RACE Programming vs Extreme Programming
Extreme Programming built engineering discipline (pairing, test-first, continuous integration, small releases) around the assumption that humans write every line. RACE Programming keeps that discipline and moves the unit of work to specifying and validating what the AI agent builds. It is less a rejection of XP than XP's instincts rebuilt for AI-augmented teams.
Same instincts, different executor
| Dimension | RACE Programming | Extreme Programming |
|---|---|---|
| Core bet | Specify precisely, delegate to AI, validate the output | Disciplined humans writing every line, together |
| Designed for | AI-augmented teams (engineer-led, agent-executed) | Co-located human teams |
| Pairing | Inner Cycle: engineer paired with the Silicon Software Engineer, 2×/day | Two humans, one keyboard |
| Test-first | Executable User Story with Gherkin acceptance, validated against AI output | Test-driven development, written by the programmer |
| Releases | Pit Stops on the client's release cadence; every story is done when its gates pass | Small releases on short iterations |
| Feedback loop | Hours (Inner Cycle) / 2-3 days (one Executable User Story) | Continuous (pairing) / 1 to 2 weeks (iteration) |
XP's instincts were right; its inner loop assumed humans
XP got the deep things right: correctness defined before code, the tightest possible feedback loop, releasing small and often, and treating engineering quality as non-negotiable. Those convictions are exactly the ones worth keeping, and RACE Programming keeps them.
What dates is the mechanism, not the intent. Pairing, hand-written TDD, and collective code ownership all assume a human is the one typing. When AI shifts engineering economics by an order of magnitude, the mechanical work moves to the agent, and the scarce human skill becomes specifying work precisely enough to delegate and validating what comes back. RACE Programming preserves the XP feedback loop and rebuilds each practice around that new inner loop.
How XP roles map across
| XP role | RACE Programming role |
|---|---|
| On-site Customer | Team Principal: client-side; budget, product direction, UAT |
| Coach · Tracker | AI Product: spec, communication, flow, in the Pit Wall |
| Programmer (senior) | Forward Deployed Engineer: prototype, architecture, ADR, CI/CD |
| Programmer | Pit Crew Software Engineer: AI-augmented execution, Inner Cycle 2×/day |
| Tester (XP-style) | Pit Crew Quality Engineer: validates AI output against EUS Gherkin |
| (no equivalent) | Silicon Software Engineer: the AI agent, present in Pit Wall and Pit Crew; not human headcount |
The triangle moves
Scope, time, and budget are the three sides of every project; quality is the area inside, fixed, never a lever. You set two sides, and RACE Programming moves the third. A senior-only RACE team delivers a Scrum team's output about 2× faster at roughly 0.75× the cost, about 3× the work per dollar. One efficiency, three doors:
- ~3× the finished software for the same budget and deadline
- ~⅓ the cost for the same scope on the same clock
- 2-5× faster time-to-business-result, since each Executable User Story is production-ready the moment its gates pass, not gated to an iteration
What we see now: the three figures above, worked out from two team shapes on the framework page. Measured: in the agent-to-agent data imports case, against our estimate for a team that already works with AI tools, all three sides moved at once: the cost of production came to about a third, the same scope took 7.1 times less human effort, and end-to-end speed stayed about the same, four months against an estimated 4.5, because that team had itself moved to Kanban in production and kept sprints only as a release cadence. XP already delivers high quality with disciplined humans; RACE Programming holds that bar and moves the economics.
Coming from XP? Its feedback discipline is the part RACE Programming most wants to keep. The framework page shows how test-first and tight loops carry into an AI-native model.