RACE Programming
By Pavel Khodalev, CTO at First Line Software ·
Glossary · Definition

What is an agentic SDLC?

An agentic software development lifecycle (SDLC) is a way of organizing software delivery in which AI agents read, write, and verify code as first-class participants, and the human role shifts from producing code to specifying intent precisely and validating AI-generated output. The bottleneck moves from writing software to specifying it well enough to delegate.

The shift

From AI-assisted to agentic

Most teams today practice AI-assisted development: an AI tool is added to a process that was designed for human-only teams. A developer writes code with autocomplete help, but the lifecycle around them is unchanged: same sprints, same artifacts, same hand-offs.

An agentic SDLC redesigns the lifecycle around the AI as a teammate. Artifacts become machine-readable. The agent executes against precise specifications rather than prose. Feedback loops tighten so the agent can self-correct. And the senior human skill becomes validation: reading AI-generated output and deciding what is structurally right, not merely what passes tests. The change is structural, not a matter of adding a tool.

Characteristics

What makes an SDLC agentic

  • Executable specifications: work is described precisely enough for an agent to execute without re-interpreting intent.
  • Everything as Code: code, tests, infrastructure, architecture, and handover docs are machine-readable and versioned in Git.
  • Fast feedback loops: deterministic gates (tests, CI) let the agent self-correct in minutes, not days.
  • Role-specific context boundaries: each participant gives the agent minimum-sufficient context, not excess.
  • Validation as the senior skill: judging AI output replaces producing code as the highest-value human work.
Implementation

How RACE Programming implements it

RACE Programming is a prescriptive Agentic SDLC framework: engineer-led, agent-executed. It makes the abstract characteristics above concrete:

  • Roles: Team Principal (the client), the Pit Wall (Forward Deployed Engineer + AI Product), the Pit Crew (Pit Crew Quality Engineer + Pit Crew Software Engineers), and the Silicon Software Engineer, the AI agent present in both tiers, which does not add human headcount.
  • Originating artifact, the Executable User Story: user story + working prototype + NFR (EARS) + architecture (ADR) + acceptance (Gherkin) + test data + a delivery-cost estimate, precise enough for the agent to build without re-interpreting intent.
  • Cycle: the Stint, a one-week delivery cycle ending in a Pit Stop (production deployment), with a twice-daily Inner Cycle of Spec → Build → Align.
  • Discipline: Everything as Code and a four-gate Definition of Done (unit ≥80%, integration, E2E, automated acceptance).

RACE Programming is the prescriptive form of the agentic SDLC. It specifies the roles, artifacts, cadence, and engineering discipline that an agentic lifecycle needs to run in production.

Read the framework → · Read the theory → · RACE Programming vs Scrum →

FAQ

Frequently asked questions

What is an agentic SDLC?
An agentic software development lifecycle (SDLC) is a way of organizing software delivery in which AI agents participate as first-class actors across the lifecycle (reading, writing, and verifying code) rather than acting only as autocomplete tools. The human role shifts from producing code to specifying intent precisely and validating AI-generated output. The bottleneck moves from writing software to specifying it well enough to delegate.
How is an agentic SDLC different from AI-assisted development?
AI-assisted development bolts an AI tool onto an unchanged process: a developer writes code with autocomplete help inside a workflow designed for human-only teams. An agentic SDLC redesigns the process around the AI as a teammate: artifacts become machine-readable, the AI executes against precise specifications, and the senior human skill becomes validation. The difference is structural, not tooling.
What are the characteristics of an agentic SDLC?
Specifications precise enough for an agent to execute without re-interpreting intent; machine-readable artifacts (Everything as Code: code, tests, infra, architecture, docs, all versioned in Git); fast deterministic feedback loops so the agent can self-correct; explicit context boundaries per role; and validation as the senior engineering skill, which means reading AI-generated output and judging what is structurally right, not merely what passes tests.
Is RACE Programming an agentic SDLC?
Yes. RACE Programming is a prescriptive Agentic SDLC framework. It specifies the roles (Team Principal, Pit Wall, Pit Crew, and the Silicon Software Engineer, the AI agent), the originating artifact (the Executable User Story), the delivery cycle (the Stint, ending in a Pit Stop), and the engineering discipline (Everything as Code, a four-gate Definition of Done). It is engineer-led and agent-executed.
Why does an agentic SDLC need new roles?
Because the work changes shape. When an AI agent executes implementation, the valuable human work is upstream (specifying intent, designing architecture) and downstream (validating output). Traditional roles built around manual production no longer map cleanly. RACE Programming collapses several specification roles into one AI-native AI Product role, elevates validation into the Pit Crew Quality Engineer and Forward Deployed Engineer, and names the AI agent itself the Silicon Software Engineer.