Beyond code generation: Making agentic software delivery work | Team '26 Europe | Atlassian

0:08 Please welcome Atlassian head of product collection Gosha Kowalska. Hello everyone. It's great to be here and it's so exciting to talk to you about how AI is changing how teams work. Together with my friends Matt and Justin, we have a lot to cover. So, let me jump into it. The tools that we have today would have seemed like magic just a few years ago. Code that appears from a single prompt, tickets that write themselves, incident summaries generated in seconds. It would all have been impossible. And it's tempting to assume that with all this technology, our teams must be shipping dramatically more. But that's not quite what's happening.

1:05 Any conversation about AI software development naturally starts with the models and how model capability has increased exponentially. Many assume that model intelligence translates straight to organizational velocity. But what we are seeing from our data as well as hearing from customers is that engineering velocity gains from AI coding agents are starting to taper. In fact, recent DX research shows that overall productivity gains start to plateau at around 10 to 15%.

1:43 And here is why velocity stalls. Developers don't just spend time coding. On most teams, writing code is only about 16% of their work. The other 84 is everything else across the lavish cycle, across discovery, planning, orchestration, review, and operations. The bottleneck is no longer coding itself. For teams to break through the plateau of productivity, they need to optimize the full life cycle, left of code, execution through right of code. Looking internally at our teams at Atlassian across 6,000 engineers, we saw that accelerating individual coding in silos actually increased friction across the SDLC.

2:36 We realized that software delivery needed a new operating model for the AI era. First, agents need organizational understanding to make the right decisions. Second, humans and agents need to be coordinated across the workflow so that the right agents act on the right work at the right time. And third, as the workflows become more agentic, organizations needs visibility and measurement, audit trails and guardrails to understand what happened and to operate the system responsibly.

3:15 Let's start with the foundation. Without your business decisions, engineering standards and organizational knowledge, agents have to guess and this leads to hallucinations, more reviews and expensive rework. The teamwork graph built into the Atlassian platform changes that. It grounds agents in the work your team have already done across Atlassian and the third party tools that you choose to connect. That understanding becomes richer with every project, every decision and every interaction. It creates the AI advantage that compounds over time.

3:55 That's organizational foundation. But for to write code safely, agents also need to understand your code. That's why we are excited to announce the general availability of code context for Bitbucket and GitHub with GitLab coming soon adding largecale multi-repo codebase understanding to the teamwork graph together that gives agents a complete pictures through the teamwork graph your organizational context as well as your code base with code context and the results aren't just theoretical At Atlasian, the results of grounding the AI in connected context were measurable and immediate. We saw a 44 % improvement in answer quality and 48 reduction in token consumption. We've made context a key part of our foundation at Atlassian and it's what grounds everything you are about to see in the demos.

5:00 Speaking of demos, let's take a look at how Atlassian is helping accelerate software development across the entire life cycle from customer discovery all the way through planning, orchestration, delivery and measurement. Let's start left of code with discovery and ideation which is closest to my heart. How ideas make it onto the road map. As code generation accelerates, one of the key bottlenecks in software development becomes deciding what to build and making sure that you drive alignment towards the right priorities.

5:36 Getting those priorities right starts with listening to customers. But most teams aren't short on feedback. On the contrary, they are drowning in it. Just think about where your customer feedback lives today. It's trapped in emails, multiple Slack channels, gold conversations, sales emails, support tickets, I could go on. Every week, thousands of row signal pour in. The real challenge isn't capturing feedback anymore. It's hearing the signal through the noise.

6:12 And the data supports it. According to Atlasian's latest state of product report, only 4% of product teams said that they could connect their roadmap decisions back to customer feedback. And this is not good enough. That's why we're introducing feedback, a brand new app in Atlasian's product collection built for modern AI native product teams. Feedback uses AI to capture customer signals from across multiple sources, messaging channels, public portals, sales conversations. It brings those signals together so that you can use real customer evidence to shape, prioritize, and validate your road map.

7:00 Instead of manually triaging thousands of customer signals as they come in, feedback works in the background automatically tagging feedback, connecting disperate signals to turn them into insights before they get lost in the noise. From there, the feedback app automatically links signals to existing ideas or creates new ideas in Jira product discovery. As new signals come in, the team iterates on the idea to ensure the right customer context informs prioritization.

