Steve Jobs removed Linking. Someone yelled, 'Take out debugging!' Everyone laughed. They weren't wrong.

There's a moment from WWDC 2003 that's been sitting in the back of my mind lately. Steve Jobs was on stage demoing Xcode, and he stopped to talk about something he called the Turnaround Loop. The idea was simple: developers spend most of their time cycling through a handful of steps. Stop. Debug. Compile. Link. Run. Repeat. That loop is your life as a programmer.

Jobs explained that Apple had taken a hard look at that loop and asked where they could cut time. Their answer was ZeroLink, a new distributed build system that eliminated the linking step during development - no more waiting for the linker. You hit run, and you're running. The crowd was impressed.

Then, from somewhere in the audience, someone shouted: "Take out debugging!"

Everyone laughed. Jobs smiled. It was a good heckle. The idea was obviously absurd. Debugging isn't overhead you can engineer away. It's how you understand what your code is actually doing. You write code; it doesn't work the way you expected. You figure out why. That's the job. That's been the job since the first program anyone ever wrote.

That was 2003. If you want to watch it yourself, the clip is here. The heckle happens right after Jobs finishes explaining ZeroLink. Everybody laughs and moves on.

Twenty-three years later

I keep thinking about that heckler because, in 2026, debugging has actually been removed from the loop, not for every task, not in every context. But for a massive class of everyday development work, the cognitive step of "figure out what went wrong" has genuinely been compressed almost to nothing.

It happened because of AI coding agents. Claude Code, Cursor, Copilot, Aider, take your pick. The workflow with these tools is fundamentally different from the one Jobs described. You don't write code and then debug it. You describe what you want, the agent writes the code, you run it, and if something's off, you describe what's off, and the agent rewrites it. Then you run it again.

The new loop is something like: Describe. Generate. Run. Describe again.

Notice what's missing. You're not reading stack traces. You're not setting breakpoints. You're not reasoning through state and figuring out where your assumptions broke down. You're just telling the AI what happened and watching it fix things. The cognitive load of "understand the bug" has been offloaded. What used to take twenty minutes of careful reading and hypothesis testing now takes thirty seconds of typing a description.

That's not a small change. That's a restructuring of how the development loop actually works.

The heckler called the shot

I don't think the person who yelled that in 2003 had any idea they were making a prediction. They were making a joke. The joke landed because everyone in that room knew debugging was untouchable. It's foundational. Of all the things you might streamline in a development workflow, that's the one you can't remove. Jobs had just done something clever by cutting out linking. The obvious joke was that debugging would be next.

And they were right that it was absurd, for any technology that existed then. But the premise of the joke, that debugging could never be removed, turned out to be contingent on something they couldn't see from 2003: the assumption that humans would always be the ones reading the errors.

When the AI is generating the code, and you're describing the problem to the AI, you're not really debugging in the classical sense. You're taking on more of a quality-assurance role with a very fast contractor. The feedback loop is still there. You still need to know when something is wrong. You still need to be able to tell the AI what the symptom is. But the part where you sit and reason through the root cause yourself is now optional for many tasks.

What this doesn't mean

None of this means you don't need to understand code. If anything, the developers who are most effective with AI agents are the ones who understand what's going on well enough to give good descriptions, catch subtle errors, and recognize when the AI has gone sideways in a way that will cause problems three steps from now. That judgment comes from understanding, not from skipping it.

It also doesn't mean debugging is gone from serious, complex, production-grade work. When you're tracking down a race condition or a memory issue or something weird happening under load, you still need real debugging skills. AI doesn't fix what you can't describe, and some bugs are hard to describe until you've diagnosed them.

But for the kind of work that makes up a huge portion of most developers' days -the small scripts, feature additions, integrations, and refactors - the loop has changed. The step everyone laughed at removing got removed.

Jobs' original Turnaround Loop was about time. How long does each iteration take? How fast can you go from idea to running code? ZeroLink made that loop faster by a few seconds per build. AI agents made it faster by collapsing a step that once required real cognitive effort.

In 2003, the idea of removing debugging was absurd because debugging was where developers spent much of their time. In 2026, it's not gone, but it is no longer the bottleneck it once was.

The joke became a roadmap.