TL;DR
- Extreme Programming (XP) was a set of ways to shorten the distance between intent, implementation, feedback and correction. Coding agents shrink the implementation part of that distance and leave the rest roughly where it was. The bottleneck moves to planning, coordinating people, validating changes, and making decisions.
- The evidence so far points the same way. Teams with high AI adoption merged 98% more pull requests while review time rose 91% (Faros AI, 2025). DORA calls AI an amplifier of whatever an organisation already is. Thoughtworks' Technology Radar names review capacity as the constraint when developers run more agents.
- I call my adaptation AI-native XP. It keeps XP's practices but reorganises the team around continuous feedback that actually changes later decisions, cross-functional collaboration around one shared context instead of handoffs, and collective understanding of the system, its decisions and their reasons, held outside any one person's or agent's session.
- It also means measuring different things. When code is cheap, pull requests and story points stop telling you much (they were always a crutch for human effort and attention anyway). Feedback latency, rework, decision latency and how stale the team's context is tell you whether the team is learning.
What XP Was For
According to the History of Extreme Programming page on Ward Cunningham's wiki, Kent Beck was brought in to performance-tune Chrysler's payroll project and decided to "turn all the knobs to ten". If code review was good, review all the time, and you get pair programming. If testing was good, test all the time, and you get test-driven development. If integration was risky, integrate many times a day. If customers' feedback was valuable, bring the customer into the conversation with the team.
Each of those knobs works on closing the time between deciding something and finding out whether it was right. The second edition of Extreme Programming Explained built the method on the values of communication, feedback, simplicity, courage and respect, and on "short development cycles, resulting in early, concrete, and continuing feedback."
Most teams know XP as a list of practices. I think it's more useful as a theory that software projects fail in the gap between a decision and the evidence about it. Coding agents change the size of that gap in one place and leave it alone everywhere else.
My working thesis / definition I'll use for the rest of the post is this:
AI-native XP is a way of running a team in which people and AI agents continuously turn intent into working software, check the outcome, and refine both the product and their shared understanding of it.
It helps to separate this from where most teams are now. AI-assisted development keeps the existing process and uses AI to speed up implementation, testing and refactoring inside it. AI-native development reorganises the team around the fact that implementation has become much cheaper, while planning, coordination, validation and decisions cost what they always did.
The Bottleneck
Fred Brooks made the arithmetic point in 1986, in No Silver Bullet: "Unless it is more than 9/10 of all effort, shrinking all the accidental activities to zero time will not give an order of magnitude improvement." Swap "accidental activities" for "typing the code" and you have the current situation. However fast implementation gets, the time from idea to validated change can't fall below the time spent on everything else.
That is eseentially Amdahl's law applied to a delivery pipeline, and it's easy to see with your own numbers. Set how much of your lead time is implementation today, then how much faster agents make it:
Show the numbers
| Implementing share, p | s = 1× | s = 2× | s = 3× | s = 5× | s = 10× | s = 100× |
|---|---|---|---|---|---|---|
| 20% | 100% | 90% | 87% | 84% | 82% | 80% |
| 30% | 100% | 85% | 80% | 76% | 73% | 70% |
| 40% | 100% | 80% | 73% | 68% | 64% | 60% |
| 50% | 100% | 75% | 67% | 60% | 55% | 51% |
| 60% | 100% | 70% | 60% | 52% | 46% | 41% |
| 70% | 100% | 65% | 53% | 44% | 37% | 31% |
| 80% | 100% | 60% | 47% | 36% | 28% | 21% |
The model assumes the rest of the work stays the same size. The evidence so far says it grows, and more time is spent on reviews and rework. Faros AI's telemetry from over 10,000 developers across 1,255 teams found that developers on teams with high AI adoption completed more tasks and merged far more pull requests, while the work that lands on reviewers grew faster still:
- Output
- Load on reviewers and quality
Show the numbers
| Measure | Change | As the report puts it |
|---|---|---|
| Tasks completed | +21% | “complete 21% more tasks” |
| Pull requests merged | +98% | “merge 98% more pull requests” |
| Average PR size | +154% | “a 154% increase in average PR size” |
| PR review time | +91% | “PR review time increases 91%” |
| Bugs per developer | +9% | “a 9% increase in bugs per developer” |
DORA's 2025 State of AI-assisted Software Development, from nearly 5,000 technology professionals, put it more directly: "AI's primary role in software development is that of an amplifier. It magnifies the strengths of high-performing organizations and the dysfunctions of struggling ones." Ninety percent of respondents used AI at work, and 30% reported little or no trust in the code it generated. The 2024 report had estimated a 1.5% drop in delivery throughput and a 7.2% drop in delivery stability for every 25% increase in AI adoption. In 2025 throughput had turned positive, but AI adoption "still increases delivery instability."
And Thoughtworks' Technology Radar, Volume 35 names the constraint outright: "As developers run more agents, their attention and review capacity become bottlenecks." It also quite rightly points out that "when review can't keep up, oversight risks becoming human-in-the-loop theater."
The part agents speed up was rarely the slowest part of the work. Most of what remains is the problem XP was built to solve, because a team still has to find out, as quickly as it can, whether it was right.
XP Dev Practices REDUX
Most of XP's practices carry over with little more than a new name, and a few change shape.
| Traditional XP | AI-native XP |
|---|---|
| Pair programming | People pairing with agents, people pairing with people, and engineers steering |
| Test-driven development | Executable acceptance criteria, agent-written tests that people steer, property-based tests and automated evaluation. The aim is a change a machine can verify |
| Continuous integration | Small agent-written changes implemented, verified and integrated continuously, with the wider team kept in the loop |
| On-site customer | Product and engineering working together continuously, with agents helping turn business intent into executable requirements |
| Collective code ownership | Shared ownership of code, architecture, context and decisions, across people and agents |
| Simple design | Explicit architecture constraints, complexity budgets and continuous simplification |
| Small releases | Feature flags, incremental deployment and delivery validated in stages |
| Refactoring | Automated detection and repair of complexity and design drift, all the time |
| Sustainable pace | Managing people's cognitive load, review capacity and the amount of agent work in progress |
Two of those rows need expanding on a little. Refactoring is the practice most at risk of quietly rotting. GitClear's analysis of 211 million changed lines found that "moved" code fell from 25% of changed lines in 2021 to under 10% in 2024, while cloned lines rose from 8.3% to 12.3%. Moved code is mostly what refactoring leaves behind. If agents write more of the code, someone has to ask for simplification explicitly, because it no longer happens as a side effect of a person editing by hand. Sustainable pace now has a second meaning. A team can exhaust its review capacity long before anything else, and an agent queue never gets tired, so the limit has to be set with serious intent.
Continuous feedback, cross-functional collaboration and collective understanding matter more than the others, because they change how the whole team operates rather than how fast one developer works. The rest of the post is mostly about those three.
Feedback as the Organising Principle
I'd design the team's engineering system around five feedback loops, each running at a different timescale. Reasoning sits in the middle and runs all the time. Product outcomes sit on the outside and take days or weeks.
Show the numbers
| Loop | Typical timescale | Evidence it produces |
|---|---|---|
| L5 Product outcomes | Days to weeks | adoption, usability, commercial value |
| L4 Production | Minutes to days | telemetry, incidents, user behaviour |
| L3 Integration | Minutes | CI, contracts, dependency checks |
| L2 Implementation | Seconds to minutes | tests, static analysis, review |
| L1 Reasoning | Continuous | intent, assumptions, design decisions |
Speeding up each loop is easier to sell than it is useful. The harder requirement is that evidence produced in one loop changes a decision in another. Four examples of this:
- An agent hits an architectural constraint nobody wrote down while implementing a feature. If that knowledge stays in the agent's session, the next engineer and the next agent will hit it again. It has to reach the shared design.
- Production telemetry shows latency rising. An agent ties the regression to a recent change, reproduces it and proposes a fix. An engineer decides whether to take it.
- A product manager sees users doing something nobody expected. The team should revisit the hypothesis behind the screen, as well as the screen.
- Agents keep failing on the same component.
The last example gets less attention than it should. Agent failures are evidence about the engineering environment. If several engineers or agents independently struggle with the same module, the module, its interfaces, its documentation or its tooling is probably at fault. Developer experience has always been hard to measure because people work around friction quietly, whereas agents log every retry, revert and abandoned attempt. Counted per component, those logs make friction visible as part of the system's own telemetry.
A verification contract
An autonomous implementation loop needs to know when it has finished. I'd make that explicit in a contract that the agent and the engineer both read before the work starts:
# Verification contract for one change (an example)
goal: Users can resend the verification email from the onboarding screen
done_when:
- acceptance tests in onboarding/resend.feature pass
- p95 latency of POST /verify/resend stays under 300 ms in the load test
- no new errors in the onboarding funnel 24 hours after the flag is on
authoritative_evidence:
- CI on the merge commit, not the agent's local run
- the load test in perf/onboarding.k6.js
may_change:
- services/onboarding/**
- web/src/onboarding/**
must_not_change:
- the public API schema in api/openapi.yaml
- existing tests, except to add cases
stop_and_ask_when:
- a fix needs a change outside may_change
- the same check fails three times in a row
- the evidence contradicts the acceptance criteria
accepted_by: the engineer pairing on the change
It says what counts as success, which evidence is authoritative, what the work may change and when to stop. Those questions aren't specific to agents. Engineers do better work when they know the answers too, and a lot of rework comes from people who didn't.
Anthropic's own guidance for Claude Code describes the failure this prevents: "Claude said it was done and it wasn't quite, usually because it had no way to check its own work." Birgitta Böckeler's harness engineering article on martinfowler.com names the two halves. Guides "anticipate the agent's behaviour and aim to steer it before it acts", and sensors "observe after the agent acts and help it self-correct." A verification contract is a guide that tells the agent which sensors count.
The most important line in the contract is the last one. Feedback and judgement are different things, and they need different owners. A compiler can establish whether code compiles. It can't establish whether the product solves the right problem. Some questions a machine can settle, and an agent can fix its own work against them and retry. Others need a person, and the agent's job is to bring them the evidence.
Show the numbers
| Question | Authoritative evidence | Who decides | What an agent may do |
|---|---|---|---|
| Does it build? | Compiler, type checker, linter | Tooling | Fix and retry |
| Do the tests pass? | The test suite | Tooling | Fix the code, not the test |
| Do the contracts hold? | Contract and property tests, schemas | Tooling; engineers own the contracts | Fix the code; propose contract changes |
| Is it within budget? | Benchmarks, telemetry against a budget | Tooling, against a budget people set | Fix within scope, or stop and report |
| Is the design still simple? | Review, complexity signals | Engineers | Flag it |
| Is it right to use? | Design review, usability sessions | Design | Flag it |
| Did it solve the right problem? | What users do, outcome measures | Product and the team | Gather the evidence |
The On-Site Customer
XP's on-site customer put the person who knows what the software is for in the same room as the people building it. In 1999 that was (to say the least) a radical idea. Today I would extend it to every function the work passes through.
In most organisations work moves through functional boundaries. Product defines requirements, design produces mock-ups, engineering implements them, QA verifies them, operations runs the result. Each handoff is a translation or compression, and each step is lossy. It loses some of the intent and adds latency and then feedback has to travel back through the same chain.
- Roles
- Shared context
- Where the work happens
AI can make this better or worse. It makes it worse when agents become one more layer of translation. One agent turns a product brief into tickets, another turns tickets into pull requests, and a third summarises the pull requests for the product manager. That's the same handoff chain, automated.
It makes it better in three ways. People in one function can interrogate the reasoning of another. An engineer can ask why a design decision was made, a designer can explore what an interaction costs technically, and a product manager can see which assumptions are expensive to validate. Questions can be explored while the people who asked them are still in the room, so a designer and an engineer can have an agent build a working prototype during the conversation instead of raising a ticket and booking another meeting. And the outcome of a conversation can be kept as structured, versioned knowledge that shapes the next piece of work, instead of evaporating when the call ends.
None of this replaces people talking to each other but the intent is to make those conversations more productive and keep what they produce.
An example: onboarding drop-off
Say a team with a product manager, a designer, three engineers and an engineering manager, all with access to shared coding and analysis agents, finds that a large share of new users abandon onboarding. In the AI-native version:
- Product and design go through the behavioural data with an agent to find the likely points of friction.
- Engineering checks whether performance, validation errors or API behaviour contribute.
- The team argues through competing hypotheses, with evidence, quick prototypes and feasibility assessments on the table.
- An agent produces a small implementation, with tests and the telemetry changes needed to measure it.
- Engineers validate the implementation; design checks the interaction against the intended experience.
- The team ships it behind a feature flag, watches what users actually do, and revises the hypothesis if needed.
The steps overlap and loop back on each other, and the team counts progress in hypotheses it has tested rather than tickets it has closed. Eric Ries put the same idea at the centre of Lean Startup: "The unit of progress for Lean Startups is validated learning", and Barry O'Reilly's hypothesis-driven development carries it into engineering: "We do not do projects anymore, only experiments." I'd argue that's closer to the original spirit of XP than a heavily automated pipeline from ticket to pull request.
Collective Understanding
Collective code ownership was XP's answer to bottlenecks. Anyone can change any part of the code, so no one person blocks the team and everyone is responsible for the whole. I'd extend it to collective ownership of knowledge.
In a team that uses agents heavily, the knowledge needed to change the software is scattered across code, design files, tickets, documentation, chat threads, production telemetry and individual memory. Agents are far more sensitive to that fragmentation than people, because they arrive at every task with no memory of the last one. A person can remember that the billing service has a quirk. An agent knows only what it's given. If the team doesn't keep a shared, versioned record of its knowledge, the agents will never know it either. An additional risk is context rot, agents are extremely sensitive to stale context, and a team that doesn't keep its knowledge up to date will find its agents making the same mistakes over and over.
I'd keep a shared, versioned body of knowledge with at least these parts:
| Knowledge | What it records |
|---|---|
| Product intent | Problems, hypotheses, outcomes and priorities |
| Architecture | System boundaries, constraints, ADRs and trade-offs |
| Contracts | APIs, schemas, invariants and acceptance criteria |
| Engineering conventions | Standards, testing strategy and development workflow |
| Operational knowledge | Reliability expectations, incidents and production behaviour |
| Decision history | What was decided, why, by whom and when |
Keeping it true takes more work than writing it, so it needs continuous reconciliation. When a code change invalidates an architecture document, an agent should flag the inconsistency. When an incident reveals an invariant nobody had written down, that lesson should land in the shared record as well as the postmortem.
This is where the work I've called Compiled Context fits. In Context as a Compiled Artefact I argued that context should be built from canonical sources by a deterministic process that keeps provenance, rather than accumulated in a model's working memory or a vector store. For a team, that means canonical knowledge lives independently of any agent session, and the context for a particular task is assembled from it when the task starts (Bounded Execution and Selective Memory covers the execution side). Anthropic's context engineering guidance makes a related point: "Context, therefore, must be treated as a finite resource with diminishing marginal returns."
That makes context quality an engineering concern, with owners and checks. Every important decision should be traceable to its source and its current validity. Without that, the default is a pile of agent memories and summaries of summaries that gets less reliable each time it's compressed.
Pairing
Classic pair programming has a driver and a navigator. With agents, I see three useful modes:
Two people and an agent. For complex design, ambiguous problems and mentoring, this is the mode I'd reach for first. The two engineers argue about the problem; the agent is sent off to try an alternative, check an assumption, write a plan or build a throwaway experiment, and comes back with something to look at. The humans can then judge it, annotate it, and send it back for another iteration. The agent is a third pair of hands, not a replacement for thinking and judgement.
A person and an agent. This is the closest thing to classic pairing. The engineer sets direction, questions the agent's assumptions and judges what comes back; the agent writes, tests, explains and revises. Either one can drive. Kent Beck's distinction between vibe coding and what he calls augmented coding is the standard to hold this to: "In augmented coding you care about the code, its complexity, the tests, & their coverage."
Two agents, with a person accountable. This suits bounded tasks whose outcomes can be checked independently. One agent implements, a second argues with it or verifies the behaviour, and an engineer decides whether to accept the result. I'd only run this mode under a verification contract like the one above.
The risk I worry about most sits outside any one of these modes. If every developer runs several agents on their own, a team can turn into a collection of silos. Each moves quickly, and the team slowly loses a common understanding of its own architecture. That would undo the thing XP worked hardest to build.
- Engineer
- Agent
- Context
The countermeasures are old XP habits applied deliberately. Keep design collaboration between people, rotate ownership of areas of the system, hold shared technical reviews, and make decisions easy to find. After a month of this the whole team should understand the system better, and no individual's output figures will tell you whether it does.
For engineering managers, this makes mentoring more important. Engineers still have to learn to judge a design, reason about a system, spot weak evidence and explain a trade-off, and they'll write far less code to learn it from. Those skills used to be picked up as a side effect of writing code; now someone has to teach them on purpose.
A Cadence for the Team
I'd keep XP's lightweight iteration planning and retrospectives, and move most daily coordination into continuous, asynchronous feedback. For a team adopting this, I'd start with something like:
| How often | What | Why |
|---|---|---|
| Continuously | Agent implementation, tests, verification and integration | Small, validated changes |
| Daily, asynchronously | Progress, blockers, decisions and integration risks, written down | Everyone knows what's happening without a status meeting |
| On demand | People working together on an ambiguous or consequential decision | Uncertainty resolved quickly |
| Twice a week | Product, design and engineering review working software together | Earlier product feedback |
| Weekly | Outcomes, agent failures, engineering friction and architectural drift | Improve the product and the system that builds it |
| Fortnightly | Retrospective and capability improvement | Fix systemic problems |
With status written down, meetings are for reasoning and deciding together. Agents can do the preparation by summarising what changed, surfacing assumptions that conflict and listing dependencies nobody has resolved.
I'd be careful that this doesn't turn into a stream of agent-written reports and notifications. Team Topologies is blunt about the limit: "Teams can only handle so much complexity before breaking down." Every summary someone is expected to read spends part of that budget and once things become too complex, the team will stop reading and start ignoring. I'd keep the cadence light, and the summaries short, and make sure the team has a way to flag when it can't keep up.
Measure Learning, Not Output
This is where AI adoption programmes most easily go wrong. Once code is cheap, counting commits, pull requests, story points and lines of code tells you less every month. Self-reported productivity isn't a safe substitute either. In METR's 2025 randomised trial, experienced open-source developers believed AI had made them faster, but were measured as slower:
Show the numbers
| Who | Change in completion time |
|---|---|
| Economics experts' forecast | −39% |
| ML experts' forecast | −38% |
| Developers' forecast | −24% |
| Developers' estimate after | −20% |
| Measured | +19% |
The tools have moved on since then, and METR's own follow-up found "some evidence for speedup" while calling its new data unreliable. Whatever the current effect, the study showed that a developer's sense of being faster is a poor instrument. So I'd measure the team's ability to learn and to deliver changes it has validated:
| Metric | What it tells you |
|---|---|
| Feedback latency | How long between making a change and getting useful evidence about it? |
| Validation latency | How long before the team knows whether a change meets its acceptance criteria? |
| Change failure rate | How often do changes cause problems in production? |
| Rework rate | How much effort goes into correcting misunderstood requirements or defective implementations? |
| Decision latency | How long do important product or technical questions stay open? |
| Knowledge freshness | How often does out-of-date context cause a mistake? |
| Outcome lead time | How long from spotting a product opportunity to knowing whether it worked? |
I'd also instrument the agent workflows themselves, tracking repeated failed attempts, cycles of a test failing and being repaired, mistakes caused by missing or stale context, the points where a person had to step in, and changes rejected in review. Those show where the development system needs work, which is the same argument as treating agent failures as evidence.
DORA's 2025 report reaches a similar place from a different direction. Its AI Capabilities Model lists seven capabilities that determine whether AI helps or hurts. Working in small batches, strong version control practices and a user-centric focus would all be familiar to an XP team.
Starting With One
I wouldn't start by deploying lots of autonomous agents or by reorganising anyone. Start small with one cross-functional feature team and strengthen its feedback system over time:
- a baseline. Map the journey from product hypothesis to production feedback. Measure review latency, build times, rework, where decisions get stuck, and how much knowledge is lost between functions.
- shared context and collaboration. Give product, design and engineering a common context for the feature. Use agents for exploration, prototypes, acceptance tests and small implementations. Keep it clear which person owns each decision.
- automate the fast loops. Strengthen CI, contract testing and reproducible agent environments. Let agents correct their own work where verification is objective, under a contract like the one above. Make failures and uncertainty visible.
- close the product loop. Connect deployment, observability and user outcomes back to the original hypothesis. Compare against the baseline and decide which practices are worth spreading.
At the end I'd want to show something more substantial than developers finishing tasks faster, such as less time to validate a product idea, fewer misunderstood requirements, faster defect detection, less rework, or a better outcome for customers. Those are the results that justify doing it with a second team.
What Changes for Leaders
Engineering organisations have been shaped, in part, by how expensive and scarce implementation was. We divide work into specialities, set up handoffs, manage dependencies and plan delivery around how much engineering capacity is available. When implementation gets cheaper, the constraint moves to the quality of decisions, the speed of validation and the flow of information between people.
That changes what an engineering manager is for. Less of the job is allocating implementation capacity and managing its throughput. More of it is creating the conditions in which a team can make good decisions and reliably turn them into outcomes:
- clear communication and a shared understanding of the product and the system
- fast feedback from sources the team trusts
- clear architectural boundaries and engineering standards
- teams that can experiment without heavy coordination
- engineers who develop judgement as well as skill at directing agents
- a culture where problems come up early and lessons are shared
There's a real risk on the other side. A team can produce far more code without getting any better at understanding, validating or maintaining it, and then it accumulates organisational and technical debt faster than before. More oversight runs straight into the review bottleneck. Stronger feedback, better information flow and clear ownership of outcomes scale better.
Making the existing pipeline more efficient is the AI-assisted version. The AI-native version goes after the distance between an idea, a working experiment and evidence of whether the idea was right, which is what XP was for in 1999. With code this cheap, that distance is most of what a team has left to improve. I'd point an engineering manager at the whole system of collaboration, reasoning, implementation and feedback, and at how quickly the organisation learns from the software it ships.
References
XP and its context
- Kent Beck and Cynthia Andres, "What is XP?", sample chapter from Extreme Programming Explained: Embrace Change, 2nd ed. (Addison-Wesley, 2004). informit.com
- "History of Extreme Programming", page on Ward Cunningham's wiki (c2). c2.com
- Martin Fowler, "Continuous Integration" (2000, updated January 2024): "The whole point of Continuous Integration is to provide rapid feedback." martinfowler.com
- Frederick P. Brooks Jr., "No Silver Bullet: Essence and Accident in Software Engineering" (1986). PDF
- Kent Beck, "Augmented Coding: Beyond the Vibes", June 2025. newsletter.kentbeck.com
Evidence on AI in software delivery
- DORA / Google Cloud, 2025 State of AI-assisted Software Development, September 2025. PDF
- DORA / Google Cloud, 2024 Accelerate State of DevOps Report. PDF
- Faros AI, The AI Productivity Paradox Report 2025, July 2025. faros.ai
- METR, "Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity", July 2025. metr.org, arXiv 2507.09089
- METR, "We are Changing our Developer Productivity Experiment Design", February 2026. metr.org
- GitClear, "AI Copilot Code Quality: 2025 Look Back at 12 Months of Data". gitclear.com
- Stack Overflow, 2025 Developer Survey, AI section: 46% of developers distrust the accuracy of AI tools and 33% trust it. survey.stackoverflow.co
Harnesses, context and verification
- Thoughtworks, Technology Radar, Volume 35. PDF
- Birgitta Böckeler, "Harness engineering for coding agent users", April 2026. martinfowler.com
- Birgitta Böckeler, "Context Engineering for Coding Agents", February 2026. martinfowler.com
- Anthropic, "Effective context engineering for AI agents", September 2025. anthropic.com
- Anthropic, "Effective harnesses for long-running agents", November 2025. anthropic.com
- Anthropic, "Best practices for Claude Code". code.claude.com
Teams and learning
- Eric Ries, The Lean Startup, principles. theleanstartup.com
- Barry O'Reilly, "How to Implement Hypothesis-Driven Development", Thoughtworks, October 2014. thoughtworks.com
- Matthew Skelton and Manuel Pais, Team Topologies (2019), key concepts. teamtopologies.com
Related posts on this site