The Method
C² — the AI-native build method.
A document-driven method built on one architectural insight: every software project runs two parallel systems — a codebase and a contextbase. Traditional methods optimise the code. C² optimises both, and treats their relationship as multiplicative.
01What C² Is
Two systems, not one
C² (C-Squared) is a document-driven, AI-native software development method built on one insight: every software project has two parallel systems — a codebase (what runs) and a contextbase (what guides).
The contextbase — PRDs, session briefs, gotcha logs, decision records, patterns — is written as part of development, lives in the same repository as the code, and is read by AI agents before they touch anything. After 50 sessions it is denser in decision context than the codebase itself. After 200 sessions it is irreplaceable institutional memory.
This is not a documentation culture. It is an execution infrastructure.
02The Equation
P = aic²is a mnemonic, not a law of physics. Read it plainly: productivity comes from AI applied to your two systems — Context and Code. The “squared” is the two Cs, not a literal exponent. If either C is zero, productivity collapses regardless of AI capability: a brilliant AI with no contextbase is improvising; a rich contextbase with no working code is documentation.
The two systems multiply each other. A richer contextbase makes AI-generated code more precise; better code surfaces insights that enrich the contextbase. Context improves Code; Code improves Context. That’s the compounding loop the method exists to capture — the real claim under the mnemonic.
All three are live levers — not constants. A 2× better model, 2× richer Context, and 2× better Code compound to 8× (2 × 2 × 2). When a new model ships, every C² project benefits overnight: the contextbase doesn’t need rebuilding, and a stronger ai reads the same compounded Context and Code.
| P | Productivity — features shipped, quality held, knowledge retained |
| ai | The AI crew — capability of the agents executing under human direction |
| c | Context — the contextbase: briefs, patterns, gotchas, decisions |
| c | Code — the codebase: the software that runs |
| c² | Context × Code — the two Cs multiply each other |
03Prompt · Context · Harness
Where C² sits
Three nested layers, each containing the one before: prompt engineering (the message — one composed input), context engineering (the memory — what a curator keeps or drops in a finite window), and harness engineering (the machine — the gather → act → verify loop that retries on failure).
C² is a harness method. The Prompt Brief is its prompt layer; the contextbase and the .md Router are its context layer; the Cascade and the verification chain are the harness. “Isn’t this just prompt or context engineering?” — no. C² sits at the harness layer and contains both.
04The Pilot Model
The developer is a pilot, not a crew member
A crewman hauls rope. A pilot sets course, reads instruments, makes decisions, and directs the crew. AI agents are the crew — they write code, run tests, manage files, generate documentation. The pilot scopes the work, reviews output, makes architectural calls, and owns the quality bar.
The reframe matters structurally. It changes what the human works on:
Crewman — wrong
- Writing boilerplate
- Chasing a bug for three hours
- Typing out a test
- Updating documentation after the fact
- Measures output in lines written
Pilot — right
- Writing the brief that constrains the boilerplate
- Invoking the debug limit and escalating
- Specifying testable acceptance criteria first
- Writing the session brief as part of the session
- Measures output in decisions made
05The Cascade — 6 Tiers
Every piece of work flows through one chain
Each tier has a defined frontmatter contract and a folder lifecycle: backlog → in-progress → review → done.
Platform PRD
└── Feature PRD ← one per feature, a living document
└── Prompt Brief × N ← the atomic build unit
└── Task × N ← zero is fine for small briefs
└── Session Brief ← every session, no exceptions
└── Release Note (optional, on completion)
└── Weekly Announcement (optional, Friday roll-up)Feature PRDs are living documents
Not frozen at creation. One PRD per feature, evolved in place. A PRD that doesn’t change is a PRD nobody is reading.
Prompt Briefs are the atomic build unit
Where the pilot-to-crew handoff happens. The brief specifies what to build, what not to build, what to read first, and the acceptance criteria. Brief quality is the bottleneck — not the AI’s capability.
Session Briefs are AI memory
Every session, no exceptions. AI agents have no memory between sessions; the session brief is the mechanism that provides it. It is written any time context is about to break — a phone call, a meeting, closing the laptop, hitting the context limit — not just at end of day. The question is never “is the session finished?” but “if I came back to this cold, what would I need to know?”
06Codebase + Contextbase
The self-improving layer
Treating docs/ as equally important to apps/ — and having the AI write to both — is C²’s most distinctive structural commitment.
project/
├── apps/ ← codebase (what runs)
└── docs/
├── 01-planning/ ← PRDs, strategy, methodology
├── 02-working/ ← Prompt Briefs, sessions, tasks, releases
├── 03-knowledge/ ← Patterns, gotchas, ADRs ← the self-improving layer
├── 04-operations/← Deployment, runbooks, debugging
├── 05-reference/ ← Tech stack, naming, constants
└── 06-agents/ ← Agent team design, roles, protocols, reviewsThe 03-knowledge/ directory is the highest-compounding asset. An agent discovers a quirk, extracts it to gotchas/ in the same session, and the next session reads the knowledge index before touching relevant code. The gotcha never costs the team time again. Gotcha capture is not optional: a session brief with a non-empty Key Discovery is not complete until the knowledge file is committed in the same session.
The Router
One file your agent reads first — the living index of the whole contextbase. We call the concept router.md; on disk you name it for your agent so it’s read automatically: AGENTS.md(the emerging cross-agent default — Codex, Cursor, and most), CLAUDE.md for Claude Code, GEMINI.md for Gemini CLI. Ship it agent-correct from day one — never rely on a rename you’ll forget.
The Router links rather than embeds, so the agent pulls only the slice the work needs — lazy-loading is the compression. And it’s maintained: as the project grows you add reference points, lists, and links, so the Router becomes the project’s living wiki — the curated entry point that keeps every session lean.
How context stays lean
The contextbase will outgrow any model’s window. C² keeps the working set small with three mechanisms, at different timescales:
Session Brief
point-in-time
At every context break, digest the session down to 'what the next agent needs cold' and drop the raw transcript. Compaction triggered by the break, not by the window filling up.
The Router
continuous
Links instead of embeds, and is kept current — so each session loads a lean, curated slice rather than the whole contextbase. The living index does the compressing.
The Learn loop
capture → consolidate
During the session, capture discoveries fast — classify each (gotcha, pattern, ADR) and write it to 03-knowledge/ so it's never lost. Periodically, consolidate: merge duplicates into canonical docs and refresh the Router's links. The wiki stays current without sprawling.
When a single session’s working set still overflows the window, borrow in-session compaction (à la HumanLayer’s ACE). C²’s three mechanisms handle the durable, cross-session half.
07The Agent Team
Agent-agnostic by design
C² works with any AI coding agent that can read files, write files, and commit to git — Claude Code, Grok CLI, Gemini CLI, Codex, Cursor. The contextbase is plain markdown. Choosing C² is not a commitment to a vendor; it’s a commitment to a method. When a better agent ships, the contextbase transfers intact.
Lead Agent
executes
Reads the contextbase, writes code, manages git, extracts knowledge, writes session briefs. One agent leads per codebase surface — running 4+ agents on the same problem creates conflicts and incoherent briefs.
Bench Agents
reviews, never executes
Independent review on high-stakes calls — PRDs, security, architecture. Budget-capped. Reviews saved with a mandatory Actions Taken table. Their value is independence: they didn't write the code.
Specialist Agents
scoped subagents
Tightly-defined roles for repeatable tasks — QA review, release-note authoring, security review. Defined in .claude/agents/ (or equivalent) with a documented protocol.
Multi-agent is a sequential practice — lead executes, bench reviews, lead acts on the review — never a parallel one. The anti-pattern emerges from urgency: throwing more agents at a blocked session. Clarify the brief instead, and let one agent proceed.
08The Principles
Five principles. Pilot in command.
AI-augmented teams create faster than they complete — speed without command becomes drift. Five principles keep you the pilot, not a passenger:
A · Fly the plane
own it
One human owns each PRD from intent to a verified outcome — accountable for the landing, not just the takeoff. Keep the cockpit small: you can only truly fly a few at once. Done means the result moved, not that code shipped.
B · No takeoff without a flight plan
brief it, trim it
A PRD becomes active work only as a Prompt Brief the agent can fly — and the brief cuts the mission to what matters, in small legs you can turn back from in minutes. No brief, no flight.
C · Build the autopilot
systematize it
Never do the work twice. Don't write the blog — embed the system that runs it. Don't work the pipeline by hand — build the agent that runs it. Ship the machine that produces the output, not the output.
D · Earn the green light
verify it
An agent hands you confident, wrong code at machine speed. Its output is a proposal, not product: it ships when the tests pass and a human clears it. Verification before velocity.
E · Every flight makes the next one better
compound it
Each delivery updates the contextbase, so the next agent starts from the new baseline — not from scratch. The team gets smarter every loop. That's the c².
09What C² Emphasises
Where C² puts the weight
Few of these are unique in isolation — native rule files, BMAD, and HumanLayer’s ACE each share a piece. C²’s contribution is combining them into one lightweight, agent-agnostic discipline, and treating the contextbase as an investment that compounds.
- 01
The Pilot mental model as a scope constraint
Not a metaphor — it makes the wrong behaviours feel obviously wrong rather than heroic.
- 02
The contextbase as a first-class product artefact
docs/ treated as equally important to apps/, with the AI writing to both.
- 03
The autonomous execution contract
A pre-flight listing exact files and line ranges forces the author to think like an architect before the agent touches anything.
- 04
The .md Router pattern
One entry point the AI reads first, lazy-loading exactly the context the work needs.
- 05
Knowledge capture to git as compounding memory
Gotchas, patterns, ADRs — written by the AI, read by the AI. It accumulates instead of evaporating when people leave.
- 06
Session briefs triggered by context breaks
Not the clock. Any break that resets AI context triggers a brief.
- 07
Multi-AI review as structured practice
Lead + bench with budget controls and close-the-loop Actions Taken tables — not ad hoc 'ask ChatGPT'.
10Prior Art
C² isn’t alone — and that’s the point
The real differentiator in 2026 isn’t the model — it’s how systematically you manage context. A lot of good people are converging on that, because it works. Here’s the honest landscape and where C² sits in it.
Native rule files
CLAUDE.md · AGENTS.md · .cursorrules
The baseline every agent supports. C² isn't a replacement — it's the method around these files: what goes in the router, how it lazy-loads, and the brief/knowledge structure it points to.
BMAD
agent-persona SDLC
Breakthrough Method for Agile AI-Driven Development — a heavier, orchestrated pipeline with specialised AI personas (PM, Architect, Dev, QA). C² is lighter and agent-agnostic, centred on the contextbase rather than a persona workflow.
HumanLayer ACE
context compaction
Advanced Context Engineering — disciplined window management and intentional compaction (research → plan → implement). Complementary: C² is where the context lives; ACE's compaction is how you keep the working slice lean. Worth borrowing.
Pocock / Packmind / Anthropic
workflows · ContextOps · the umbrella
Matt Pocock's PRD→issues→autonomous workflow shares the spirit; Packmind treats context as an enterprise lifecycle; Anthropic's 'context engineering' writing is the broader discipline C² implements with the specific vocabulary of a contextbase.
The pre-AI and academic lineage
C²’s closest pre-AI ancestor is Shape Up (appetite, outcome focus, no sprint theatre); its closest academic peer is AWS AI-DLC.
| Shape Up | AWS AI-DLC | C² | |
|---|---|---|---|
| Human role | Shaper | Approver at gates | Pilot — directing throughout |
| Context model | — | Delivery (load & use) | Contextbase (invest & compound) |
| Knowledge | Tribal | Not specified | 03-knowledge/ in git, self-improving |
| AI integration | None | Agent-agnostic pipeline | Native — exists to direct AI |
| Documentation | Basecamp | Rule files per phase | Repo-native markdown, compounds |
C²’s lane: the lightweight, agent-agnostic end of this spectrum — contextbase-as-investment, a clean brief cascade, and the Pilot model, formalised from real production work rather than theorised up front. Mix in ACE’s compaction or BMAD’s workflows where they fit; these approaches compose.
For a fuller side-by-side, read AI development methodologies compared or an alternative to Agile.
11The Proving Ground
Built in production, then formalised
C² wasn’t designed up front and then tried out. It emerged from two years of production software delivery across real commercial products, under real pressure, and was formalised afterward from what actually held up.
Built with C² across two years and 1,000+ AI agent sessions — shipping a range of real production software: SaaS platforms, websites, agents, and ecommerce stores. Every template in the method came from that build.
No anonymous percentages. No certification funnel. The method is the contribution — free and open, forever, and yours to adapt. The proof is that it shipped something real, and the commit history is public.