Knowledge Base

Concepts

The vocabulary of C², defined. Each term links into the method where it’s used in full.

Core ideas

P = aic²: Productivity = AI × (Context × Code). A mnemonic, not a law of physics — the "squared" is the two Cs, not a literal exponent. Your output is the AI crew multiplied by the Context and Code you build around it.
The two Cs: Context and Code — the two systems C² optimises, and the two letters in C². They multiply; if either is zero, productivity collapses.
Contextbase: What guides: briefs, patterns, gotchas, decisions. Written as you work, committed to git, read by the AI before it acts. It compounds.
Codebase: What runs: the software itself. Richer context makes sharper code; cleaner code surfaces sharper context.
Pilot / Crew: The human is the pilot — sets course, reviews, owns the quality bar. The AI is the crew — writes code, runs tests, manages files.
Harness engineering: The layer C² operates at — the gather → act → verify loop. The three layers nest: prompt ⊂ context ⊂ harness, each containing the one before. C² is a harness methodology.
The layer triage: A diagnostic for what broke, not a stack of what you build: cannot operate → the environment · unreliable → the loop and its stop rule · the process is complex → the topology. Deliberately not the same three as prompt/context/harness.

The Cascade: The six-tier chain every piece of work flows through: Platform PRD → Feature PRD → Prompt Brief → Task → Session Brief → Release Note. It doesn't terminate — it closes back onto the PRD.
Prompt Brief: The atomic build unit — where the pilot hands off to the crew. Interactive (pilot present) or Autonomous (pilot absent). One brief ≈ one pull request.
Quality gate: The six-item check — goal, scope exclusions, testable AC, non-goals, testing approach, definition of done — every brief passes before execution.
Bank switch: How a PRD compounds without hoarding: each version absorbs the last (v1.0 → v1.1 → v2.0), leaving one live artefact that says where the work is now.

Node: One agent doing one bounded job. In C² a node is a Prompt Brief, and the brief is its contract.
Edge: What crosses between two nodes — one agent's output becoming another's input. "And then" is not an edge. Name it by the artefact, not the order.
Surface: Everything an agent mutates or contends for — files, data, external resources, a deploy target. Two agents on one surface is the anti-pattern.
The concurrency rule: Agents may run concurrently exactly when no edge connects them and no surface is shared. The test is the surface, not the headcount.
False independence: Two agents whose briefs never mention each other, colliding over a shared database, a rate-limited API, or one deploy target. A hidden edge.
Fan-out / barrier: Independent nodes running at once is a fan-out. Where their results merge — the integration brief, the PR — is a barrier. A barrier makes everything wait for the slowest, so earn it.
Isolation: Stopping one node's mess reaching the others — a git worktree per agent. It isolates the filesystem and nothing else.
The shape: The fifth part of a filed flight plan: which briefs are independent, which are joined by an edge, where the barrier sits, which edges get verified.

Anchor: The one signal that decides done, which no agent in the run can produce by asserting it. A test that ran. A query that returned rows. A deploy that resolved.
Loop on evidence: "The agent says it's done" is not a stop condition. Neither is "the review passed" when the review read the builder's own account of the work.
Frozen rule: A rule marked non-negotiable precisely because it's the one an optimiser would bend to win. Every frozen rule exists because it got bent once.
Verified edge: A result that gets an independent pass before it counts. Independence is mechanical: a different model, inputs the author can't control, and teeth.

Flight Planning: The gate between "I have a PRD" and "I'm running build sessions against it". Five parts: the line, the briefs, the journey, the shape, and an optional red line.
Closing the Flight Plan: The landing gate. A filed plan is closed on arrival — the landing, the deviation, the anchor, the learning. Filing spends context; closing makes it.
The three gates: Flight plan (per PRD, judgement) · pull request (per PR, correctness) · closing (per PRD, judgement). The outer two bookend the build under one owner.
The sweep: Clearing the previous cycle's findings at the bank switch — done by the next flight plan, not by the closing.

The Router (router.md): The file your agent reads first — the living index of the contextbase. Named for your agent. Links rather than embeds.
Knowledge index: The index of 03-knowledge the Router points to. The AI reads the index, not every file.
Learn loop: Capture discoveries fast during a session, then periodically consolidate them into 03-knowledge and the Router.
Compaction: Keeping the working context lean. C² does it three ways: the Session Brief, the Router, and the Learn loop.

Lead agent: Executes — reads context, writes code, manages git, writes briefs. One leads per codebase surface.
Bench agent: Reviews, never executes. Independent second opinion on PRDs, security, architecture. Budget-capped.
Specialist agent: A scoped subagent for repeatable tasks — QA review, release notes, security review.

WIP cap: Max five in-progress PRDs. Anything above goes to backlog — forces completion before starting.
Brief-before-active: A PRD can't go in-progress without at least one Prompt Brief. If you can't write a brief, it's a thinking document.
Monthly PRD review: A 30-minute monthly pass: walk every in-progress PRD; force-move stale ones to backlog.