RACE Programming

Permissive is not enough

Scrum, SAFe, Kanban — frameworks. Roles and events at a level of abstraction that permits enormous variation. Permissiveness worked when code production was the bottleneck.

When AI shifts engineering economics by an order of magnitude (Theorem 4), permissive is not enough. The specific disciplines that make AI-native delivery work — spec-driven development, executable user stories, continuous context curation, role-specific context boundaries — must be prescribed, not suggested. A team that implements half does not get half the benefit; it gets a small fraction.

RACE Programming is a methodology. It prescribes. Roles defined. Artifacts mandatory. Ceremonies serve specific mechanical purposes. Prescriptions are not optional.

Three tiers, three speeds

F1 metaphor, not corporate hierarchy. Each tier protects the others' rhythm — discipline beats prohibition. Team Principal sets the pace; Pit Wall buffers; Pit Crew keeps the inner cycle intact.

Team Principal

Client's product vision owner · Cycle: Client's pace

Originates ideas, conducts User Acceptance Testing (UAT), holds the tacit business knowledge that AI cannot verbalize. Owns strategy, budget, positioning. Decides which races to run. Rhythm discipline: stays at strategy level — communicates exclusively with Pit Wall, never directly with Pit Crew.

Pit Wall

ACE Technical Lead + AI Product · Cycle: Days

The client-facing pair. Co-authors the Executable Product Backlog and Roadmap with Team Principal. Builds Prototype on synthetic data using AI tools — a stand-alone module, not a branch of main — within 1–2 days of receiving an idea. One Pit Wall pair can serve multiple Pit Crews. Rhythm discipline: stable handoff; no reimplementation of what Pit Crew produces.

Pit Crew

AI Product (Context Manager) + 2 Engineers · Cycle: Hours

The execution unit. AI Product owns design guardrails, alignment review, and no-duplication enforcement. Engineers execute under those guardrails with AI tools. Inner cycle: Spec → Build → Align, twice per day (kanban, no sprints). Rhythm discipline: inside guardrails; never re-scopes mid-cycle.

The full delivery flow

Pit Wall → Pit Crew handoff is a demo plus full artifact transfer: code, requirements, and test scenarios. All feedback is mediated by Pit Wall — Team Principal and Pit Crew never communicate directly.

1. Idea — Team Principal → Pit Wall · Hours. Team Principal articulates business need.
2. Prototype — Pit Wall · 1–2 days. ACE TL + AI Product build on synthetic data with AI tools.
3. Handoff — Pit Wall → Pit Crew · Demo + Estimate. Demo + transfer: code, requirements, NFRs. Pit Crew estimates in person-hours.
4. Inner Cycle — Pit Crew · 2×/day. Spec → Build → Align (kanban, no sprints).
5. Demo — Pit Crew → Pit Wall · Every 2–3 days. Pit Wall accepts or returns for rework (never to Team Principal).
6. UAT — Pit Wall → Team Principal · ~1 Stint. Team Principal tests real business expectations.
7. Pit Stop — Pit Crew → Production · End of Stint. Production deployment. Every Stint ends with a Pit Stop.

Stint and Pit Stop

The Stint is the one-week iteration cycle in RACE Programming — replacing the two-week sprint of Scrum. Shorter cycles are required because stale plans are toxic context (Theorem 5).

Every Stint ends with a Pit Stop — a production deployment. Working software ships to production weekly by design, not by exception. Stint length flexes with client absorption capacity; weekly is the default, two-day is the observed extreme.

Velocity math

Same headcount. 4× backlog throughput per month.

800 → 3,200 SP/month = 4× throughput. Same headcount. Same monthly spend. Throughput committed per week. Stint length flexes with client absorption.

Executable User Story

The core unit of the Executable Product Backlog. Anyone can write a user story. Almost no one produces one that AI agents execute without re-interpreting context. EUS gives AI minimum-sufficient context to execute without drift.

1. User Story — Classic "As a [role], I want [outcome], so that [value]." The intent — what we're trying to achieve and for whom.
2. Working Prototype — Built on synthetic data, in a stand-alone module (not a branch of main). Shows the experience before implementation begins.
3. NFR / EARS — Non-Functional Requirements in EARS format: "The system shall…", "When X, the system shall Y." Performance, security, scalability.
4. Architecture / ADR — Constraints captured as Architecture Decision Records, versioned with the code. Where this fits in the system, why this choice. Prevents AI drift across Stints.
5. Acceptance / Gherkin — Functional behavior + acceptance criteria in Given/When/Then format. Pit Wall authors the scenarios; Pit Crew runs them as Playwright / unit / E2E gates.
6. Test Data — Pit Wall declares what data is needed (client + synthetic). Pit Crew curates and stages the actual fixtures.
7. Estimate — Pit Crew effort in person-hours / person-days. Real labor cost — not abstract Story Points. The basis of the throughput commitment.

Pit Wall authors the EARS (NFR) + Gherkin (functional + acceptance) + ADR (architecture). Pit Crew runs them as Playwright / unit / integration / E2E gates (≥80% unit coverage).

Two mandatory artifacts govern the Pit Crew's execution environment: the Executable Product Backlog (prioritized stack of EUS, AI-ready) and Everything as Code — code, tests, infra, architecture decisions, handover docs, and a Conversations KB all versioned in Git. If it's not in Git, it doesn't exist.

Race Drivers

Six values that govern every decision in RACE Programming.

Verbalize

If you can't say it, AI can't do it. Tacit knowledge gets surfaced or lost.

Delegate

Engineers orchestrate AI; they don't manually produce. Validation > production.

Demo or it didn't happen

Working software is the only proof. Every Stint ends with a demo.

Speed of feedback

First-class metric. Slow feedback collapses the inner cycle.

Everything as Code

If it's not in Git, it doesn't exist.

Outcome over Output

We commit to Pit Stops shipped, not hours logged. Output is the unit of value.

Key Principles

Operational rules that keep the system stable at speed.

Tiers protect rhythm

Team Principal sets weekly cadence. Pit Wall buffers. Pit Crew never breaks its inner cycle.

Hybrid by design

Pit Wall can coordinate both Pit Crews and external Scrum teams. No all-or-nothing adoption required.

No re-scoping downstream

Pit Crew executes; never re-scopes. Rejection always returns to Pit Wall, which updates the Backlog before re-handoff.

Outer cycle for refactors

Inner cycle stabilizes product. Major redesigns get their own outer Stint, keeping the inner cycle intact.

RP vs XP vs Scrum