It turns out you can be extremely precise about what makes code complex and how to solve it I spent a decade teaching this to hundreds of engineers ( https://mirdin.com ).

In the hands of an AI: super-effective

In Command Center: click “Refactoring” before reading

Command Center 1.0 is out today. People say the walkthroughs make them >2x faster at reading even a 400-line diff, while the refactorings give the LLMs taste

It has a lot more that’s needed to make you a super-fast AI builder, but that’s what hits the big problems the hardest

That brings up the first pillar of shipping AI code: maintaining quality

SlopCodeBench measures what happens when you ask an AI to make an MVP, then add a feature, then add a feature, without human intervention

Code erosion 5x worse than a human. 100% failure rate by the end

http://Refact.ai is the first company I’ve seen that specializes in refactoring. In our internal benchmarks, they scored second behind us — and more than twice as good as Claude alone

Cursor open sourced their “thermonuclear code quality review” skill.

Some of our users have badmouthed it — think we spoiled them. But they’ve been brave for putting themselves out there and showing they still care about code quality. Kudos to them.

https://github.com/cursor/plugins/blob/3347cbab5b54136f6fba0994c3a01a56f7fb7fca/cursor-team-kit/skills/thermo-nuclear-code-quality-review/SKILL.md

Lathe ( https://github.com/devenjarvis/lathe ) is my new favorite. Sometimes learning code is not about reading the code, but about understanding the domain and algorithms. Lathe gives you such a deeper tutorial about anything you want.

I think we noticed this problem first and have gone much further than anyone else. But I want to give shout-outs to the other builders also working to unlock 100x shipping speed

For a more detailed explanation of learning science in the context of reading codebases — with a surprise tie-in to classic 90’s gaming — see

The trick then is to put them back into logical order.

That’s what Command Center walkthroughs give you

Reading a 1000 line diff now becomes pressing ➡️ 100 times

Extra labels are cues that help you mentally chunk each bit

And explanations on the side, but you’ll usually ignore those

Back to coding.

Here’s me trying to add Giphy integration to a popular messaging app (Signal Desktop).

Here’s the diff when the AI finishes

First thing? Random localization strings.

Then some random CSS

But first, a little memory challenge:

I’m going to give you a set of 3 facts each about 2 people.

Later, I’l ask you to recall each without looking back.

Ready?

That’s why it’s so hard to remember the random facts about this unknown human

But maybe it would make a difference if I told you that Ralph “Jones” is actually my father Ralph Koppel, and the Elijah Watt Sells award is given to the top 100 scorers each year on the CPA exam.

The Geoff facts connect in a logical story, and attach to something you’ve heard of

If I just gave you those facts in reverse order, it would be harder to remember

The Ralph facts? Can’t even visualize them

What makes code reading hard?

Back to the memory challenge

When I’ve done this live, usually several can get the Geoffrey Hinton facts.

For Ralph Jones? Maaybe the whole room can cobble it together

That’s because learning and memory is actually rather predictable.

I designed the Geoff facts to be easy to remember, and the Ralph ones to be hard.

Thinking through a “what if” can be far faster than trying it

Much faster even than typing a question to the AI

But that only goes for when thinking about it is easy, and there are fewer distinct scenarios to think about it

“Quality cannot be tested in. It must be built in”

Geoff pushed that we should teach machines to think associatively. Like humans.

According to multiple cognitive theories, humans organize knowledge into discrete chunks that connect. Activating one thought makes it easier to recall everything connected to it.

You’ve improved quality

It’s more readable; easier for humans and AIs to build on

You still want to understand it. Enough for the power of seeing a problem and knowing what’s up. Or at least to understand an AI’s explanation

Time to read the code. Summaries are no replacement

What we’ve seen: sequencing makes a big difference to ease of understanding

I gave you the Geoff facts in logical order

Would it be harder to remember if I scrambled them?

Well, coding agents show their changes in **alphabetical** order

The thing you should probably read first — the core datatypes — is buried in the middle

Most changes are unmotivated until you read that part

So reading a 1k-line diff tends to consist of scrolling up and down until you spot something that makes sense

>2x harder than a 500 line diff