Extreme Programming When Code Is Cheap

Extreme Programming was built to shorten the distance between a decision and the evidence that it was right. Coding agents make implementation cheap, and that moves the bottleneck to validation, coordination and judgement. So how do we adapt XP for teams working with AI agents? My answer is feedback that changes decisions, a context everyone works from, clear owners for judgement, and metrics that support a continuous loop of learning and collaborative feedback.

November 1, 2026 · 23 min read

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.

Two diagrams, switched by a two-way choice. XP iteration: four boxes in a row, Plan, Test first, Implement in pairs, Integrate and release, with one arrow running from the last back to the first, labelled feedback, once an iteration. AI-native XP: four boxes in a ring, Intent (people and the business), Implementation (people and agents), Verification (tests and evaluation) and Observation (users and telemetry), joined by arrows around the ring, each also connected to a central amber box, Shared context: intent, decisions, evidence.
From one feedback loop per iteration to feedback at every stage
Figure 1. The XP iteration runs its stages in order, and what the team learns comes back once per iteration. In the AI-native version, each of the four stages reads from and writes to one shared context, so a failing test, a production trace or a product conversation can change the other stages without someone carrying it across by hand. Switch between the two views above the diagram.

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:

Two horizontal bars split into implementing and everything else. Before is the whole lead time; after shrinks only the implementing part. Two sliders set the share of lead time spent implementing (20% to 80%) and how much faster implementing gets (1× to 100×). At the default, half the lead time implementing and 10× faster implementing, the new lead time is 55% of the old, 1.8× faster overall. Even 100× faster implementing at 50% gives at most 2.0×.
Faster implementing shortens delivery less than you'd expect
Share of lead time spent implementing
50%
Implementing gets faster by
10×
Figure 2. This is a model, not a measurement. If implementing is a share p of the time from idea to validated change, and only implementing gets s times faster, the new lead time is (1 − p) + p / s of the old. At half the lead time and 10× faster implementing, delivery gets 1.8× faster. It assumes everything else stays the same size, which is optimistic, because more code usually means more to review.
Show the numbers
New lead time as a share of the old, (1 − p) + p / s
Implementing share, ps = 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%
Amdahl's law: only the implementing share gets faster; everything else (deciding, coordinating, reviewing, validating, waiting) takes as long as before. The model assumes that remainder does not grow, which is optimistic if more code means more to review.

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:

Horizontal bars of percentage change with high AI adoption, from Faros AI's 2025 report. Output: tasks completed +21%, pull requests merged +98%. Load on reviewers and quality: average PR size +154%, PR review time +91%, bugs per developer +9%.
Heavy AI adopters merged twice the PRs while review time rose 91%
  • Output
  • Load on reviewers and quality
Figure 3. Percentage change associated with high AI adoption, as published in Faros AI's report. Slate bars are output; coral bars are load that lands on reviewers and on quality. The data is correlational telemetry, not a controlled experiment.
Show the numbers
Change associated with high AI adoption (Faros AI, 2025)
MeasureChangeAs 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”
Telemetry from over 10,000 developers across 1,255 teams. Tasks, PRs merged and review time compare developers on teams with high AI adoption; PR size and bugs per developer are what the report says AI adoption is consistently associated with. Correlational, not a controlled experiment.
Source: Faros AI, The AI Productivity Paradox Report 2025 (July 2025)

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 XPAI-native XP
Pair programmingPeople pairing with agents, people pairing with people, and engineers steering
Test-driven developmentExecutable acceptance criteria, agent-written tests that people steer, property-based tests and automated evaluation. The aim is a change a machine can verify
Continuous integrationSmall agent-written changes implemented, verified and integrated continuously, with the wider team kept in the loop
On-site customerProduct and engineering working together continuously, with agents helping turn business intent into executable requirements
Collective code ownershipShared ownership of code, architecture, context and decisions, across people and agents
Simple designExplicit architecture constraints, complexity budgets and continuous simplification
Small releasesFeature flags, incremental deployment and delivery validated in stages
RefactoringAutomated detection and repair of complexity and design drift, all the time
Sustainable paceManaging 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.