7:40 AI makes it easy to analyze customer feedback at scale and accelerates discovery, but it's still on the team to focus on alignment and decision making. With a simple prompt, teams can now create different roadmap scenarios rooted in customer evidence and in company strategy. Every road map decision is backed by customer evidence, making it easier to prioritize with confidence and align the team on what to build next.

8:15 I'm excited to share that feedback app will be generally available soon. If you haven't done it yet, make sure you join the the wait list. Now that we have customer signal helping us validate what to build and align on priorities, how do we turn this intent into engineering reality? I'm going to hand it over to Matt who will walk us through planning, orchestration, and delivery in the AI native SDLC.

8:50 >> >> Thanks, Gosha. So, now that we've captured ideas and decided what to build, what I want to do now is talk you through Atlassian's approach to actually delivering it. What we're observing both internally and with customers that we talk to is that writing code is no longer the bottleneck. The bottleneck has moved to the left and right of code. It's become things such as turning ideas into work that people and agents can do, coordinating people and agents to execute that work, and then maintaining highquality code aligned to outcomes even as the volume of code dramatically increases.

9:34 So let's start with the first challenge, capturing work into a shared system of record that people and agents can trust. As Goha showed us, work can be captured from customer insights and turned into a formal road map. But we know that new work is entering the team's backlog from every direction. You've got a bug reported by a customer. You've got a production error that needs investigating or an edge case that the team encountered. What we noticed is that a huge proportion of this non-roadmapped work comes through the team's communication tool of choice, Microsoft Teams or Slack. And these communication tools are where teams discover, discuss, and decide on how to turn ad hoc work into action. But taking a conversation and turning it into work that a person or an agent could pick up used to require a lot of tedious manual effort.

10:28 And that's why we've built the Jura cloud agent into Microsoft Teams and Slack. Teams can now mention Jira right in their thread. Jira will then capture all of the context about the work to be done and the discussion that the team had. It'll create a rich set of work items full with all of the context a person or an agent needs to be able to pick up that work. And once done, you can even delegate that work directly to a cloud agent to begin executing.

10:55 But of course, not all work starts as a textbased conversation. Some of it is easier to show than tell. Think things like a broken UX flow, a front-end bug, or a designer walking through their latest changes. For these situations, our brand new Loom to agent capabilities can turn Loom recordings into structured work items. You can simply record a Loom, describe what it is that you want done, and Loom will capture not only your voice and your screen, but all relevant clicks and logs. The result is a work item that serves as a rich prompt for an agent. In my opinion, we are all sleeping on video and Loom as an input for our agents. It's made a huge difference in my workflows, and I'd encourage you all to give it a try. So, now we have this rich backlog of work, but how do we actually get started executing against it? Well, at Atlassian, even midsize changes required years of builtup organizational context and expertise across many complex code bases. For a long time, we struggled to have AI agents operate effectively in these brownfield environments. And we know that many customers we talk with felt exactly the same. And so this is why we built teamwork collections new planner. Let's jump in and take a look.

12:06 Let's take one of those big ideas from our Jura product discovery road map. The idea itself already captures what it is that we want to achieve and why it matters, but it doesn't yet have the level of detail for an engineer or an agent to pick up. So let's use planner to turn that road map idea into a shared spec that people or agents can work from. Now planner doesn't start from a blank page because it's connected to teamwork graph. It's able to pull pull in all relevant context from your code, your repositories, your documents, and your team's prior work. And it's built for collaboration so the whole team can review and shape the output together.

12:43 I'll give you an example from my workflow. I'll typically start with a PRD. I will then hand it off to my tech lead who develops the technical spec. Once the team is aligned on the plan, planner breaks down the work into executable tasks. The goal with planner is to curate and define the context up front. This removes ambiguity for the individual agents working to deliver the plan leading to far better results particularly in these complex brownfield environments.

13:10 So now that we've planned the work, let's actually get it done. Now, in Jurro, we recognize two clear pathways that teams will want to use to invoke agents in their workflows. Local and cloud. Today, I want to take you through both. Let's start with local. We know that many developers tackle their hardest tasks on their local machines. And today, I'm excited to take you through a range of new improvements we've made to working with tools like Cursor, Codeex, and Claude Code.

