Changes that span files

Up until now, every edit in this level has been small and local — one file, one block, one line. That’s the right way to start. But it’s not the unlock.

The change humans dread — touch many files, keep them consistent, don’t miss any — is the change Claude is best at.

Once you internalize this, you’ll use Claude differently. You’ll stop doing the boring 14-file refactors yourself. You’ll stop avoiding them because they’re tedious. You’ll just hand them over.

What “cross-file change” actually means

A few examples, from small to large:

Rename a function that’s used in 14 places. Every call site, every import, every reference in tests needs renaming. Miss one and the build breaks.
Thread a new parameter through a function and every call site. formatPrice(amount) becomes formatPrice(amount, currency), and every caller needs the new argument.
Update an import path for a file that just moved. Twenty files might be importing from the old location.
Replace a deprecated API call with the new one — same intent, slightly different syntax — everywhere it’s used.

These are the changes that take a human an hour of grep-and-edit and yield exactly one mistake.

Why humans hate this

It’s mechanical. Almost no judgment per file. Just attention.
Attention fades. By file 9 you’re skimming. By file 12 you’re missing things.
Miss one and the consequence is silent — code compiles, tests pass, bug ships.
There’s no satisfaction in finishing. You haven’t built anything new — you’ve just kept things consistent.

So humans put these off. Or do them badly. Or half-do them and live with the inconsistency.

Why Claude is good at it

No attention fatigue. The 12th file gets the same treatment as the 1st.
It can search before it edits — find every reference first, then change each one.
It keeps a running mental list of what it touched, so you can verify.
It doesn’t shortcut. It doesn’t decide “this one’s probably fine.”

What it looks like in practice

You ask:

Rename the getUserData function to fetchUser everywhere — the function definition, all the call sites, all the imports. Don’t change anything about what it does.

Claude does the search, finds every match, proposes a diff that touches each file. You read the diff (Lesson 5.2 — yes, even when it’s long), accept, and you’re done. What would have been 30 minutes of error-prone grep-and-replace is two minutes of review.

The new habit

When you notice yourself dreading a task because it’s “tedious” or “annoying” or “easy but a lot of files” — that’s the signal. That dread is Claude’s job description.

Spend your own attention on the things that need judgment: design choices, weird bugs, the right shape of a feature. Spend Claude’s attention on the things that just need consistency.

What’s next

Big cross-file changes are powerful — and powerful means consequential. The next lesson is the safety net: how to back out cleanly when a change is wrong.