Five nested boxes, outermost first: 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). A choice picks an example and marks two loops, where the evidence starts and where it has to land: a constraint, from L2 to L1; a regression, from L4 to L2; a surprise, from L5 to L1; agent failures, from L2 to L1.
Evidence has to reach the feedback loop where the decision is made
Example
Pick an example to see where its evidence appears and which decisions it has to change.An agent finds an undocumented architectural constraint while implementing. It belongs in the shared design, where the next engineer or agent will see it.Telemetry shows latency rising. An agent ties it to a recent change, reproduces it and proposes a fix for an engineer to accept.Users behave in a way nobody expected. The team revises the product hypothesis, not only the screen.Agents keep failing on the same component. That is evidence about the component, its interfaces or its documentation, not only about the agents.
Figure 4. Five feedback loops nested by timescale, with the evidence each produces. Timescales are illustrative. Pick an example to see the loop where its evidence first appears (coral) and the loop whose decisions it has to change (amber).
Show the numbers
The loops, outermost first
LoopTypical timescaleEvidence it produces
L5 Product outcomesDays to weeksadoption, usability, commercial value
L4 ProductionMinutes to daystelemetry, incidents, user behaviour
L3 IntegrationMinutesCI, contracts, dependency checks
L2 ImplementationSeconds to minutestests, static analysis, review
L1 ReasoningContinuousintent, assumptions, design decisions
Timescales are illustrative. Each example starts in one loop and has to change decisions in another.

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.

Seven questions a change must answer, from those a machine can settle to those a person must decide. Does it build? Evidence: Compiler, type checker, linter. Decides: Tooling. Agent: Fix and retry. Do the tests pass? Evidence: The test suite. Decides: Tooling. Agent: Fix the code, not the test. Do the contracts hold? Evidence: Contract and property tests, schemas. Decides: Tooling; engineers own the contracts. Agent: Fix the code; propose contract changes. Is it within budget? Evidence: Benchmarks, telemetry against a budget. Decides: Tooling, against a budget people set. Agent: Fix within scope, or stop and report. Is the design still simple? Evidence: Review, complexity signals. Decides: Engineers. Agent: Flag it. Is it right to use? Evidence: Design review, usability sessions. Decides: Design. Agent: Flag it. Did it solve the right problem? Evidence: What users do, outcome measures. Decides: Product and the team. Agent: Gather the evidence. A rule after the fourth question marks where agent self-correction stops and judgement starts.
Machines can settle some questions, and people own the rest
Feedback: a machine can settle it
Does it build?
EvidenceCompiler, type checker, linter
DecidesTooling
AgentFix and retry
Do the tests pass?
EvidenceThe test suite
DecidesTooling
AgentFix the code, not the test
Do the contracts hold?
EvidenceContract and property tests, schemas
DecidesTooling; engineers own the contracts
AgentFix the code; propose contract changes
Is it within budget?
EvidenceBenchmarks, telemetry against a budget
DecidesTooling, against a budget people set
AgentFix within scope, or stop and report
Judgement: a person has to decide
Is the design still simple?
EvidenceReview, complexity signals
DecidesEngineers
AgentFlag it
Is it right to use?
EvidenceDesign review, usability sessions
DecidesDesign
AgentFlag it
Did it solve the right problem?
EvidenceWhat users do, outcome measures
DecidesProduct and the team
AgentGather the evidence
Figure 5. The questions a change has to answer, ordered from those a machine can settle to those a person has to decide, with the evidence that is authoritative for each, who decides, and what an agent may do on its own. Self-correction stops at the coral rule.
Show the numbers
Who owns each signal
QuestionAuthoritative evidenceWho decidesWhat an agent may do
Does it build?Compiler, type checker, linterToolingFix and retry
Do the tests pass?The test suiteToolingFix the code, not the test
Do the contracts hold?Contract and property tests, schemasTooling; engineers own the contractsFix the code; propose contract changes
Is it within budget?Benchmarks, telemetry against a budgetTooling, against a budget people setFix within scope, or stop and report
Is the design still simple?Review, complexity signalsEngineersFlag it
Is it right to use?Design review, usability sessionsDesignFlag it
Did it solve the right problem?What users do, outcome measuresProduct and the teamGather 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.

