From Scrum to RACE Programming
A practitioner's transition guide. Every Scrum role, artifact, and ceremony mapped to its RACE Programming equivalent, with a 90-day plan and the metrics to validate it worked.
How much Scrum has to change under AI
Ceremonies sync a team that no longer exists
Scrum's events exist to synchronize a 7–9 person team: Sprint Planning, Daily Scrum, Sprint Review, Retrospective, Refinement all keep a large group of humans aligned. RACE Programming runs a three-person Pit Crew (a Quality Engineer plus 2 Pit Crew Software Engineers, alongside the Silicon Software Engineer) that never needed that overhead. The Silicon Software Engineer, the AI agent, changes team composition: it does the work, so you do not staff up to coordinate. You are not recovering a tax; you are running a smaller team that was never built to be synced by those events. (Surveys put the old ceremony load near a fifth of capacity, and 47% of teams feel constrained by mandatory events, but the point is composition, not the timesheet.)
Velocity stops measuring anything
Velocity measures human coding capacity in story points, and story points encode human effort, so they break the moment AI writes the code. The question is no longer how fast a developer types: it is throughput and economics. Measure Executable User Stories per Stint plus the delivery cost in dollars. A three-person Pit Crew delivers the throughput of a 7–9 person Scrum team, the work of 9 from 3, at roughly 3× the finished software for the same budget (or the same scope for about a third of the cost, or 2–5× faster), quality held fixed. Velocity was never comparable across teams, never comparable to an AI-augmented baseline, never visible to clients. 61% of teams track it anyway.
The spec problem Scrum never solved
The Scrum Guide makes the Definition of Ready optional. Most teams start sprints with stories that need mid-sprint clarification. "As a user, I want to see my dashboard" is a wish, not a spec. AI reads it literally, builds something, gets it wrong. 63% of teams report declining software quality (18th State of Agile, 2025).
AI and Scrum: the bottleneck moved off code
46% of AI pilots fail because the delivery model doesn't match AI's throughput. Scrum assumes human effort is the bottleneck and builds its whole cadence around it. Engineering is no longer the brake. The Silicon Software Engineer produces code faster than a sprint can absorb it, so the constraint moves to specification (upstream) and human validation (downstream). Sprint boundaries create review pile-ups: a week of AI-generated code lands for review at sprint end, with no scaled review capacity to meet it.
What Scrum got right
RACE Programming builds on these; it does not discard them:
- Iterative delivery. Ship working software at a defined cadence. RACE Programming keeps this as the Stint: the time it takes one Executable User Story to go from the start of work to production, two to three days at the floor. Idea to production and one Stint are the same measurement. A week holds two or three of them, which is why throughput is still quoted in EUS per week.
- Cross-functional teams. One team owns delivery end-to-end. RACE keeps this: Pit Wall + Pit Crew is a single accountable unit.
- Visible backlog. Work is explicit and prioritized. RACE extends this: nothing enters the Executable Product Backlog without all seven components.
Role translation
| Scrum Role | RACE Programming | What changes |
|---|---|---|
| Product Manager or the business customer | Team Principal | Business decision-maker. Stays client-side. Holds budget and product direction. Approves the Executable Product Roadmap and prototypes before coding starts. |
| Product Owner Scrum Master · BA · UX Lead · Test Lead · Project Manager | AI Product | Six delivery roles absorb into one AI-native Pit Wall position. Authors Executable User Stories, Gherkin acceptance scenarios, NFR specs. Eliminates coordination overhead. |
| AI Fluent Senior Developer (Scrum Developers) | Forward Deployed Engineer | AI Fluency at senior level required. Pit Wall mode: prototype build + ADR + CI/CD. Pit Crew mode: codes alongside AI tools as engineer. |
| AI Fluent Senior / Middle Developer (Scrum Developers) | Pit Crew Software Engineer | Pit Crew Quality Engineer + 2 Pit Crew Software Engineers. AI-augmented execution. Inner cycle 2×/day. No ceremonies. |
| QA Engineer (Scrum Team) | Pit Crew Quality Engineer | AI Product authors the EARS NFR and the Gherkin acceptance tests, and owns them as the test source of truth. The Pit Crew Quality Engineer automates those tests, applies senior expert judgement to what the agent produced, and sets the guardrails AI agents cannot override. Whoever writes the tests never writes the code they judge. |
| (none, net new) no Scrum equivalent | Silicon Software Engineer | The AI agent. Executes in both Pit Wall and Pit Crew: prototyping and spec authorship alongside the Pit Wall, implementation under guardrails alongside the Pit Crew. Not human headcount; the silicon teammate that multiplies the team's output. |
Artifact translation
| Scrum Artifact | RACE Programming | Key difference |
|---|---|---|
| Product Backlog | Executable Product Backlog | Every item = fully-specified Executable User Story. Nothing enters Pit Crew without all seven components. |
| Product Goal | Executable Product Roadmap | Quarterly horizon, revised every Stint, Stint-projected, with delivery cost per item. Client approves before budget commits. |
| User Story | Executable User Story (7 components) | Adds: Prototype · EARS NFR · Architecture Decision Record · Gherkin scenarios · Test Data. Estimate in dollars, approved by the Team Principal before scope locks. |
| Sprint (2 weeks) | Stint (2–3 days at the floor, stretching to quarterly) | Prototype-first before any coding. Adaptive cycle that matches client's release cadence. |
| Velocity (story points) | EUS / Stint + delivery cost | Client-visible. Comparable across teams. AI-compatible, because story points break when AI writes the code. |
| Definition of Done (team-defined) | 4-gate Definition of Done | Unit tests ≥80% coverage · Integration tests · End-to-end tests · Acceptance tests, all automated. |
Ceremony translation
| Scrum Ceremony | Status | RACE Programming equivalent |
|---|---|---|
| Sprint Planning | Gone | Replaced by per-story estimation at handoff. The Pit Crew reviews each Executable User Story and prices it in dollars, because the estimate belongs to whoever does the work, not to whoever wrote the spec. The Team Principal approves that cost before scope locks. |
| Daily Standup | Evolved | 2×/day inner cycle: Pit Crew SWEs build, Pit Crew Quality Engineer validates output. Asynchronous, no ceremony. |
| Demo to the Pit Wall | Evolved | Pit Crew hands work to the Pit Wall when an Executable User Story is ready, not on a calendar: the finished story with all four gates green, plus a list of deviations from the specification. There is no fixed demo slot to sit through. |
| Sprint Review | Evolved | UAT at Stint end: the Team Principal accepts the work, then the Pit Stop deploys it to production. Shorter, outcome-driven. |
| Sprint Retrospective | Kept | The one ceremony RACE keeps as is. Inspect and adapt is how the framework itself came to be; the team runs it at its own cadence. |
| Backlog Refinement | Evolved | Pit Wall authors EUS + builds prototype. Client validates concept before development starts; no coding until approved. |
A three-person Pit Crew delivers the throughput of a 7–9 person Scrum team: the work of 9 from 3, for the same budget. The ceremonies are lighter because the team is smaller, not because a tax was recovered.
The 90-day transition
Pilot Pit Wall
Identify the Pit Wall pair: your Product Owner steps into AI Product, your strongest senior engineer into Forward Deployed Engineer. Run the first EUS authoring session. Build a prototype for the highest-priority story on synthetic test data.
Do not change the dev team's process yet.
Prove the cadence
Run the first full Stint. Pit Wall authors the EUS on day one. Pit Crew executes. UAT closes it on day two or three, and the Pit Stop deploys to production.
Measure: Executable User Stories delivered this Stint and delivery cost in dollars. Compare throughput to the previous sprint.
Full Transition
Executable Product Roadmap replaces the sprint roadmap. Executable Product Backlog replaces the backlog. All stories converted to EUS. Velocity metric retired.
Produce the first quarterly EPR with the client.
What practitioners resist
Scrum Masters become AI Product in the Pit Wall. The role upgrades: from facilitating ceremonies to co-authoring delivery contracts and building prototypes. More impact, fewer meetings.
Two to three days is the floor, the fastest a Stint runs. From there it stretches up to the client's release cadence, out to once per quarter. RACE Programming doesn't dictate when you ship. It matches your rhythm with less overhead.
Replaced by EUS / Stint + delivery cost. A metric the client understands and approves before work starts. Velocity was never comparable across teams anyway.
EUS is more detailed than a user story. It eliminates mid-sprint clarifications, rework, and acceptance disputes. Front-loaded spec removes the back-end chaos.
What you'll hear. What to say.
Scrum Master objections
Product Owner objections
Engineering objections
What to measure in the first 90 days
| Metric | How to measure | Success looks like |
|---|---|---|
| Throughput per Stint | Executable User Stories delivered per Stint, at known delivery cost | A three-person Pit Crew matches a 7–9 person Scrum team's output by month 3 |
| EUS acceptance rate | % of EUS accepted without revision after prototype review | > 80% first pass by month 2 |
| Pit Stop pass rate | % of Stints that reach the Pit Stop with UAT green | > 70% in first 3 Stints |
| Rework rate | Stories returned to Pit Crew after delivery | < 10% after month 2 |
| Client feedback cycle time | Days from build-start to client validation | ≤ one Stint duration by week 6 |
Ready to start? The Framework overview covers all roles, artifacts, and ceremonies in depth. For a side-by-side breakdown, see RACE Programming vs Scrum. To talk through the transition for your specific team, reach out directly.