C² vs native rule files: when one CLAUDE.md isn't enough

Everyone building with AI agents starts the same way: a single rules file. CLAUDE.md, AGENTS.md, .cursorrules — one markdown file the agent reads first. It's the right place to start. It's also where most people stall, because a single file quietly stops scaling and it's not obvious why.

Here's an honest look at what a native rule file does well, the exact walls you hit, and how C² extends it rather than replacing it.

Where everyone starts (and why it's right to)

A native rule file is the agent's first context: a bit about the project, a few rules, maybe where things live. Zero setup, universal, agent-native. You make the file, the agent reads it, you're building.

This is genuinely the correct starting point. You shouldn't reach for a methodology on day one of a weekend project. A single rule file is the right tool for a small, solo, short-lived build — and for that, it's enough.

What one file does well

Give it its due:

• Instant. No structure to learn, no scaffold to set up.
• Universal. Every agent reads some version of it.
• Right there. It's the file the agent definitely loads, so anything in it lands.

For orienting an agent to a small codebase, a rule file is hard to beat. The problem isn't that it's bad. The problem is that it's the only structure, and one file can't be everything.

The three walls you hit

As the project grows, a single file runs into three walls — fast.

1. The bloat wall. You keep adding rules until the file is hundreds of lines. Then the agent skims it and starts missing things that are right there in the text. One file has no way to separate "read this every time" from "read this only when relevant." (This one's common enough to have its own field note.)
2. The memory wall. A rule file holds rules, not history. It has no place for what happened last session, what was decided and why, or the gotcha you hit yesterday. So the agent keeps relearning, and the knowledge evaporates.
3. The second-person wall. A rule file is a solo artifact. The moment a collaborator (or a second agent) joins, there's no shared structure for hand-off, no briefs, no async memory — just one file that was really only ever yours.

Stuart Leo

A single rules file isn't wrong. It's the seed. The trouble starts when you ask the seed to be the whole tree.

The empirical work on context files for agentic coding lands in the same place: focused files that point outward beat one exhaustive file, because the exhaustive file stops being read.

How C² is the structure that file is missing

C² doesn't throw your rule file away. It promotes it. Your CLAUDE.md becomes the Router — the entry point that indexes everything else — and around it C² adds the structure a single file can't hold:

• A contextbase. A docs/ folder where briefs, decisions and gotchas live, so knowledge accumulates instead of bloating one file.
• Session briefs. Written memory across sessions, so the agent and your collaborators start from what was learned.
• A knowledge layer. Gotchas captured once, read before the relevant code, never re-discovered cold.

The rule file was the seed. C² is the system it grows into — and crucially, it's the same plain markdown in git, so adopting it is extending what you have, not migrating off it.

Side by side

How to choose

• Stay on a single rule file if the project is small, solo, and short — don't over-engineer a weekend build.
• Move to C² the moment you hit a wall: the file's bloating, the agent's relearning, or someone else joins. That's the signal the seed has outgrown its pot.

A single rules file isn't wrong — it's the seed. C² is what it grows into.

Start here: how to write an AGENTS.md that agents follow, how the methodologies compare, or read the method.