13:40 First, right from the work items, teams can now choose to open in their local coding harness of choice. I can choose from a range of tools from leading providers and we'll deep link you if that's available and if not, we'll copy a prompt to your clipboard. And that prompt is going to contain all of the relevant context that an agent needs to get started on the work item. Once open and local, of course, you can use the teamwork CLI or Atlassian MCP to pull down a work item and all related context. And we know that you all love this capability. We see over 1 million monthly active users performing over 5 million actions every single day throughout MCP. To support you and your agents in getting more from MCP, we also recently rebuilt our MCP server to include a much richer array of tools for agents to use. And we improved our tool structure to make it far more efficient for agents to use the MCP to get work done. Now, usually this is about where the story ends. A developer picks up their ticket, they write some code on their local machine, they create a pull request, and if we're really lucky, they will even update the status of the work item in Jira.

14:42 Now, now that we have dozens, maybe hundreds of agents working for any one engineer, teams can quickly lose track of what's really going on, what agents are working, what agents are stuck, and what work is being duplicated. All of this rich context exists on the developer local machine, but to date, it's never made it back to the team. to solve for this and to give the team real time a real-time view of work. We're making local agents visible in Jira.

15:09 Let's take a look at that. So, let me jump into cloud code and like I do in a moment of inspiration. I just get started. While Claude is working away, let's jump over to Jar and take a look at what's happening on the board view. On the left hand side of my board view, I can now see a representation of all of the local agent sessions that haven't yet been attached to a work item. Here at the top, we can see a session. I just started it and it's captured right here on the board. We can see in real time the work item is updating with all of the state of that local session for my team to see. We can even see the pull request attached here. And when it's done, I get a chance to show you my favorite part. What I'm able to do is click and drag to take that work item over to my board.

15:52 This creates a new work item rich with a summary description and that local session attached. This ability to capture local sessions makes Jira the true representation of all of the work that your team is doing. Now, while plenty of this work is still done in local environments, we're seeing an increasing number of agent workflows moved to the cloud. And so, I want to focus there next. As we announced 6 months ago in Anaheim, Jurro now allows teams to assign and mention cloud agents from leading providers. And today, I'm really pleased to announce that Jiren now integrates with even more coding agents. That means that on top of Claude, GitHub copilot, and cursor, we're now adding Devon, Factory AI, and Warp. Now, in addition to integrations with leading coding agent providers, Jiren now integrates with a range of new third party agents to the left and right of code as well. We have Novas by Pendo, Bear Q, and more. These new agents can support with readiness, testing, verification, and monitoring. and we're excited to announce one of our most requested agents. Codeex is going to be coming later this year.

16:56 Over the past six months, we've seen teams absolutely loving the capability to assign and mention agents on work items. But in order for teams to scale their use of agents, we saw the need for teams to bring autonomous agents into their existing workflows without the manual handoff. That's why we're introducing new ways in Jira to automate agent orchestration at scale. First, teams are now able to easily configure a column on their board to automatically trigger an agent. In this example here, we have both claude and cursor configured on the in progress column with different conditions about when they'll pick up different work items. So, when we move a card to in progress, the cursor agent triggers and automatically picks up the work item. We can see the agents progress right here from the board view. And if we click to open it, we can even see all of the details about what that agent is doing.

17:46 And we've now added all coding agents, including third parties, into Jira automations. This lets you create more complex event-driven workflows with loops and branching built right into Jira. At Atassian, one of the most impactful automations that we've set up for ourselves is a scheduled task that will pull in any feature flags that have become stale. An agent will automatically remove them from the codebase and raise a pull request for the team to review. In the past month, we've already seen that half of all feature flag removals are now handled completely autonomous agents acting throughout our workflows.

18:25 But as agents speed up the delivery, we're seeing more code written and of course that means more code to review. And every one of those changes still has to be reviewed and tested and held to your organization's standards. Raise your hand if review is now becoming a bottleneck for your organization. yes, us too. And you are not alone. it turns out teams that heavily use AI to author code now wait more than twice as long for a review on a pull request.

18:50 And in the past year, the median size of a pull request has doubled. Review is quickly becoming one of the most critical bottlenecks for teams accelerating with agents in their SDLC. And that's why we're investing in the write of code, too. And how your team reviews, verifies, and ships changes. So, let's take a look at some of those exciting new capabilities. First, code reviewer, a new agent that automatically reviews your team's pull requests. It surfaces specific issues for the engineer along with the reasoning behind each recommendation.

