Audio brief · 2 min
Compare

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.


At a glance

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
Why it changed

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 each layer owns

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)
Economics

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.

Read the framework → · More comparisons →

FAQ

Frequently asked questions

What is the difference between RACE Programming and Kanban?
RACE Programming runs on Kanban. Executable User Stories flow across a Kanban board and through the gates, with no sprint box to fill. Kanban on its own is an evolutionary flow-management method: you visualize the workflow, limit work in progress, manage flow and improve gradually, without prescribing roles or how the work is done. RACE Programming is a prescriptive Agentic SDLC framework that keeps that flow and adds what Kanban leaves open: the roles, the Executable User Story as the unit of delivery, the four Definition-of-Done gates, AI-native execution with the Silicon Software Engineer (the AI agent), and a release cadence set by the client.
Is RACE Programming a replacement for Kanban?
No. RACE Programming is built on Kanban flow and adds a delivery model on top of it. Kanban is method-agnostic: it optimizes the flow of an existing process but does not define the engineering model, roles, or practices. RACE Programming defines all of those and leaves the flow itself to Kanban. A team already running Kanban keeps its board; what changes is who is on it, what moves across it, and what "done" means.
Does RACE Programming set work-in-progress limits?
No. The team sets its own Kanban limits, as Kanban intends; the framework does not prescribe a number. What RACE Programming fixes is what a card is (an Executable User Story), what it must pass to be done (four Definition-of-Done gates and UAT by the Team Principal), and how often finished work reaches users (a Pit Stop, a production release on the client's release cadence).
Kanban has almost no prescribed roles. What does RACE Programming prescribe instead?
Kanban deliberately prescribes no engineering roles (its optional roles, Service Delivery Manager and Service Request Manager, are about flow, not building software). RACE Programming prescribes a full role set: a client-side Team Principal; an AI Product and a Forward Deployed Engineer on the Pit Wall; Pit Crew Software Engineers and a Pit Crew Quality Engineer in delivery; and the Silicon Software Engineer, the AI agent, present across both and adding no human headcount.
How does RACE Programming release if there are no sprints?
Release cadence is a separate decision, and it belongs to the client. The team releases on a fixed rhythm (sprint-length, if the client already plans that way) or on calendar dates. Each release is a Pit Stop: every Executable User Story that has cleared its gates since the last Pit Stop goes to production. The sprint survives only as a release rhythm; it no longer caps scope.
How much more efficient is RACE Programming than a Kanban team?
Quality is held fixed, so locking any two of scope, time, and budget moves the third. A senior-only RACE team delivers a Scrum team's output about 2x faster at roughly 0.75x the cost, about 3x the work per dollar. Kanban improves the throughput of an existing team but does not change the underlying engineering economics; RACE Programming keeps the flow and changes the economics by making the team AI-augmented and senior-only. That is what we see now, worked out from two team shapes. 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.