Software teams have taken to coding agents faster than almost any tool before them, and yet shipping software hasn't sped up to match. Atlassian has put a number on the gap. In a longitudinal study the company ran with the engineering intelligence platform DX, the volume of AI-authored code nearly doubled over three months, while developer productivity gains stalled – topping out at around 15%, and coming in below 10% at many organizations.

On the back of this comes an announcement from Atlassian with a set of new capabilities in Jira and the Teamwork Graph aimed at the work that surrounds the code rather than the coding itself. Ming Wu, Head of Engineering for Dev AI at Atlassian and joined around two years ago from Microsoft and GitHub, walked me through the reasoning ahead of the launch. Her starting point is that writing code was never where most of the effort went.

The coding part, it's an essential part, but it's only fifteen to sixteen percent of the time. All the rest comes from planning and iterating on the design and alignment, and addressing all the issues when it goes out, and the code review.

The rest of the software development lifecycle is where the cost lives, and Wu says this is the part that a lone coding agent tends to handle badly.

Atlassian's shorthand for the shift is that work becomes human-steered and agent-executed. Asked what steering means when you take the word literally, Wu was clear that the senior engineer's job doesn't shrink.

I actually don't think the human's role, the main role, has changed. The human is the one holding the responsibility of how this thing will ship, and what you're going to ship, or when. AI tools, it's very fast, but it doesn't know what to do.

What changes is the typing and the small, well-defined tasks around it. She explains:

I don't have to type anymore, but I still have to see. I have to tell it what to do.

That leaves the repetitive work – tech debt, feature-flag clean-up, small atomic fixes – as the part an agent can absorb, and frees people for the more complex and creative work. The point she emphasizes is accountability – a human still has to sign off on whatever ships.

Atlassian says that for this shift to actually work, three things have to be true. Intent has to be structured before work starts, so an agent gets the requirement, the architecture, the decision history and the constraints, rather than a one-line summary. The agent should be a runtime choice rather than a process one, so a team can reach for the Cursor integrated development environment on one task and Claude Code on another without the workflow forking each time. And autonomy has to stay observable, so agent work doesn't vanish into terminals and browser tabs.

Running through the announcement is the Teamwork Graph, which Atlassian describes as its context layer – a map of work, code, people, decisions and dependencies that pulls together the task in Jira, the requirements in Confluence, the conversation in Slack, the code context from GitHub, and customer insight from Jira Product Discovery. Wu observes that the context layer is harder to build than it sounds, and she believes it matters more than the agents themselves. She elaborates:

The context layer is not about the raw data. How do you actually retrieve, efficiently and smartly, only the relevant ones? We all know documents go obsolete.

She calls the work of selecting the context that's actually relevant as context engineering, and she's put a good deal of Atlassian's investment there. She was also explicit that it's a claim many companies make and few follow through on, and she leaned on her own background to say so:

I come from Microsoft, and I was in GitHub. The context graph is always the hard topic that every company claims they do. But not everyone actually puts in serious effort.

Without it, Wu notes:

An agent won't work well if you just throw everything together.

Starved of context, according to Atlassian, an agent solves a ticket too literally, misses an architectural constraint, or produces a pull request that looks plausible until a senior engineer spends an hour unwinding it. Jim Mercer, Program Vice President for software development, DevOps and DevSecOps at the analyst firm IDC, made the same point:

Agents operating without a deep understanding of team decisions, architectural constraints, and project history produce misaligned code more quickly, leading to technical debt and production issues.

Getting into the details, these are the elements that are shipping:

Getting the context in. Jira Planner brings spec-driven development into Jira. For complex projects, Atlassian says it pulls from the codebase, from Jira and Confluence history, and from team context to produce a structured technical specification in Confluence, readable by a person and usable by an agent. Wu describes the target as brownfield work, the tangled existing systems where an autonomous agent tends to come unstuck, and she doesn't pretend the people can be designed out of it, explaining:

Especially from what I see in banking and finance, that type of more rigorous environment with a lot of dependencies, you cannot skip the complexity of the real-world problem, and also the collaboration. You actually do need the people coming in.

Alongside it, Jira for Slack turns a thread into a work item when a team asks @Jira, keeping the conversation that shaped a decision attached to it. Loom video prompts take a screen recording and a spoken walk-through, and turn them into structured instructions an agent can act on.

Delegating and watching the work. Agents in Jira lets teams assign a work item to Claude Code, Cursor, or GitHub Copilot directly, with OpenAI's Codex listed as coming soon. The Jira Coding Agent, now built into every paid Jira plan at no extra cost, takes a well-scoped item and returns a ready-to-review pull request for routine fixes without a developer dropping into a local environment. Agent sessions in Jira, together with new Teamwork Graph command-line interface hooks, link a local terminal session back to the Jira item it belongs to, so the record survives a closed laptop.

Governing the cost and the scale. Coding agent automations let teams route routine work – bug fixes, vulnerability remediation, test generation, documentation updates – through Jira's automation rule builder, with an engineer notified when a pull request is ready. The Agentic Engineering project template and a setup wizard stand up an agent-ready project with workflows and integrations pre-configured. DX AI cost management gathers spend and token data across tools such as Claude, Cursor and GitHub Copilot alongside Jira, and estimates a cost per pull request.

Atlassian ran these patterns across its own engineering organization before shipping them. In an internal study of 6,000 engineers using the new capabilities, the company reported a 44% rise in agent task completion efficiency, a 48% drop in token consumption, a 36% reduction in pull request cycle time, and 51% of routine code vulnerabilities resolved autonomously and queued for developer review.

The work is done by an agent, and then it waits for a person to review it before it merges. For atomic, well-scoped tasks such as vulnerability tickets, Wu puts the internal automation rate in the region of half to two-thirds, adding:

The more complex the task is, you will have to interact and tell the agent.

We also talked about benchmarks and how often a ready-to-review pull request merges with only light review. Wu points to the SWE-bench coding benchmark. She notes that the full set sits in the low 40s and the verified set far higher, but doesn't put much weight on it, observing:

Honestly, I think SWE-bench is saturated. It's also open, so everyone sees that. Take the numbers with a grain of salt. We're not banking on that too much.

On strategy, she places Jira as the layer that sits across those agents rather than a rival to the model builders, and agrees that some of the positioning is still moving.

Jira is well positioned to be that orchestration layer. It has to be, because nobody else would be in that role. Atlassian is not a model player. I don't think that's our competing strategy right now.

She ends on the point that the collaboration only works once an agent can be trusted with the context a colleague would have:

You work with your teammate only when they understand your context. Then you can trust them to actually work together with you.

Atlassian says Agents in Jira for Claude Code, Cursor and Copilot, along with Jira for Slack, the Jira Coding Agent, agent automations, the agentic templates, and agent sessions, are available now for paid Jira Cloud customers at no additional cost. Jira Planner is in early access, and Codex in Jira is listed as coming soon. DX AI cost management is available to Atlassian DX customers.

The agent clears the routine vulnerability, and a person still looks before it merges. Using a metric of "queued for developer review" feels like a much simpler explanation of human-steered and avoids hype.

Earlier this year I talked to several Atlassian experts about the Teamwork Graph pitch and spent a good part of those conversations pushing on whether it was real yet or still a keynote slide – how fresh the context actually was, how fast the graph knew when something had changed. A few months on, every agent capability in this launch leans on it, and the context layer is now carrying the whole product.

Atlassian has put its coding agent in every paid plan, and its real effort into context and governance, rather than joining the ongoing vendor agent race. The memory of what your team decided, and the record of who signed off before it shipped, are Atlassian's solid ground, because of its strong history as the system of record.