Frontend Deskilling and Code That Nobody Owns

History vs code-generation

A product manager built a working React component last week. Clean, responsive, decent state handling - capturing all the business requirements neatly. She has never written JS in her life. She described what she wanted, and the model wrote it.

Somewhere a senior frontend engineer felt a small death. The flexbox intuition, the memory of which CSS property quietly breaks which layout, the muscle memory of wiring up state - the stuff that took years - is turning into a commodity you can ask for in plain English.

There’s a word for this, and it’s old: deskilling. The skill that used to live inside a person gets absorbed into a tool, and suddenly the person is easier to replace. It feels like a tragedy when it's happening to you. It usually isn’t.

Before the factory, a skilled weaver held an entire craft in their hands: they understood the loom, the fibers, the patterns, the trade. The power loom didn’t just speed that up, it broke the work into pieces a person could learn in an afternoon. The expertise moved out of the worker and into the machine.

The Luddites smashed those machines, and they weren’t wrong about what was being done to them. They were wrong about how it ends. Their grandchildren didn’t get poorer. The amount of cloth in the world exploded, and clothing went from a multi-generational heirloom to something you buy without thinking.

Deskilling doesn’t delete ability. It relocates it - out of a guild and into something far more people can pick up.

Software has done this to itself the whole time

Here’s the part frontend engineers forget: their entire field is already a monument to deskilling.

Programmers once wrote assembly, tracking registers and memory by hand. When high-level languages showed up, serious people sneered - a compiler could never write code as good as a careful human, and letting amateurs near a machine would produce garbage. The compiler won. It freed millions of people to build things without ever learning what a register is.

The web ran the same loop faster. In the 90s you hand-wrote HTML in a text editor. Then Dreamweaver let people drag boxes around and spat out the markup, and real developers mocked the bloated tag soup - this was how I started my journey as a dev.

Then jQuery papered over the browser quirks you used to need arcane knowledge to survive, and a generation who never learned those gory details shipped fine software anyway.

Every single time, two things happened together. A hard-won skill became unnecessary, and a much bigger group of people got the power to build. And every single time, the people guarding the old skill turned out to be wrong about it mattering as much as they thought.

There’s one counter worth taking seriously, because it’s the strongest one: a compiler is deterministic. You can trust its output. An LLM guesses, and sometimes it guesses wrong in ways that look right. The analogy breaks.

It’s a real difference, and it’s exactly why the skill doesn’t disappear - it moves. Nobody hand-verifies compiler output anymore, but plenty of people got very good at reading, testing, and reviewing the code that comes out the other end. That’s where the frontend skill is heading too. Not writing the JSX. Knowing whether the JSX is any good, and what to do when it isn’t.

Code that nobody owns

The code that PM shipped isn’t really hers, and it isn't really the model’s either. No single person holds the craft anymore. The skill has leaked out of individuals and into the tool, the same way it leaked out of the weaver and into the loom.

Knowing what to build. Sensing when an interface feels wrong before you can say why. Deciding which problem deserves to exist at all. That has always lived one level up from the syntax, and that’s exactly where the work goes after every round of deskilling. The assembly programmers who thrived didn’t mourn the registers. They moved up to architecture.

A thing you bled for is losing its market price, and no productivity chart makes that feel better. But the loss is local. Step back far enough and you’re watching technology do the only trick it’s ever really known: take something locked behind a wall of expertise, and hand it to everyone else.