RACE Programming
Reliable Agentic Coding Excellence. An Agentic SDLC Framework that is engineer-led, agent-executed. An integrated transformation of organizational structure, delivery process, and technological stack, derived from AI-First Theory and the AI-First Manifesto and pioneered at First Line Software. The AI-era realization: SDLC is no longer just a quality process. It is the skill of delivering ideas to production at the client's idea-generation speed: 2–3 days from idea to enterprise-grade production.
Agile, Scrum, XP were built to coordinate people
Agile, Scrum, and XP were built for one job: to coordinate people, to align a group around the customer's intent and keep them aligned, because every person is full, unpredictable complexity. Big teams, two-week sprints, and estimation rituals all exist to manage that human coordination problem.
The job changed. The team member we now coordinate is a Silicon Software Engineer, an AI agent. Different problem → different framework. The old defaults (big teams, two-week sprints, story-point estimation) were sized for coordinating humans and no longer fit.
So RACE Programming keeps the useful pieces and drops the whole; it does not reinvent the wheel. The parts of Agile that still serve delivery are retained; Agile as a holistic framework, built for a problem we no longer have, is what's replaced.
The Silicon Software Engineer
Not a tool. Not a co-pilot. A new team member, the AI agent. Design your process for this profile, because it behaves nothing like a human engineer. It is present in both the Pit Wall and the Pit Crew, and it does not add human headcount: a Pit Crew is still three people.
Strengths
Speed ×1000
Senior/mid-grade code in seconds. At this level it is economically indefensible not to use it.
Zero friction
Perfect obedience. No ego, no burnout, never argues. Zero autonomy in business decisions.
Tireless throughput
Works in parallel, around the clock. Many tasks at once, no fatigue, no context-switching cost.
Limits
Text-only
Works only on what's written. Mocks, video, voice: all media converts to text first.
Stateless
No memory across sessions. Starts blank every task. Precise, minimum-sufficient context, not excess.
No judgment
Compliance is not understanding. It executes a wrong spec exactly as written.
The bottleneck shifts
Execution is instant, so the constraint is now specification: the scarce skill is describing exactly what to build, precisely enough to delegate. Opting out is like stepping out of an F1 car to go hiking: you can't cover the distance anymore.
The Agentic Agile Manifesto
The four Agile values still hold, rewritten for teams where AI executes. The left column endures; the right is how AI-augmented teams actually deliver. The thread through all four is AI fluency: the ability to delegate to AI and validate its output, kept current as models change.
Read the Agentic Agile Manifesto: all four values, Classic 2001 → Agentic 2026 →
AI Fluency
A subscription to ChatGPT, Claude, or Gemini is access. Fluency is different, and the skill is cognitive, not technical.
Know your Silicon Engineer
What can it do, and what can it not? A new team member: 1000× faster at code, confident, stateless, no ego, no context beyond what you give it, no judgment on ambiguous specs. Fluency starts with mapping that profile accurately.
Calibrate your trust
Three constant questions: delegate without checking, delegate but verify hard, or not delegate at all? That cognitive map, kept current, is the skill.
Practice, not certification
Your calibration expires. Models update regularly; capabilities change, for better or worse. Behavior calibrated last month may not hold today. Fluency is ongoing practice, not a one-time adoption.
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 pace.
Vision, budget, acceptance (UAT); decides which races to run.
Strategy only · talks only to Pit Wall · the new bottleneck.
Pit Wall
Days.
Intent → AI-executable spec; prototype on synthetic data (1–2 days).
Stable handoff · no reimplementation of Pit Crew's work.
Pit Crew
Hours · 2×/day.
Build inside guardrails; QE owns the executable Gherkin (Chinese Wall).
Kanban, no sprints · never talks to Team Principal directly.
Who does what
The Pit Wall is the client-facing pair; the Pit Crew is the execution unit. The Silicon Software Engineer, the AI agent, works inside both. Three people plus AI tools deliver a nine-person Scrum team's output, with no ceremonies: no stand-ups, no planning poker, no retrospectives.
Pit Wall
AI Product
- Co-authors the Executable Product Roadmap + Backlog with the Team Principal
- Authors NFR in EARS and the acceptance intent (what "done" means for the client) in the EUS
- Key output: the Executable User Story, a minimum-sufficient spec AI builds without re-interpreting context
- Stays in the Pit Wall; never sits in the Pit Crew
- 50–100% per engagement
Forward Deployed Engineer
- Embedded in the client's business context (colocated or remote): turns business intent into an AI-executable spec and a working prototype
- Operates Cursor / Claude Code / agentic tools natively: prompts, reviews, iterates with AI
- Owns the full pipeline: requirements, architecture, CI/CD, observability
- Validation is the new senior skill: judging AI output beats producing it
- Primarily forward-deployed in the Pit Wall; can drop into the Pit Crew to execute alongside AI tools
- One per Pit Crew; 50–100% per engagement
Pit Crew
Pit Crew Quality Engineer
- Hardens AI Product's acceptance intent into the executable, maintained Gherkin: the test source of truth
- Owns test design and coverage; validates every AI output against it
- Sets the guardrails the AI agents cannot modify: a Chinese Wall between spec and execution
- Runs the AI-evaluation discipline: LLM-as-Judge, eval-driven development, golden datasets, hallucination/faithfulness checks
- Builds and configures the testing agents · one per Pit Crew
Pit Crew Software Engineer
- Implements against the EUS with AI tools
- Owns unit (≥ 80%), integration, and end-to-end coverage; prevents AI drift across Stints
- Executes inside the Quality Engineer's guardrails; never re-scopes mid-cycle
- 2 per Pit Crew
Present in both tiers
The Silicon Software Engineer
- Not a tool but a teammate: senior/mid-grade code in seconds
- Text-only, stateless between tasks, zero business autonomy
- Executes in both tiers: prototyping + spec with the Pit Wall, implementation under guardrails with the Pit Crew
- Adds no human headcount; multiplies what the people deliver
Role Transitions
Every old role has a path forward. Add AI fluency and expanded responsibility, and climb. Roles are absorbed and redrawn around what AI executes, not renamed. (Project Manager and Product Owner aren't shown here: the Product Owner maps client-side to Team Principal, not to an engineering path.)
Once inside, the ladder keeps going: Pit Crew SWE → Forward Deployed Engineer and Pit Crew Quality Engineer → AI Product.
This is the moment to choose your branch: decide what you want to build creatively, and actively grow into the path that excites you most.
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. The EUS gives AI minimum-sufficient context to execute without drift, in seven components:
User Story
Classic "As a [role], I want [outcome], so that [value]." The intent: what we're trying to achieve and for whom.
Acceptance / Gherkin
Functional behavior + acceptance criteria in Given/When/Then format. AI Product authors the acceptance intent; the Pit Crew Quality Engineer hardens it into the executable, maintained Gherkin (the test source of truth) and runs it as Playwright / unit / end-to-end gates.
Working Prototype
Built on synthetic data, in a stand-alone module (not a branch of main). Shows the experience before implementation begins.
Architecture / ADR
Constraints captured as Architecture Decision Records, versioned with the code. Where this fits, why this choice. Prevents AI drift across Stints.
NFR / EARS
Non-Functional Requirements in EARS format: "The system shall…", "When X, the system shall Y." Performance, security, scalability.
Test Data
Pit Wall declares what data is needed (client + synthetic). Pit Crew curates and stages the actual fixtures.
Estimate
Delivery cost in dollars, the client-facing component, not abstract Story Points. The date and cost the client approves before scope locks.
Executable Product Roadmap + Backlog
Not a Gantt chart, not a Jira board, but a machine-readable delivery contract co-authored with the client.
Executable Product Roadmap (EPR)
The backlog projected onto Stints at the client's release cadence. Every item is an EUS package with a delivery date and an estimated cost. The client approves scope before budget commits, so there are no surprises. Pit Wall co-authors with Team Principal; revised each Stint.
Executable Product Backlog (EPB)
A prioritized stack of EUS refined to AI-executable quality. Priority = business importance × delivery cost (in dollars). Nothing enters the Pit Crew without all seven EUS components present. Pit Wall owns it; Pit Crew pulls. A single source of truth.
Everything as Code
If AI operates the SDLC, every artifact must be machine-readable and versioned in Git. RACE Programming places the Executable User Story as the upstream originating artifact across eight layers:
Executable User Story
User Story + Prototype + EARS + ADR + Tests + estimate. The upstream originating artifact.
Executable Product Backlog
Prioritized EUS stack, AI-ready.
Executable Product Roadmap
Backlog projected onto Stints at client release cadence.
Code
Every commit AI-assisted, reviewed for context fit.
Tests
AI-readable Playwright / unit suites, auto-generated.
Infra
Terraform / Pulumi. Pit Wall owns; Pit Crew operates.
Architecture
ADRs versioned with code. Pit Crew SWEs prevent AI drift.
Handover Doc
Agent-maintained: systems, environments, first-day scenarios.
Conversation Knowledgebase
An agent-maintained base spanning all eight: every client touch-point, decision note, call recording and agreement. The shared memory across Stints and team changes. If it's not in Git, it doesn't exist.
From idea to Pit Stop: the EUS lifecycle
The Pit Wall → Pit Crew handoff is a full artifact transfer, with no verbal context. All feedback is mediated by Pit Wall; Team Principal and Pit Crew never communicate directly.
Principal
What Pit Wall produces
Three executable artifacts. Pit Crew starts production work the moment it receives any one of them. Anyone can write a Product Vision; almost no one produces an Executable Product Backlog; that is what Pit Wall sells.
Executable Product Roadmap
Backlog projected onto Stints; the throughput (EUS / week) to buy each Stint.
Executable Product Backlog
Prioritized backlog ready for AI delivery; priority = importance × delivery cost.
Executable User Story
The hero artifact: User Story + Prototype + EARS + ADR + Gherkin + test data + estimate, giving minimum-sufficient context for AI to execute without drift.
What Pit Crew returns: the four-gate Definition of Done
Input: EARS + Gherkin + ADR + Prototype. Output: a demo of working software plus four green gates. All four green = EUS closed. No partial delivery. AI Product authors the EARS (NFR) and the acceptance intent; the Pit Crew Quality Engineer hardens it into the executable Gherkin (functional + acceptance) and runs it, alongside the ADR, as Playwright / unit / integration / end-to-end gates.
Gate 1 · Unit coverage ≥ 80%
Automated on every commit; the deterministic baseline and primary engineering investment.
Gate 2 · Integration
Closed-loop; used where the integration point is the source of business risk.
Gate 3 · End-to-end
Full user journey; each test maps to a Given/When/Then scenario in the executable Gherkin owned by the Pit Crew Quality Engineer.
Gate 4 · Automated acceptance
Every Gherkin scenario in the EUS is a passing test. AI Product authors the acceptance intent; the Pit Crew Quality Engineer owns the executable Gherkin and runs it. Formal closure of the acceptance contract.
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: AI executes against whatever context it is given.
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.
| Event | Cadence |
|---|---|
| Inner cycle (Spec → Build → Align) | 2× per day |
| Pit Crew demo to Pit Wall | Every 2–3 days |
| One Stint | 1 week (default; flexes with client absorption) |
| Pit Stop (production deployment) | End of every Stint |
| UAT cycle | ~1 Stint |
The triangle moves
Scope, time, budget: the three sides of every project. Quality is the area inside; it is not a lever, and you don't shrink it. So you only ever set two sides, and RACE Programming moves the third.
more finished software, for the same budget and the same deadline.
to a business result: each piece ships the moment it is ready, not gated to a sprint.
the same scope, on the same clock.
Conservative figures, measured on delivered projects, not projections. Story Points appear only as an apples-to-apples ruler against Scrum; the client-facing unit is the Executable User Story, priced in dollars.
RACE Programming pioneered at First Line Software. Organizational structure, process, and technological stack built as an integrated system, not assembled from parts. First to prove the economics in production. The reference implementation.