RACE Programming vs Kanban
RACE Programming runs on Kanban flow. Kanban manages the flow of work; RACE Programming adds what Kanban deliberately leaves open: the roles, the Executable User Story as the unit of delivery, the four Definition-of-Done gates, and a release cadence set by the client. Not rivals: one sits inside the other.
Kanban flow, plus a delivery model
| Dimension | RACE Programming | Kanban |
|---|---|---|
| What it defines | The whole delivery model on top of Kanban flow: roles, artifacts, gates, AI-native execution | Flow policy over an existing process; not the work itself |
| Designed for | AI-augmented teams (engineer-led, agent-executed) | Any team wanting smoother flow, evolutionary change |
| Flow mechanics | Kanban: pull, visualized flow, Kanban limits set by the team | Visualize flow, limit WIP, manage flow, explicit policies |
| Unit of work | The Executable User Story: spec, prototype, NFR, ADR, Gherkin, test data, cost in dollars | Whatever the team puts on a card |
| Roles | Team Principal · Forward Deployed Engineer · AI Product · Pit Crew Quality Engineer · Pit Crew Software Engineer · Silicon Software Engineer (AI) | None prescribed (optional: Service Delivery / Request Manager) |
| Cadence | Continuous flow; each story production-ready in 2-3 days at the floor; Pit Stops (production releases) on the client's release cadence | Continuous flow; optional cadences for replenishment and review |
| Metrics | Kanban flow metrics, plus four Definition-of-Done gates per story and the idea-to-production clock | Lead time, cycle time, throughput, WIP, cumulative flow |
Managing the flow is not the same as changing the work
Kanban is a genuinely good idea, and RACE Programming is built on it. Visualizing work, limiting work in progress, and managing flow make almost any process smoother, and they suit AI-augmented delivery better than a sprint box: a story is done when its gates pass, not when a cycle ends. But Kanban is deliberately method-agnostic: it improves the flow of whatever you already do without saying who should be on the team, how software should be built, or what "done" means.
When AI shifts engineering economics by an order of magnitude, the flow is not the constraint, the delivery model is. A smoother flow of the old way of working still leaves you with the old roles, the old headcount, and the old handoffs. RACE Programming keeps the Kanban flow and prescribes the model that runs on it: senior micro-teams delegating to and validating the AI agent, Executable User Stories on the cards, four gates in front of done, and Pit Stops on the client's release cadence. The team still sets its own Kanban limits; the framework does not prescribe a number.
What RACE Programming adds to Kanban
| Concern | Kanban | RACE Programming |
|---|---|---|
| Flow and WIP | Core discipline | Adopted as is; the team sets its own limits |
| Who is on the team | Not defined | Prescribed role set, senior-only micro-team |
| What moves across the board | Not defined | The Executable User Story, authored by the Pit Wall |
| How software is built | Not defined | Spec-driven, delegated to and validated with AI; Inner Cycle (Spec, Build, Align) twice a day |
| What "done" means | Left to the team | Four Definition-of-Done gates per story, then UAT by the Team Principal |
| When work reaches users | Not defined | At the Pit Stop, a production release on the client's release cadence (sprint-length or calendar dates) |
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 ready the moment its gates pass, not gated to a batch
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. Kanban improves how smoothly a team moves; it does not change the underlying engineering economics the way an AI-augmented, senior-only team does.
Already running Kanban? Keep the board. What changes is who is on it, what moves across it, and what "done" means. The framework page shows the full delivery model.