Two diagrams, switched by a two-way choice. Handoffs: Product, Design, Engineering, QA and Operations in a line, each passing an artefact to the next (spec, mock-ups, code, release), with feedback travelling back through every handoff to Product. Shared context: Product (outcomes), Design (experience), Engineering (architecture) and Operations (reliability) each connected to one shared product and engineering context (intent, decisions, constraints, acceptance criteria, observations), which connects to people and agents who explore, implement, validate, deploy and learn.
A shared context keeps the intent that handoffs lose at every step
  • Roles
  • Shared context
  • Where the work happens
Figure 6. Handoffs pass an artefact from one function to the next, and feedback travels back the same way. In the shared-context version each function contributes to, and works from, one product and engineering context, and the work itself is done by people and agents drawing on it. Switch views above the diagram.

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:

  1. Product and design go through the behavioural data with an agent to find the likely points of friction.
  2. Engineering checks whether performance, validation errors or API behaviour contribute.
  3. The team argues through competing hypotheses, with evidence, quick prototypes and feasibility assessments on the table.
  4. An agent produces a small implementation, with tests and the telemetry changes needed to measure it.
  5. Engineers validate the implementation; design checks the interaction against the intended experience.
  6. 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:

KnowledgeWhat it records
Product intentProblems, hypotheses, outcomes and priorities
ArchitectureSystem boundaries, constraints, ADRs and trade-offs
ContractsAPIs, schemas, invariants and acceptance criteria
Engineering conventionsStandards, testing strategy and development workflow
Operational knowledgeReliability expectations, incidents and production behaviour
Decision historyWhat 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.

Five engineers in a ring, each connected to two agents. Isolated pairs: each engineer and their agents sit inside their own faint context ring, and nothing connects the pairs. A team: the private rings are gone; each engineer is linked to the engineers beside them, and every engineer and agent is linked to one shared context in the centre.
Five fast human–agent pairs are not yet a team
  • Engineer
  • Agent
  • Context
Figure 7. Each of five engineers runs two agents. As isolated pairs, each keeps its own context and nothing connects them. As a team, engineers pair, review and rotate with each other, and every person and agent works from one shared context. Switch views above the diagram.

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 oftenWhatWhy
ContinuouslyAgent implementation, tests, verification and integrationSmall, validated changes
Daily, asynchronouslyProgress, blockers, decisions and integration risks, written downEveryone knows what's happening without a status meeting
On demandPeople working together on an ambiguous or consequential decisionUncertainty resolved quickly
Twice a weekProduct, design and engineering review working software togetherEarlier product feedback
WeeklyOutcomes, agent failures, engineering friction and architectural driftImprove the product and the system that builds it
FortnightlyRetrospective and capability improvementFix 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:

Dot plot of the change in time to complete an issue when AI tools were allowed, from METR's 2025 trial. Forecasts: economics experts −39%, ML experts −38%, developers before the study −24%. Developers' estimate afterwards: −20%. Measured: +19%, the only point on the more-time side of zero.
Developers felt 20% faster with AI but were measured 19% slower
Figure 8. Change in time to complete an issue when AI tools were allowed, from METR's randomised trial of 16 experienced developers on 246 issues in repositories they knew well (early 2025 tools). METR now marks this result as out of date, and says its February 2026 follow-up gives an unreliable signal of the current effect. The figure is about the gap between what people felt and what was measured.
Show the numbers
Change in time to complete an issue when AI is allowed (METR, early 2025)
WhoChange in completion time
Economics experts' forecast−39%
ML experts' forecast−38%
Developers' forecast−24%
Developers' estimate after−20%
Measured+19%
16 experienced developers, 246 issues in mature open-source repositories they knew well, each randomly assigned to allow or disallow AI tools (mostly Cursor Pro with Claude 3.5/3.7 Sonnet). METR now marks this result as out of date; its February 2026 follow-up says the new data gives an unreliable signal of the current effect.
Source: METR, Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity (July 2025), arXiv 2507.09089

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:

MetricWhat it tells you
Feedback latencyHow long between making a change and getting useful evidence about it?
Validation latencyHow long before the team knows whether a change meets its acceptance criteria?
Change failure rateHow often do changes cause problems in production?
Rework rateHow much effort goes into correcting misunderstood requirements or defective implementations?
Decision latencyHow long do important product or technical questions stay open?
Knowledge freshnessHow often does out-of-date context cause a mistake?
Outcome lead timeHow 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

Matthew Gribben is a Chief Technology Officer writing about AI systems, software architecture, cyber security, cryptography, and the practical realities of technology leadership.