Had a thought this week that landed differently than I expected. Been working with AI tooling constantly (agents, code generation, the whole stack) and I carried this assumption that every developer would level up. Rising tide, all boats, varying degrees. Seemed obvious. Turns out I was wrong, or at least incomplete.

The developers who came up writing code line by line, sequentially, building understanding as a side effect of typing things out? That sequential process was actually a crutch. Not a bad one. It worked. You wrote the implementation, so you understood the implementation. Tight loop between doing and knowing. But AI obliterates that loop. The distance between "what I want" and "what exists in the codebase" is now enormous. You can conjure a thousand lines in minutes. The question is whether you know what those lines should be.

And that's where design thinking stops being a nice-to-have and becomes the entire game. Not just system architecture whiteboard stuff. Low-level design too. How your components decompose. Where your boundaries sit. How state flows through the system. How your database connections pool. Schema decisions. Separation of concerns at every layer. The people who always thought in systems, who held a mental model of the whole thing before writing a single function. Those people are about to have a decade. Because when you're directing an agent, the agent is the hands. You need to be the brain. And the brain's job is design.

Here's what surprised me about this realization: it's not just senior engineers who win. It's anyone who thinks structurally. Junior devs with taste. Engineering managers who always had strong opinions about how systems should fit together but stopped building because the org chart said so. They just got handed the keys back. The agent doesn't care about your title. It cares about the clarity of your intent. If you can describe the shape of a system, really describe it at multiple levels of abstraction, you can build it now. That's a profound unlock for people who were sidelined by the mechanics of implementation.

The flip side is uncomfortable. People who shipped code by following patterns without understanding why those patterns exist, who relied on the sequential grind to paper over gaps in their mental model. AI doesn't fill those gaps. It widens them. You prompt an agent without a clear design in your head and it'll happily build something. It'll look complete. It'll even work, for a while. But the moment you need to extend it, debug it, reason about it under pressure, there's nothing there. No skeleton. No opinion. Just a pile of generated code shaped by whatever the model defaulted to. And taming that after the fact is brutally hard. Harder than building it right would've been.

So I'm weirdly more optimistic about the people nobody's talking about. The architect who hasn't committed code in three years. The manager who still sketches systems on napkins. The junior who asks "but why is it structured this way?" in every code review. Those instincts are suddenly the most valuable thing in the room. Design was always important. AI just made it non-optional.