Code was always supposed to solve a problem.

That’s it. Someone has a problem and you write code to fix it. Somewhere along the way we lost that. The code became the thing. Engineers got deep into the craft of it, the clean architecture, the design patterns, the perfect abstraction. And the actual problem drifted. It became someone else’s job to care about.

The people closest to the solution lost sight of what made a solution good. Not the implementation, but the taste. Knowing what’s worth building and what isn’t.

So we built layers to compensate. Product managers to translate business problems into specs, engineering managers to keep teams aligned, program managers to keep the managers aligned. A whole chain of humans existed because the people writing the code had drifted so far from the problem that you needed bridges to connect them back.

Taste got distributed across a dozen roles, and nobody owned it fully.

The code was never the point. The problem was. And taste was knowing the difference.

That worked for all these years. It was inefficient but it worked. Everyone had a role and everyone had a seat.

All the code we wrote, every design pattern, every architecture doc, every refactor, every Stack Overflow answer, every pull request we agonized over. That’s what trained the AI. We built the dataset. Years of collective engineering effort poured into the machine that’s now replacing the need for most of it. We spent decades perfecting the craft of writing code, and that craft became the training data for a system that makes the craft optional.

Now AI walks in and blows up the middle.

AI is removing the implementation bottleneck, and when you do that, the distance between the problem and the solution shrinks. You don’t need three layers of translation anymore. An engineer who understands the business problem can go straight to a working solution. The gap that justified all those middle layers is closing.

The org chart that made sense when implementation was slow and expensive doesn’t make sense when it’s fast and cheap. That’s what’s behind a lot of the layoffs we’re seeing. Not just cost cutting, but structural.

Who thrives in this? The people who were always a little too self-directed for the old system. The ones who cared about the problem, not just the ticket. Engineers who think like owners, designers who ship working prototypes instead of Figma files, product people who understand what’s buildable.

People with taste. People who can look at what AI hands them and know whether it’s right. Not whether it runs, but whether it’s right.

Specialization was the path for all these years. Stay in your lane, write the code, let someone else worry about whether it’s the right code. That comfort is gone now. You need to think a level above your pay grade, maybe two or three levels above. And as AI keeps improving, that number only goes up.

AI lowered the entry barrier so anyone can build now, but it raised the ceiling massively. The tools are the same for everyone, same models, same access, same starting line. What separates people isn’t what they can build, it’s whether they know what’s worth building.

You are the user. Every product, every feature, every interaction is for a person on the other end, and you are one. You know when something is off before you can explain why. You know when a flow is annoying even if it technically works. AI can generate solutions all day, but it can’t feel what it’s like to sit on the other side of them.

The judgment to know what’s worth making, the instinct to kill a feature that works but doesn’t matter, the refusal to ship something that’s fine but not good. AI doesn’t have any of that.

Taste is all you have. Not effort, not speed. The willingness to look at what the tool hands you and say no, that’s not it. That’s the job now.

I haven’t slept properly in two days.

Not because something is broken. The opposite, actually. Everything works, and that’s the problem.

I’ve been using Claude Code for over three months now. It was fine at first, productive and useful and controlled. But this past week something shifted. It became a loop. Build something, deploy it, see what could be better, refine it, deploy again. Two days of this with barely any real sleep. I’d lie in bed and my brain just wouldn’t stop running through what needed restructuring, what deploy could be cleaner. I’d fall asleep for a couple of hours, wake up mid-thought already planning the next change. I was dreaming about Claude Code, actual dreams, and then waking up from those dreams and reaching for the laptop.

Close the lid. Sleep for a bit. Open the lid. Repeat.

The old bottlenecks used to save you from this. Typing speed, debugging, waiting for a build. Implementation itself was the wall, and hitting it gave you a natural place to stop. Those walls are gone now. The tool is capable enough that the bottleneck is never the tool, it’s always you. Your ideas, your stamina, your willingness to keep going. Most of the time I’m not even typing code, I’m rambling into audio mode, talking through ideas like I’m explaining them to someone. And it just works.

But nothing comes free.

You’d think being more productive would feel good, and it does at first. But then something breaks. Before AI, the hard part was implementation. You’d spend hours just getting something to work, and when it finally did, that was the win. Now implementation takes minutes, so you skip straight past the win and into the details. Refining, tweaking, polishing, and then refining the refinement. The bar moves every time you reach it. There’s no moment where it feels done, because you know you could make it better and now you actually can. The satisfaction that used to come from building something is gone, replaced by an endless loop of “but what about this part.”

That’s the thing nobody talks about. The friction was the finish line. When building was hard, finishing meant something. You hit the wall, you pushed through, and the act of getting it to work at all was enough to call it done. Remove the friction and there’s no signal to stop. You just keep going, refining past the point of usefulness, losing sleep over margins that don’t matter.

The tool doesn’t get tired. You do. And there’s no version of you that can keep up with a machine that never needs to stop. You’ll try, you’ll lose sleep trying, and then you’ll realize the only skill that matters now is knowing when to close the lid and mean it.

Let’s see.