19:18 The engineer can then resolve it, dismiss it, or approve the change. Code reviewer is now available to all Jira and teamwork collection customers in early access. Now, code reviewer is only going to be as accurate as the context it has about your team's ways of working, your code conventions, and your practices. For this, we're introducing a new capability called standards. Standards is a new feature coming soon that lets your team define the libraries and languages you use, the accessibility standards you adhere to, and the security and privacy policies that you've standardized on. You can define these once and they are then applied consistently across your codebase. You can see here the rules were provided for agents operating in a specific repo.

19:59 Code reviewer backed by standards handles the first pass, but when it's time for a human to review, understanding the change still takes a lot of effort. The next capability I want to show you is Loom's ability to add an automated visual work walk through right into your pull request. Loom captures a clickthrough of the change and turns it into a walkthrough with rich titles, a voiceover and section so reviewers can understand the change. This is now available in early access and I know as a PM I love this feature because it means I don't have to set up a local dev environment in order to participate in the review process.

20:31 Now, we all know that a broken build, flaky tests, or an error run can easily take time away from the team fixing issues that could have otherwise been addressed by an agent. That's why we've built Agentic Pipelines into Bitbucket. Agentic pipelines enable agents to automatically fix pipeline failures within the guardrails you set. When a build breaks or a vulnerability is detected, the agent analyzes the failure, isolates the root cause, and opens a pull request complete with test results and the audit trail across planning, orchestration, execution, and review. We keep seeing the same pattern that the biggest gains don't come from adding agents everywhere. Instead, they come from redesigning the workflow around what people and agents do best.

21:14 But building the workflow is only half of the story. The other half is knowing what is actually working. And for that, I'm going to hand over to Justin. Hello. So, we have just seen how Atlassian connects the AI powered software life cycle, but it's really only half of the story. As Matt mentioned, you also need to know whether these investments are actually working.

21:45 you know, are our agents actually accelerating our delivery? Is quality being maintained alongside all this new velocity? So, I have hundreds of conversations with engineering leaders over the course of a year, and we hear the same concern over and over again. They're they're flying blind, right? Productivity measurement was difficult before AI came along, and now we're accelerating that. So, they can see the AI tools they've purchased. they understand how many tokens teams are consuming and they even know how much code AI is actually generating but they don't have visibility into whether teams are actually delivering faster and whether quality is holding up and whether agents are even introducing new friction elsewhere in the life cycle and the value stream. So this is why DX is such a great fit as part of Atlassian's AI native SDLC. DX helps provide the engineering intelligence to pinpoint SDLC and agent hotspots and friction points and see where AI is accelerating delivery and where new friction actually emerges where do the constraints move so to show the real impact of these AI initiatives we have to move beyond just simple adoption metrics which tell us some things about what's happening in the organization but we need to measure real velocity we need to see how value is now flowing through our system and of course the impact on our quality. So, DX helps organizations accelerate AI readiness as well readiness of the platform and software health by tracking repo health, service ownership, and documentation quality so that agents have the environment that they need to be successful. So, before we get further, let's circle back to something we've been talking about, you know, throughout this presentation. customers are using more AI tools than ever. and this slide shows what it actually looks like on the balance sheet. You know, we we we have a lot of metrics that we have access to at the moment. This is the only exponential one. AI spend certainly see keeps climbing. We have more seats and more tokens and more tools that we're using.

23:49 But this is the part that should really get our attention right now in the data. We're not seeing this actually increase the organization's innovation ratio, which is the percentage of time that engineers can spend working on new features and new value as opposed to keeping the lights on and maintenance work. And this is a real gap, right? And if you don't have visibility into where AI is delivering value and where it doesn't, it's not a gap that's going to be easy for you to close, right? And this is exactly where DX comes in. So DI DX's AI impact report connects AI adoption. So our utilization metrics coming from telemetry directly to delivery speed and quality across the SDLC and we do this by benchmarking heavy AI adopters against a comparison cohort to isolate really the true productivity delta. We're taking the utilization metrics and we're cross-referencing them to our trusted core productivity metrics. and so on the surface the signal is strong. you know metrics like our true throughput which is a form of PR or MR throughput that actually factors in code complexity as well not not just the volume of PRs shows in this case AI assisted team shipping significantly more work but there is a catch look at the PR revert rate here you know that same speed is also driving more re rework and driving more roll backs and so this is the kind of insight that's going to enable organizations to take more targeted action right addressing things like better prompt guidance and context engineering and reviewing guardrails to make sure that AI velocity actually translates into more production value.

