.webp)
The Six-Month Test: Atlassian's Agentic Pivot and the Work Around Code
There is a question nobody asks during the coding-agent demo, because the demo is going well and the question would be rude. Six months from now, when this change is implicated in an incident, can anyone in the room explain why the agent did what it did?
Atlassian just asked it for you. In The Agentic Pivot, a research report published September 3 and introduced by Derek Cheng, Atlassian’s Head of Engineering, the company surveyed more than 1,100 engineers and engineering leaders about AI-native software delivery. According to that survey, only 15% of engineers and 25% of leaders are very confident they could reconstruct the reasoning behind an AI-assisted decision six months later. I would put that number on a wall somewhere near the CTO’s office. It is the whole report in one sentence.
What Atlassian actually published
First, a release-state note that is refreshingly easy this time: this is research, not a product. There is nothing to enable, no tier gate, and no rollout wave. The report lives at atlassian.com/whitepapers/the-agentic-pivot behind a short form.
The headline numbers, all attributed to Atlassian’s survey rather than to me:
- 94% of engineering leaders say their organizations use AI somewhere in the software development lifecycle, and 36% already run agentic workflows with limited human intervention.
- 74% say AI has accelerated code generation. 78% say their teams still rely on the same traditional peer-review process for that larger, faster volume of AI-generated code.
- 88% of leaders say they need a governed engineering system of work for AI. 19% say they have built one. Only 6% describe their organization as having moved to a formalized, AI-native system of work.
Atlassian’s framing is that AI has compressed the implementation phase while leaving the phases on either side of it, planning, testing, review, and ship-and-monitor, largely untouched. Those phases have become the new bottleneck. The report calls this territory “the work around code,” which is a phrase I expect to be hearing in steering committees for the next year.
Standard caveat, applied evenly: this is vendor-commissioned research, and the exact percentages deserve to be held loosely. The shape of the findings, though, matches what the whole industry has been living through since the first autocomplete suggestion landed in an editor.
The bottleneck did not disappear. It moved.
Read the 74% and the 78% together and you get the report’s real argument. Most organizations accelerated exactly one phase of delivery and left the surrounding process as they found it. Review is the place that shows the strain first, because review was always a context-reconstruction exercise. The reviewer needs the requirement, the constraint, the prior decision, and the evidence that the change does what it claims. When a human wrote the code, a lot of that context was in the human’s head and could be extracted with a comment thread. When an agent wrote it, the context was in a chat session that has since scrolled away.
So the reviewer reconstructs. Then the next reviewer reconstructs. Multiply that by the volume increase AI brought, and you arrive at the 78%: the same review process, now asked to do a job it was never designed for at a scale it was never designed for.
The part I think most people will skim past
The most interesting idea in the report is buried under a modest heading about capturing what agents do. Atlassian argues for an agentic system of record: a place where an agent writes back what it did, the context it used, the decisions it made, what remains unresolved, and what should happen next.
Strip away the AI vocabulary and this is a documentation discipline being extended to non-human contributors. Human engineers already have this scaffolding. Commit messages, pull request descriptions, architecture decision records, the “why” field on a ticket. Agents, in most environments today, have a transcript that lives in someone’s IDE and nowhere else. The 88-versus-19 gap is not primarily a tooling gap. The tools to record what an agent did exist in every serious platform. The gap is that nobody has decided what an agent must write down before its work counts as done.
That is a governance decision, and governance decisions are cheaper than licenses. It is also the same lesson we keep arriving at from different directions. When we wrote about Jira hiring an agent who codes, the conclusion was that the ticket had quietly become the prompt. This report extends that: the ticket also has to become the receipt.
Atlassian’s three moves, and what they map to
The report closes with three moves for engineering leaders. Each one corresponds to something concrete in the Atlassian stack, with the usual release-state fine print.
1. Make intent and context explicit before code is generated
When implementation is cheap, building the wrong thing becomes the expensive failure. Specifications, architectural guardrails, engineering standards, and test expectations need to be first-class inputs rather than things a senior engineer remembers to mention. This is the territory Jira Planner was built for, and it is worth remembering that Planner launched in Early Access in August, with Rovo, Teamwork Graph, and Confluence as prerequisites. If your acceptance criteria field is empty on most work items, Planner will not fix that. It will faithfully plan from an empty field.
2. Extend AI beyond code generation
Atlassian names two opportunities: testing and quality, and observability and incident triage. Survey respondents already rank quality as the top place they would reinvest capacity freed up by AI, yet AI-automated guardrails remain a minority practice. On the Atlassian side, this is where Rovo Dev’s code review role and Bitbucket’s Agentic Pipelines earn their keep. The flaky-test agent remains my favorite example of the pattern done well, because its final step is a draft pull request handed back to a named human. The agent does the archaeology. The human keeps the merge button.
3. Make agent work traceable and observable
Teams need to see which agents are active, what context they used, where they are blocked, and how key decisions were made. In Jira Cloud, the My agent sessions view on the For You page groups every session by needs input, working, and finished, and requires Rovo to be activated on the site. Pair that with the consumption meters that arrived with Atlassian’s expanded usage-based pricing and you have both halves of the ROI conversation the report says leaders are struggling to have: what the agents did, and what it cost.
Who should care, and who can wait
If your organization is in the 36% running agentic workflows with limited human intervention, this report is describing your next incident review. Platform owners, security and compliance leads, and anyone who signs off on release management should read the traceability section twice.
If your teams are still using AI as a smarter autocomplete inside the editor, you have time. Use it to do the unglamorous work in Move 1, because it costs nothing in licensing and it is the prerequisite for everything else. Nobody has ever regretted having acceptance criteria written down before an agent showed up.
What to do this quarter
- Run the six-month test on your last ten AI-assisted merges. Pick them at random. For each, ask a reviewer who was not involved to explain why the change was made and what constraints applied, using only what is written down in Jira, Confluence, and the pull request. Score it. That number is your baseline, and it will be more persuasive than any survey.
- Inventory where intent actually lives. Tickets, Confluence pages, Slack threads, one architect’s memory. Anything in the last two categories is invisible to an agent and to the reviewer six months from now.
- Write the agent’s Definition of Done. Decide the minimum an agent must record before its work is reviewable: intent referenced, context sources used, decisions made, open questions, verification evidence. Put it in the workflow, not in a policy document.
- Pilot one phase to the right of code. Test remediation or incident triage, not both. Measure review time before and after.
- Put a number on it. Agent sessions tell you what happened; the usage meters tell you what it cost. Report both to leadership on the same page.
The Avaratak Take
This report is a mirror, not a roadmap, and I mean that as praise. Atlassian has not announced a feature called Governed System of Work, and I would be wary of any vendor that did. A governed system of work is a set of decisions: where intent lives, who approves, what gets written back, and what evidence a change must carry before it ships. The platform can enforce those decisions once they exist. It cannot make them for you.
The place I expect organizations to overreact is Move 3. Observability dashboards are satisfying to look at, and a session view full of finished agent work feels like progress. Without Move 1 underneath it, you are watching agents execute unclear intent at speed, with excellent visibility into the wrong thing. Sequence matters. Intent first, write-back discipline second, dashboards third.
The place I expect organizations to underreact is the 78%. Keeping the same peer-review process while the volume of code doubles is not a neutral choice. It is a decision to let review quality degrade quietly, and the report is polite enough not to say that out loud. I am less polite. If the review process has not changed since agents arrived, the review process is where the next surprise is coming from.
Atlassian’s bet is that the system of record for human work should also be the system of record for agent work, and that Jira, Confluence, and Bitbucket are already sitting in that seat for most of its customers. I think that bet is right for organizations that have kept those tools honest. For everyone else, this report is a very well-timed reason to start.
If you want a second set of eyes on how your environment would score on the six-month test, that is exactly the kind of conversation Avaratak’s senior consultants have. Book a discovery call and bring your last ten merges.