Onboarding a new dev with the contextbase

A developer joined a project I'd been building with C², and was shipping real work by the end of day one. The usual ramp is two weeks. The difference wasn't the developer — it was that the knowledge they needed was already written down. This is the field note.

The usual two-week ramp

Onboarding someone normally means a slow drip of tribal knowledge. They read the code, hit a wall, find me, I explain the thing that's "obvious" once you know it, they move on, hit the next wall. Repeat for a fortnight. Most of the delay isn't the new person being slow — it's that the knowledge they need lives in my head and comes out one interruption at a time.

I'd braced for exactly that. It didn't happen.

What I handed them instead

Instead of "here's the repo, ask me when you're stuck," I handed them the contextbase — the docs/ folder that had been compounding the whole time I'd built the project. The Router as a map. The decisions, with their reasons. The gotchas. The session briefs that traced how the project actually got to where it was.

Everything I'd normally have explained in person was already written, because I'd written it for the agent — and it turned out a new human reads it just as well.

The agent as a guide through the contextbase

The other half was the agent. Rather than me walking them through the architecture, they did what I'd do on any unfamiliar codebase — they had the agent guide them, and the agent's tour was good, because it was reading the same rich contextbase, not guessing from bare code. They asked it how things worked, it answered with the actual decisions and reasons, and they built a mental model in hours.

Stuart Leo

Everything I'd normally explain in person was already written down — because I'd written it for the agent, and a new teammate reads it just as well.

This matches what teams report as agents reshape onboarding: the ramp to an unfamiliar codebase collapses when the context is there to read.

Where the gaps showed

It wasn't flawless. The new dev hit two areas where the contextbase was thin — corners of the codebase I'd never worked in with C², so they'd never been documented. There, they got the old experience: confusion, then asking me. Which was a useful signal — the gaps in the contextbase were exactly the gaps in the project's written knowledge.

What I added after

So they did the obvious thing: as they figured out those thin areas, they wrote them up — adding to the contextbase as they went, the same habit the project ran on. By the end of their first week, the corners that had tripped them up were documented for the next person. The contextbase didn't just onboard them faster. They left it better than they found it.

The contextbase onboarded the new dev faster than I could have — the knowledge was already written down.

Start here: see how to onboard to any codebase with an agent, write a session brief, or read the method.