25:31 So proving overall throughput and spotting spikes and revert rates is really just the first step here, right? Leaders also need to know exactly where in the delivery life cycle that friction is coming from. You know, it's one thing to understand, you know, maybe we have a block or two or ROI in one place, but what should we focus on to fix that? So, let's take a look at how we determine that. When we break down cycle times in this example, we find something sort of counterintuitive here. Our heavy AI users are actually taking 7% longer to deliver a a final product. And this is actually something I see way more commonly than you might think with the customers that I speak with when I look at the data. But how is this possible when developers are generating code, you know, faster than ever? Well, when we drill in, we can really see here a sharp spike in defect ratios and incident counts showing up in our deployment part of the life cycle. We can see that code is getting to the review fast, but without the right context and guard rails, it's failing in production.

26:34 So, quick show of hands here. How many people are looking to better understand and control their costs around AI? Right, we got this 40x increase that we're kind of seeing. our AI cost measurement dashboard gives leaders a very clear view of their AI spend and their token consumption over time across multiple models across tools and across teams. You can identify your largest cost drivers and importantly you can compare that investment with the outcomes that are being produced. So you can find the right balance between cost and quality and and value.

27:10 So using historical usage patterns, the cost management dashboard also can forecast future spend. And this can help leaders understand and set in form budgets before these costs become unpredictable and while we're still very heavily subsidized that way. another key way that DX helps organizations control their AI spend is by matching the right model to the right kind of work. Right? So our model fit analysis dashboard which is currently in open beta compares how different models are going to perform across different types of work. so with a grid here in the middle we can see which types of models are well suited to specific tasks. Right? So we could see refactors are running on higher cost models right now that could actually maybe shift to a lighter one to see some immediate savings while still meeting the needs of the use case. while performance improvements in this case might benefit from a more capable model to lift overall quality and the outcome of that use case. And of course this can be used as context to drive what we're all going to be working on which is better model orchestration, better model routing, token economics and all of those things. But measuring effectiveness alone and cost is is it only matters when those insights can actually lead to action. Right? At DX from the very beginning, this data has always been about creating virtuous cycles of continuous improvement within your R&D organization. And so DX is going to help customers close that loop by providing helpful context and additional guard rails to continuously improve the agentic development that we're doing. our software component catalog then gives developers and agents a shared context who owns what how services depend on one another and where that knowledge actually lives.

28:52 So while scorecards give leaders and platform teams and developers a shared view of software health while also helping organizations continuously assess AI readiness standards across your repositories from documentation and test coverage to compliance and architectural guidance. So that brings the entire measurement to journey together into a very clear and repeatable system. All right, the loop is pretty simple. Observe the impact, diagnose the friction, improve the context and guard rails, and then measure whether performance actually improves. And this is how organizations move from disconnected AI experiments to a governed and continuously improving system that can deliver measurable value.

29:38 So bringing all these pieces together, the AI native SDLC isn't defined by any single agent. It's a connected system underneath every workflow and it starts with customer intent. The feedback app as part of the Atlassian product collection can help terms teams turn scattered customer signals into evidence-backed ideas priorities and road maps. And these priorities then flow into the system of record. Jira and Confluence and Loom were the teams that define their work, capture their knowledge and communicate intent. The teamwork graph connects that work with people, knowledge and relationships surrounding it, forming a lithography for the value stream within your organization and agents or Atlassian's third party as we've seen a range of agents we can integrate with now operate directly inside that system. working from the same context as your teams models and agents will continue to change. The system of record and context underneath then becomes the durable foundation.

30:36 And finally, measurement gives leaders visibility into how people and agents and processes are performing across the entire life cycle because you can't improve an AI powered organization if you can't see how it's working. And that's the complete picture. a system of record, a connected context, embedded agents, each layer making the others more valuable. And this is how AI moves from a collection of disconnected experiments to a governed and measurable way of working. Thank you. And to close, we hope you will check out our brand new, it's like 4 days off the press, AISLC transformation playbook, giving you a practical framework for navigating the AISLC. Thanks very much and enjoy the rest of the team.