For most of my career, a certain kind of ticket made my stomach drop. Not the hard ones. The old ones. The service nobody wrote down anything about, where the last person who understood it left two reorgs ago, and the README was a single line that said “ask Dmitri.” Dmitri was also gone.
I was afraid of legacy. I avoided complex legacy systems because I didn’t understand them, they were fragile, and there was no map. Open the hood and you might find the thing held together by a config value nobody remembers setting in 2017.
So we did what everyone does. “If it works, don’t touch it.” Except “works” usually meant works 80% of the time. The other 20% we papered over with a retry, a manual restart, a Slack message that said “it’s flaky, just run it again.” We built whole rituals around not looking too closely.
That fear was rational. Understanding a 60,000-line codebase you didn’t write used to cost days of archaeology: grepping, drawing boxes on a whiteboard, tracing one request through fourteen files to find where it died. The cost of understanding was so high that avoidance was the economically correct choice. We weren’t lazy. We were doing the math.
The math changed.
The map draws itself now
Modern LLMs like Opus (or the mighty god-like Fable) read a large, unfamiliar codebase quickly and, more importantly, reliably. I can drop into a repo I’ve never seen (and not even /init-ed it) and have a working mental model in minutes, not days: where the entry points are, how the modules talk, where the landmines are buried. The archaeology that used to eat a sprint now happens before my coffee gets cold.
The real superpower shows up when you correlate two things that used to live in separate worlds: production signal and source code. Logs and metrics on one screen, the code that emits them on the other and an AI agent with a bit of “prompts-skills-memory-MCPs” glue holding both at once. “This error spikes every Tuesday at 0200” stops being a mystery and becomes a five-minute trace back to the exact line that breaks. I’d have killed for that ten years ago.
And the economics of fixing flipped. A legacy fix used to be a roadmap detour: scope it, fear it, pad the estimate by 3x because who knows what you’ll find. Now the discovery cost is close to zero, so the fix stops being a detour and becomes a quick side-quest you knock out between real features. It just costs you some Claude/Cursor quota usage.
The Slack bot nobody would touch
Here’s the one that converted me.
We had a Slack bot that had never connected reliably. It used the Bolt API, and every so often the socket would just refuse to come up. Restart it, cross your fingers, sometimes it worked. It had been flaky so long that “the bot is being the bot again” was a known phrase. Nobody wanted to own it: not anybody’s job, scary, and it touched production Slack, so the blast radius felt high.
Classic 80%-works, don’t-touch territory. We had lived with it for over a year.
I pointed Claude at it on a slow afternoon, mostly out of curiosity. The diagnosis took minutes: an outdated dependency. The Bolt version we were pinned to had a known issue with the connection handshake that had been fixed upstream. That was it. That was the whole monster. A version bump and a few lines of reconnect handling, and the bot that had haunted us for a year just… worked. Reliably. The fix was almost insulting in how small it was.
The lesson wasn’t “the bug was easy.” It was that the fear had been the expensive part, not the fix. For a year we paid a tax in manual restarts and low-grade dread to avoid a problem that took an afternoon, because before, finding it would have cost more than living with it.
What actually changed
The technology to fix that bot existed the whole time. The dependency was public, the fix was upstream, the changelog was right there. What changed is that the cost of understanding the unfamiliar collapsed, and when understanding gets cheap, courage gets cheap with it.
“If it works, don’t touch it” was always a statement about cost, not about quality. We told ourselves it was wisdom. It was mostly fear wearing a nice coat.
So go open the scary repo. The one with no docs and the maintainer who quit. It’s not haunted. It was never haunted. You just couldn’t see in the dark, and now you can.
Happy debugging.