Articles
Articles
How builders use and adapt C² — practical how-tos, worked examples, and the thinking behind an adaptive build method.
MethodJun 26, 2026
Flight Planning: file the plan before you take off
Flight Planning is the C² review where you file your plan — scope, briefs, and ETA — before an agent builds. What it is, who's in the room, and why.
MethodJun 9, 2026
Add a contextbase to a legacy codebase
A legacy codebase holds years of tacit knowledge the agent can't see. How to build a contextbase for an existing project, incrementally, without boiling the ocean.
ComparisonJun 9, 2026
C² vs enterprise AI coding platforms
Enterprise platforms sell governance, SSO and control for AI coding. C² gives you a method and context you own. What each is for, and where they meet.
ComparisonJun 9, 2026
Context files vs fine-tuning for your codebase
Want an agent that knows your codebase? You could fine-tune a model or write context files. Why context wins for most teams — cheaper, faster, and yours.
FoundationsJun 9, 2026
Crawl, walk, run: adopting AI agents safely
Teams that jump straight to autonomous agents fail. The crawl-walk-run path that gets AI agents from first try to production work — without the wreckage.
MethodJun 9, 2026
Defend against prompt injection in coding agents
Prompt injection turns content your agent reads into commands it follows. Why coding agents are exposed, the real incidents, and the defences that hold.
MethodJun 9, 2026
Document an inherited codebase with an agent
Inherited a codebase with no docs? An agent can read it and draft the documentation — if you direct it well. How to turn an opaque codebase into a contextbase.
ComparisonJun 9, 2026
Greenfield vs brownfield: building with agents
Starting fresh and working in a legacy codebase are different sports with AI agents. What changes, why brownfield is harder, and how to handle each.
MethodJun 9, 2026
Least privilege for coding agents: scope the blast radius
An agent can only do damage where you let it reach. How to apply least privilege to coding agents — file scope, command limits, no prod, sandboxes.
FoundationsJun 9, 2026
Onboard to any codebase in hours with an agent
Understanding an unfamiliar codebase used to take weeks. An agent can guide you through it in hours — here's how to use one to get oriented fast.
Field notesJun 9, 2026
Onboarding a new dev with the contextbase
A field note on a new developer who got productive in a day instead of a fortnight, because the contextbase already held what usually lives in people's heads.
ComparisonJun 9, 2026
PRD-first vs prototype-first with AI
Should an agent write the spec or build the prototype first? The case for each, when a clickable prototype beats a document, and how C² uses both.
Field notesJun 9, 2026
Rolling C² out to my team: what stuck, what didn't
A field note on introducing C² to a team — the parts that caught on immediately, the parts that met resistance, and what I'd do differently.
MethodJun 9, 2026
Keep secrets safe when coding with agents
An agent with shell access and secrets in scope is the worst-case setup. How to keep API keys and credentials out of an agent's reach — and out of its context.
MethodJun 9, 2026
The Cascade: from PRD to Prompt Brief
Big goals don't fit in one prompt. The C² Cascade breaks work from Platform PRD down to the Prompt Brief an agent can actually build. How the tiers fit.
Field notesJun 9, 2026
The legacy codebase the agent couldn't read
A field note on pointing an agent at a ten-year-old codebase, watching it confidently misunderstand everything, and the context that finally let it help.
Field notesJun 9, 2026
The prompt injection I almost shipped
A field note on an agent that read a malicious instruction buried in a dependency's docs, nearly acted on it, and what caught it before it shipped.
Field notesJun 9, 2026
The secret that leaked into context
A field note on an API key that ended up in an agent's context window, where it didn't belong, and the rule I keep now to stop it happening again.
FoundationsJun 9, 2026
What is a PRD, and why agents need one
A PRD — product requirements document — says what to build and why. Why AI agents need one even more than human teams, and what goes in it.
FoundationsJun 9, 2026
Why most AI agent pilots never reach production
Most AI agent pilots never ship — and it's rarely the agent's fault. The real blockers are governance, context and trust, and how to clear them.
MethodJun 9, 2026
Write a PRD with an AI agent (without the fluff)
An agent can draft a product requirements document fast — and pad it with fluff just as fast. How to write a tight, build-ready PRD with an agent.
MethodJun 8, 2026
Write acceptance criteria your agent can check itself
The difference between an agent that drifts and one that self-verifies is acceptance criteria you can run. How to write briefs with criteria the agent checks itself.
ComparisonJun 8, 2026
Agentic coding vs AI pair programming
Pair programming has the AI beside you, suggesting. Agentic coding has it running the loop while you direct. The difference, and which one you're doing.
FoundationsJun 8, 2026
AI agent teams, explained: lead, bench, specialist
When one agent isn't enough you reach for a team — but more agents on one problem makes things worse, not better. The roles that actually work, and why.
MethodJun 8, 2026
Set up AI code review with a bench agent
An independent agent reviewing the work — not the one that wrote it — catches what the author misses. How to run a bench-agent review that adds signal.
ComparisonJun 8, 2026
AI-native vs traditional SDLC: what actually changes
The software lifecycle was built for human teams at human speed. What an AI-native lifecycle keeps, what it drops, and where the real bottleneck moves.
ComparisonJun 8, 2026
C² vs AWS AI-DLC: pilot versus approver at the gate
AWS AI-DLC and C² are the closest AI-native peers. The two telling differences: human as approver-at-gates vs pilot, and context as delivery vs investment.
ComparisonJun 8, 2026
C² vs GUARDRAILS.md: safety that compounds
GUARDRAILS.md captures safety lessons so an autonomous agent stops repeating failures. A useful file — and how it relates to a contextbase that compounds.
ComparisonJun 8, 2026
C² vs native rule files: when one CLAUDE.md isn't enough
CLAUDE.md, AGENTS.md and cursorrules are where everyone starts. An honest look at what a single rules file does well, where it breaks, and how C² extends it.
ComparisonJun 8, 2026
C² vs spec-driven development: specs that persist
Spec-driven development makes an executable spec the source of truth. C² agrees — and adds the part SDD leaves out: a contextbase that compounds across every spec.
MethodJun 8, 2026
Compaction: keeping your agent's context window lean
Every model degrades as its context fills — context rot. Compaction keeps the working set lean without losing what matters. The three mechanisms C² uses.
FoundationsJun 8, 2026
Context engineering, explained: the skill that replaced prompting
Context engineering is the discipline that overtook prompt engineering: curating what your AI agent knows before it acts. What it is, why it matters, and how to start.
FoundationsJun 8, 2026
Context engineering for people who aren't engineers yet
Context engineering is the skill of writing down what your AI agent needs to know so it acts well. A plain-English guide for builders from business, not CS.
ComparisonJun 8, 2026
Context engineering vs RAG for coding agents
RAG retrieves context on the fly; context engineering curates and keeps it. How they differ for coding agents, where each fits, and why a contextbase isn't RAG.
ComparisonJun 8, 2026
Cursor vs Claude Code: why C² works with either
Cursor or Claude Code or Codex — the tool debate misses the point. Why an agent-agnostic method means you can pick any, and switch without losing context.
FoundationsJun 8, 2026
How to build software with AI agents: a starting guide
A plain-English guide to building real software with AI coding agents — the loop, the context, and the habits that separate shipping from vibe-coding into a mess.
FoundationsJun 8, 2026
How to stop your AI agent forgetting what it learned
AI agents forget everything when the session ends or the context window fills. Why the memory wall happens — and the written-context fix that makes learning stick.
MethodJun 8, 2026
How to write an AGENTS.md that agents actually follow
AGENTS.md (and CLAUDE.md) is the file your coding agent reads first. How to write one that's read, not ignored — what belongs in it, and how to keep it lean.
Field notesJun 8, 2026
I ran five agents at once and regretted it
A field note on spinning up five agents on one feature to go faster, the contradictory mess that followed, and the sequential rhythm I use now instead.
ComparisonJun 8, 2026
Multi-agent vs single agent: when more agents help
More agents sounds like more power — and on one problem it's usually the opposite. When multi-agent genuinely helps, when a single agent wins, and why.
Field notesJun 8, 2026
My agent bill tripled — here's what fixed it
A field note on an AI coding bill that tripled in a month, finding the culprit (re-sent context and the wrong model everywhere), and the two changes that fixed it.
MethodJun 8, 2026
Run parallel agents with git worktrees
Several agents on one repo means merge chaos — unless each gets its own worktree. How git worktrees give parallel agents isolation, and how to merge cleanly.
ComparisonJun 8, 2026
Prompt engineering vs context engineering for coding
Prompt engineering tunes the instruction. Context engineering curates what the agent knows. Why the second is the skill that now pays — and how C² operationalises it.
MethodJun 8, 2026
Route models to cut your AI agent bill
Running everything on the top model is the easiest way to overpay. Route by task — cheap models for discovery, strong ones for hard reasoning — and cut the bill.
MethodJun 8, 2026
How to run AI coding agents overnight, safely
Unattended agents can ship real work while you sleep — or wreck things. The guardrails that make overnight runs safe: branches, scopes, cost caps, no prod.
MethodJun 8, 2026
Subagents, MCP and skills: fitting tools into C²
Subagents, MCP servers, slash commands, skills — the agent harness has a lot of tools. How they fit a C² contextbase, and which to reach for without losing the plot.
MethodJun 8, 2026
Test-driven development with AI agents
TDD turns an agent from hopeful to reliable: write the test first, let the agent go red-green-refactor at machine speed. How to run it, and what it needs.
MethodJun 8, 2026
The 30-minute debug limit: when to stop the agent
An agent stuck on a bug will burn an hour going in circles. The pilot's move is a time limit and an escalation — here's how to set and use one.
Field notesJun 8, 2026
The agent kept relearning the same thing
A short field note on watching an AI agent rediscover the same gotcha three sessions running, and the gotchas file that finally made it stick.
Field notesJun 8, 2026
The CLAUDE.md that got too big
A short field note: my Router file bloated into an unreadable wall of rules. How I noticed, what I moved where, and the line-count rule I now keep.
Field notesJun 8, 2026
The day context rot bit me at 80% full
A field note on watching a long session quietly degrade as the context window filled — the wrong outputs, the late diagnosis, and the compaction habit I keep now.
Field notesJun 8, 2026
The overnight run that went wrong
A field note on letting an agent run unattended overnight, waking to a branch full of confident damage, and the guardrails I never skip now.
FoundationsJun 8, 2026
The Pilot model: directing agents instead of typing
The biggest shift in building with AI isn't the code the agent writes — it's that you stop being crew and start being the pilot. What that changes, in practice.
MethodJun 8, 2026
The Router file, line by line: your agent's first read
A walk through the C² Router (CLAUDE.md / AGENTS.md): the file your agent reads first. What to put in it, what to push to docs, and how to keep it from bloating.
Field notesJun 8, 2026
The test that saved the refactor
A field note on a big agent-driven refactor that should have broken everything, and the test suite that turned a risky change into a boring one.
Field notesJun 8, 2026
I vibe-coded into a corner — here's the climb out
A field note on letting an agent vibe-code a feature with no spec, the mess that followed, and how a brief with acceptance criteria turned it around.
FoundationsJun 8, 2026
What is a contextbase? The asset that makes agents remember
A contextbase is the version-controlled folder of markdown your AI coding agent reads before it acts. What goes in it, why it compounds, and how to start one today.
FoundationsJun 8, 2026
What is agentic coding? Beyond autocomplete
Agentic coding is the shift from AI autocomplete to an agent that plans, edits, runs and verifies in a loop. What it is, how it differs, and how to start.
FoundationsJun 8, 2026
What is an agent harness? Agent = model + harness
An AI agent is the model plus the harness around it — the tools, memory, and the gather-act-verify loop that make it act. What a harness is, and where C² fits.
FoundationsJun 8, 2026
Why AI agents get expensive (and how to fix it)
Agentic tasks burn far more tokens than chat — mostly from re-sending context every call. Why the bill climbs, and how leaner context brings it down.
MethodJun 8, 2026
Write your first session brief
A session brief is a short note at the end of each working session: what changed, why, what's verified, what's next. How to write one and why it compounds.
MethodJun 1, 2026
C² is adaptive, not fixed: bend it to your project
The folder structure is a starting shape, not a rulebook. Here's how to bend C² to your project instead of bending your project to C².
ComparisonJun 1, 2026
AI development methodologies compared: C², BMAD & more
An honest comparison of the methods for building with AI agents — native rule files, BMAD, ACE, Shape Up, AWS AI-DLC and C² — with a side-by-side table and how to choose.
ComparisonJun 1, 2026
An alternative to Agile for AI-native teams
Agile coordinated humans at human speed. With AI agents in the loop, the constraint shifts from execution to direction — and the ceremonies become drag.
ComparisonMay 31, 2026
C² vs BMAD: two ways to build with AI agents
BMAD and C² both bring discipline to building with AI agents — BMAD runs personas through a heavier SDLC, C² centres on a contextbase you own that compounds.
How-toMay 30, 2026
Add a 07-metrics folder: extending C² to fit your work
A worked example of extending C² — adding a metrics layer to docs/ when your project needs to track velocity and estimation accuracy.
ComparisonMay 29, 2026
C² vs Shape Up: from human teams to human + AI teams
Shape Up gave product teams appetite-based betting and an escape from sprint theatre. C² keeps those instincts and adds what AI needs — a contextbase that compounds.