New course · in production · 7 modules planned · 21 lessons so far

Brilliant on a toy app. Lost in the monolith?

Every AI demo you have watched runs against nine tidy files. Your codebase has four thousand, three generations of conventions, and a module nobody has opened since 2014, which is why none of it transfers. That is not your fault. This course is the part nobody demos.

$79 USD · instant access · Lifetime access · 14-day refund, no questions

Working with a Massive Codebase cover slide
1.8MLines in the repo we use
21Lessons so far · 7 modules planned
4Skills you keep for good
200KTokens · your whole window

It isn’t you, and it isn’t the model.

You have watched the same demos I have. Somebody opens a fresh project, types a sentence, and a working feature falls out. Then you try it on the thing your company actually runs, and the agent confidently edits a file that has not been imported since 2019.

I did this for three years inside the VS Code repository at Microsoft, and I still get it wrong when I am lazy about context. The skill nobody teaches is deciding what the model sees, which is the only part of this you fully control.

“A big repo does not need a smarter agent. It needs a smaller question.”

VS Code is the patient. The procedure is the point, and it transfers to any repository too large to hold in your head, in any language, on any stack.

The window is not the problem. The filling of it is.

A million-line repository is roughly 6.8 million tokens. Your context window holds two hundred thousand on a good day, which is under three percent of the codebase. No model release fixes that ratio, because the repositories grow too.

So the agent reads whatever it stumbled into first, runs out of room, compacts, and then explains its plan with total confidence. It is not lying to you. It is answering from a context you never chose.

You end up reviewing a forty-file diff you did not ask for, on a Friday, against a service three other teams depend on.

Five ways it goes sideways.

These are not hypotheticals. Every one of them happens on camera in Module 1, in a repository far too big for the agent, and each has a fix you can run the same afternoon.

01

Context overflow

02

Lost in the middle

03

Post-compaction fiction

04

Blast-radius blindness

05

Wrong-layer edits

We do this on a repo nobody can call a toy.

I spent three years on the VS Code team at Microsoft, so I know what is inside that repository and roughly where the bodies are buried. Cursor and Windsurf cloned the same code, found the seam where the AI plugs in, and turned it into billion dollar companies. The seam is still open.

We clone it too. By the end of Module 5 your own model is answering in the chat panel where Copilot used to be, and nothing along the way is staged: you watch agents fail, you watch me work out why, and every fix gets bottled into something you can run on Monday.

One method, four reusable skills.

Every module ends with a task you run on your own repository, not on mine. By the last one you are not following along any more, you are running the method against a codebase in a language the course never touched.

You leave with a toolkit, not notes.

Fig. 05 · The loop

What you actually run

01

Recon

map before you touch

02

Aim

six files, not nine hundred

03

Transform

build the machine

04

Verify

make it earn the merge

05

Keep

bottle it as a skill

What you’ll learn

Seven modules, one repeatable method.

Each module is a working session against a real repository, cut down to the decisions, with a task at the end that you run on your own code.

  1. Module 01

    Where Good Agents Go to Die

    Watch an agent fail five ways in one giant repo: overflow, lost in the middle, post-compaction fiction, blast-radius blindness, edits at the wrong layer. One cause behind all five, and it is never the model.

  2. Module 02

    Cold Repo to Coffee in Ten Minutes

    Fan subagents across a million lines and get back a map, a glossary, the entry points, and the files where one change ripples everywhere. Then make the repo write the CLAUDE.md it never had.

  3. Module 03

    Surgical Strikes in a Million Lines

    Symbol navigation instead of reading files, which cuts token burn by an order of magnitude. Trace one request through the whole stack, and know what breaks before you break it.

  4. Module 04

    Refactor 1,000 Files for the Price of One

    Do not make the change, build the machine that makes it. Codemods over in-context edits, parallel headless agents for what a script cannot express, and the test suite babysitting all of it.

  5. Module 05

    The Codebase Everyone Is Afraid Of

    Characterization tests pin behavior nobody remembers. Git history as an archaeology dig, a bug hunted across four layers, and the transplant: your own model wired in where Copilot used to be.

  6. Module 06

    Trust Nothing, Verify Everything

    Read a 40-file diff without losing the plot. Summary by intent, sorted by risk, scope creep caught on camera, and the reflex that catches an agent being confident about code that does not exist.

  7. Module 07

    Never Solve the Same Problem Twice

    Everything you did becomes a skill you keep. The Explore firewall so subagents read wide while your window stays clean, habits with real triggers, and a final run at a repo in a new language.

This course is being made right now.

Lessons show up in your account as they are written, and anything listed but not on camera yet is marked TBD. We might add a lesson, drop a lesson, or split one in half because it turned out to be two. We’re not quite sure yet. Buy once and all of it is yours as it lands.

What you keep

Four skills that outlive the course.

Drops straight into your own .claude/skills folder, and works on repositories that do not exist yet.

01

repo-recon

Point it at a repository you have never opened and get back the architecture, the vocabulary, the entry points, and the landmines.

02

impact-map

What depends on the thing you are about to change, and what it depends on. Read before the edit, not after the incident.

03

codemod

The default move for anything touching more than a few files. Write the transform, run it over a thousand files, review one script.

04

characterization-tests

Rope around untested code before you climb it. Pins current behavior so a refactor that changes it fails loudly.

Who am I to be showing you this stuff?

I’m Rob Conery, and I’ve been building software for over 25 years. I spent a decade at Microsoft, three of those years on the VS Code team, which is the repository this course takes apart. Before that I wrote SubSonic, founded Tekpub, and wrote The Imposter’s Handbook.

I use agents every single day on codebases far past the size where the demos stop working, and I have wrecked enough of my own afternoons to know exactly where they go wrong. That is the whole course: the failures, and what I do about them.

$79 one time · lifetime access · no subscription required

Course · Checkout

Working with a Massive Codebase

Drive AI agents through a million lines of code you did not write. Recon, surgical navigation, codemods, characterization tests, and a toolkit of four reusable skills you keep.

$79One payment. Nothing renews.

What you get

  • Working with Large Codebases
Guarantee

Watch the whole thing. If it does not change how you work in a big repo, tell me inside 14 days and I will refund you. No friction, no hard feelings.

What happens next

  1. Pay right here, on this page.
  2. Stripe handles your card. This site never sees the number.
  3. You land back here with your access switched on and a receipt in your inbox.

Your order

Working with a Massive Codebase
$79
Getting the secure form ready…

Stripe handles your card. This site never sees the number.

Working with a Massive Codebase

Stop losing to the repo that pays you.

$79 gets you all seven modules, the four skills, and everything still being recorded. 14 days to change your mind, no questions asked.

Get the course - $79Continue watching