The Vertigo of Competence
I spend a lot of my time now using Claude Code with Opus 4.6 to build sales engineering demos. Not the canned kind you run through fifty times. Bespoke ones. The prospect mentions they're in healthcare, they have a specific compliance concern about data residency, they want to see how incremental static regeneration would work for their content model. You build them something that addresses exactly that.
I am faster at this than I have ever been at anything in my career. Before Vercel I was what you'd call a composable full-stack developer, which is a term that shouldn't mean anything but somehow does. I built sites with Next.js and headless CMSs and deployment pipelines that I'd carefully tuned until they hummed. I was good at it. Good enough that I was one of the first people, possibly the only person for a brief window, to ship a Partial Pre-Rendering app to production. Not a demo. Not a toy. A real thing that real users hit with real requests.
That mattered to me. The specificity of it. The way you could say "I did this difficult thing that almost nobody had done yet" and have it be simply true. Now I watch Claude Code scaffold out a demo that would have taken me three hours, and it happens in the time it takes to describe what I want. Part of why it's faster is obvious: it types quickly, it doesn't forget import statements, it doesn't get distracted. But part of it is weirder and harder to admit.
Opus can draw a straighter line to a solution than I can because it doesn't wrestle with a vaguely defined but strongly held sense of what the code is and how it should be written. I have opinions about component structure. I have feelings about when to abstract and when to inline. I have a whole edifice of taste built up over years of reading other people's code and having my own code reviewed and internalizing various context-dependent rules about what good looks like.
Sometimes that edifice is weight. Sometimes the straight line is just better. This is not a complaint. This is not me saying the tools are bad or that I want to go back. This is me trying to describe a specific feeling that I think a lot of people who are good at computers are having right now and don't quite have language for.
It's the vertigo of competence. Of skills that still matter but matter differently. Of being very good at something right at the moment when "very good" starts to mean something new.
There was a time when being good at making websites meant you understood the stack all the way down because the stack was shallow enough to hold in your head. You could open FileZilla, connect to a server, upload your modified theme files, see the changes. The distance between wanting something to be different and making it different was short. The tools were simple enough that you could understand them completely.
Then "view source" stopped being useful. Not all at once, but gradually. First it was minified jQuery, then it was build tools, then it was webpack configs generating bundles that bore no resemblance to what you'd written. You could still understand it all, but now you had to understand the layers of transformation. The map and the territory kept diverging.
By the time I was building composable full-stack sites, "good at computers" meant something different than it had meant five years earlier. It meant knowing how Next.js thought about routing, how to configure a headless CMS, how to think about the edge and serverless functions and static generation. It meant having opinions about monorepos. It meant understanding not just how to write code but how to orchestrate systems.
Shipping that Partial Pre-Rendering app to production meant understanding something most people didn't understand yet because most people couldn't understand it yet because it was too new. There's a specific pride in that. Not the pride of knowing something others don't, exactly, but the pride of having put in the work to understand something hard at the moment when it was still hard. The thing is, all of that accumulated understanding, that edifice of taste and context and hard-won knowledge about where the weird bugs live, it doesn't go away. It's still there. But what you do with it changes when the tool you're using has also read all of Stack Overflow and every Next.js GitHub issue and the entire React documentation and can generate working code faster than you can explain what you want.
You still need to know things. You need to know them maybe more than before, because now you're evaluating whether what came back is right, is appropriate, fits the context. But the nature of knowing has shifted. It's less about the craft of writing and more about the craft of recognition. Less about building and more about steering.
I don't know yet if that's a loss or just a change.