I collected frameworks like they were proof of something. Flutter, then React, then Spring Boot and Rails made me fullstack, then Python for ETL. Every new thing felt like another brick in the wall. More range, more proof I could figure things out.

Then the wall stopped meaning anything. The application layer I spent years climbing just went flat. So I started going deeper. Into the platform. The stuff underneath the frameworks. How the database engine actually schedules queries. How systems behave when the docs are useless. That felt right. Fewer people down there because fewer people bothered when the application layer was paying well. The knowledge takes years to build. You learn it by getting burned, not by reading tutorials.

And it is the right move. For now.

Platform depth buys you time. It doesn’t buy you safety. AI can already debug better than me in a lot of cases. It can reason about systems, evaluate tradeoffs across tech stacks, make architecture calls I’d need an hour to think through. It’s getting better at this every month. Going deeper just means it takes longer before the ground under you flattens out too.

But here’s what I keep coming back to. AI still can’t sit with a finance team and figure out how to provision infrastructure for a company that’s burning cash and needs to ship in six weeks. It can’t make the call to go managed instead of self-hosted because it talked to the ops team and knows they’re already stretched thin. Those decisions come from context that lives in hallway conversations and Slack threads and years of watching things go wrong in ways that never make it into a postmortem. You have to be in the room for that. You have to have been in the room before.

That’s where I’m trying to go. Not just deeper, but wider. Owning the whole infrastructure. Networking, storage, compute, CI, observability, security. Not expert level in all of them. But enough to make real decisions when the constraints are messy and human. You can’t say “I don’t do databases” anymore. If it touches the system you’re responsible for, it’s yours now.

I’m not comfortable with this yet. I liked having a lane. But the lane is gone and I’d rather adapt than pretend it’s coming back.

The person who was in the room when it broke is the person who gets asked what to do next.

Be the person they call when the constraints are real and the model can’t help. That’s the job now. It always was. We just had the luxury of pretending otherwise.

The old model was simple. Get exposed to something, take time to understand it, learn the fundamentals, then build.

That still works for a lot of things, but not when AI is writing most of the code. The whole story flipped. You don’t need to understand something fully before you build with it anymore. Just build it, see how it compares against the existing system, see what goes wrong. The failures show you how each piece actually works. You get a map of the system through its fractures.

Build first. Learn from what breaks.

And not just the code. When something breaks you don’t just learn why that function failed. You learn what the product was supposed to do, what the user expected, where the assumption was wrong. Every failure is a window into the system and the thing the system serves.

But building first only gives you the surface. You see the shape of it, not the depth, and you can’t stop there. You take what you skimmed and drill in, layer by layer, with AI running in parallel. One niche at a time. Pick a specific corner and go to the root. AI lets you do that now without waiting for a teacher or a course or a mentor. You just go.

Remove the friction, build as fast as you can, then learn, then build again. Compress that cycle and keep repeating it until you’re comfortable within one specific niche, then pick the next one. Each rotation teaches you the code less and the product more.

This matters because when AI writes the code, you own it. Every decision it made, every tradeoff it picked, every shortcut it took. If you just wave things through without understanding why, eventually something will break and you’ll be staring at a system you can’t reason about. That’s not a hypothetical. That’s Tuesday.

The moment you stop understanding, you stop owning it. Not just the code, but the product, the business logic, the thing users actually touch.

We will lose context of our own codebases. AI will have written most of it, and the repositories will outgrow what any one person can hold in their head.

There’s nothing we can do about that.

The code is temporary. What you understand about the product is not.

The code context fades. The product understanding compounds. What it does, what it doesn’t, where it falls apart, what users actually need. That stays with you. That’s the thing AI can’t take.

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.