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
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.
Context overflow
Lost in the middle
Post-compaction fiction
Blast-radius blindness
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
Recon
map before you touch
Aim
six files, not nine hundred
Transform
build the machine
Verify
make it earn the merge
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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
repo-recon
Point it at a repository you have never opened and get back the architecture, the vocabulary, the entry points, and the landmines.
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.
codemod
The default move for anything touching more than a few files. Write the transform, run it over a thousand files, review one script.
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
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
- Pay right here, on this page.
- Stripe handles your card. This site never sees the number.
- You land back here with your access switched on and a receipt in your inbox.
Your order
Working with a Massive CodebaseStripe handles your card. This site never sees the number.
The payment form didn't load, which is on me, not you. Refresh and try again, or email rob@bigmachine.io and I'll sort it out.
You already have Premium. Core is an upgrade to the membership you have, not a second one, so there is nothing to buy here. Stripe works out the difference for the rest of your year.
Upgrade to CoreWorking 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.
