The AI-First Manifesto

We are rediscovering how software is built in an era when AI systems can formalize, execute, and verify engineering work. Through this practice — with working code shipped and teams transformed — we have come to value:

That is, while there is value in the items on the right, we value the items on the left more — and the shift matters.

Where the values come from

Each value derived from a theorem in AI-First Theory. Theory describes what changes. Manifesto translates to orientation: positions to hold, trade-offs to prefer. RACE Programming derives from the manifesto.

Specifications over implementations

Theorem 2: the specification — not the code — becomes the primary artifact of engineering skill. Invest engineering time in making specifications sharper. Implementation is downstream — often automated, always verifiable against the spec. What cannot be specified is what humans are for. This inverts decades of practice where "requirements" were cheap upstream and "implementation" was where skill concentrated.

Verification over generation

Theorem 3: code-writing-to-verification ratio inverts from 3:1 to 1:3. Engineering judgment expressed through what a system does not do — tests that must pass, invariants that must hold, properties that must be preserved. Code is inexpensive; correctness is what you are selling. Measure your team by what they verify, not what they generate.

Context curation over comprehensive documentation

Theorem 5: AI-executed development bounded by context quality. Stale context is the primary failure mode. A large stale wiki is worse than no wiki — AI systems read it and act on it. Context must be versioned, minimized, invalidated aggressively. Comprehensive documentation is a liability when readers execute the contents.

Team compression over team scale

Theorem 4: AI-augmented team of N humans produces output of 5N–10N humans — provided roles, process, and tooling are aligned. Stop scaling teams the way the industry did in the 2010s. Three people with aligned roles out-deliver ten with mixed ones. Role boundaries must be redrawn around what AI absorbs, not what humans specialize in.

Methodology redesign over tool adoption

Theorem 6: Waterfall, Scrum, SAFe, Kanban — not neutral substrates for AI augmentation. Structural assumptions incompatible with AI-native execution. Stop treating tool adoption ("we bought Copilot licenses") as organizational change. Methodology is where leverage lives. A better AI tool does not change how you deliver unless the methodology changes with it.

Hybrid authorship over pure-human or pure-AI work

Derived from both axioms — Formalization and Tacit Transfer — not a single theorem. The question "was this human-written or AI-written?" is wrong for 2026. Every meaningful engineering artifact is co-authored. The right question: was the authorship designed? Human judgment where it belongs — specification, verification, edge cases. AI execution where it belongs — boilerplate, refactors, pattern application. "Hybrid by design" is the operational stance.

Ten principles

We follow these principles:

1. Deliver working software at a cadence and cost previously unattainable.

   Through the disciplined collaboration of human judgment and AI execution. This is the promise of AI-native delivery; everything below is in service of it.
2. What can be specified can be delegated.

   Invest in specification skill as the compounding engineering asset. Teams that write specs well build a moat that cannot be automated away.
3. What cannot be specified is what humans are for.

   Welcome ambiguity — it is where your engineering value concentrates. The tasks that resist formalization are the ones where human judgment compounds.
4. Prefer verification that can be automated.

   Test design, property-based assertions, and formal invariants are higher-leverage than post-hoc code review. Review the verification, not the generation.
5. Treat context as a first-class artifact.

   Version it, minimize it, and invalidate it aggressively. Stale context is toxic context. Context management becomes the discipline formerly known as code hygiene.
6. Keep cycles short.

   The economics of AI-native work favor one-week iterations or faster. Longer cycles accumulate context rot faster than they accumulate value.
7. Compress teams.

   A small team with aligned roles out-delivers a large team with hybrid roles. Let the AI absorb the scale; let humans be few, specific, and indispensable.
8. Prefer prescriptive methodology to permissive framework.

   When stakes are high and leverage is high, ambiguity in process is expensive. Prescription is not bureaucracy — it is how mature methodologies protect their own economics.
9. Build the stack; don't buy it.

   AI-native delivery requires integrated artifacts, tooling, and ceremonies designed together. Off-the-shelf adaptations underperform; the parts must be made to fit one another.
10. Publish openly.

    Methodology strengthens through critique. What is not falsifiable is not a methodology. What is hidden in proprietary slides is not a methodology either.

Why a new manifesto

The Agile Manifesto (2001) correctly responded to heavyweight documentation-driven processes. Its values — "working software over comprehensive documentation," "responding to change over following a plan" — hold.

Agile was written for a world where code production was the bottleneck; humans the sole generative agents. That world is ending. When AI generates production-quality code from specs, the bottleneck shifts to specification and verification. When AI absorbs context and executes, team composition shifts from "who will write this" to "who will specify and verify this."

Agile's values are under-specified for this regime. The AI-First Manifesto extends them: specification over implementation is compatible with "working software over comprehensive documentation" — but sharper. This manifesto is not a replacement. Values for the inflection point Agile did not anticipate.

From manifesto to methodology

A manifesto articulates values. A methodology prescribes behavior. The values above are the philosophical bridge between AI-First Theory (the description of what changes) and RACE Programming (the prescription of what to do about it).

Accept the theory, reject a manifesto value → a variant methodology is possible. Accept the values, reject a RACE Programming prescription → experiment with alternative methodologies that share these values. Accept the full stack → RACE Programming is the reference implementation.

The stack is vertical: theory → manifesto → methodology. Each layer is more prescriptive than the one above, and each depends on the one above being sound.