A few days ago I shipped a change that was 3,800 lines long. I couldn't have reviewed all of it if you'd paid me. No human could. I read what I could, ran the tests, watched it behave, and shipped it with a low, familiar hum of dread. If this breaks in production, it's mine. Code I didn't write, couldn't fully vouch for—mine anyway.
Writing that code was the easy part. Easier than it's ever been. I told the machine what I wanted, and the machine produced it in just a couple of hours. The hard part—the part that used to be the whole job—was reading it, understanding it, and being able to put my name on it and mean it.
AI made the writing nearly free and left the understanding out of the picture. That's the trade nobody put in the pitch deck, and it's quietly burning out some of the best engineers I know.
If that dread is familiar, hear this first. You're not being precious. You're not too slow, too proud, or too old. Something real is being done to you, and it's worth naming before we talk about what to do with it.
Survey
I'm not the only one watching this happen. Lenny Rachitsky and Noam Segal just surveyed close to 6,000 tech workers about how they're feeling in 2026, and the headline was a workforce splitting in two—half amplified by AI, half shaken by it. Burnout is now the majority experience, up eleven points in one year.
The part that jumped at me was what best predicted how someone felt about their career. Not their role, not their seniority, not the size of their company. It was what AI had done to their sense of who they are. One person put the whole problem in seven words: "I don't fully understand what I merge." I've felt that sentence.
It lands hardest on a specific kind of engineer. The ones who built their whole sense of themselves on understanding the code. Not just writing it—understanding it. Clean, sharp, easy for the next person to maintain. That was the craft!
Now that person is handed a tool that produces more code than they can read, often worse than they'd have written by hand, and told to move faster. They can't vouch for what they're shipping. And they know, in their gut, who takes the fall when it breaks. Not the tool. Not the exec who mandated the tool. Them!
Reverse Centaur
Cory Doctorow has a name for this shape—the reverse centaur. A centaur is a person a machine helps—you're in charge, the tool extends you. A reverse centaur is the flip: you've been harnessed to the machine, serving it at its pace, cleaning up after it. The machine isn't your horse. You're its.
There's a companion idea from the researcher Madeleine Clare Elish: the moral crumple zone. In a crash, a car's crumple zone absorbs the impact to protect the person. In an automated system, the nearest human absorbs the blame to protect the system. The company keeps the speed and the savings. When something goes wrong, there's a face to point at, and it's yours—even though you barely had the controls.
The same survey demonstrated it clearly. When Rachitsky and Segal asked what people actually fear from AI, "losing my job" landed near the bottom, at 22 percent—well behind the fear that topped the list: being expected to do more for the same pay, and to absorb it quietly as the quality of the work slips. The dread isn't a machine taking your place. It's a machine used to squeeze you. More output, same paycheck, and your name on whatever breaks.
So let's say the honest thing out loud. A large part of this burnout is not a mindset problem. It's a structural problem. And the structure was built by the industry, not by you.
Burnout
Burnout was never mostly about workload anyway. Christina Maslach has spent decades showing it runs on six things, not one:
-
workload,
-
control,
-
reward,
-
fairness,
-
community,
-
and whether the work fits your values.
Look at that list in the age of AI. Workload is the one thing that supposedly got lighter. Every other one took the hit.
Control, gone—the tools and the rules shift under you weekly. Reward, murky—the thing you were paid to be good at is now free. Fairness, questionnable—you're accountable for work you didn't write. Values, sold out—you came here to make good things, and now you ship things you only hope are good.
That's not you failing to keep up. That's a job that quietly rewrote its own terms without consulting with you.
Here's where I have to be careful, because this is the part that actually matters.
You can be completely right about all of that and still be stuck. Because you don't control the industry—you control almost none of it. You can push for real review time, for honest ownership, for leaders who don't use their best engineers as crumple zones. Fight that fight. But you won't win it this quarter, and your nervous system can't wait for the industry to grow a conscience.
What you do control is smaller and far more powerful—what you tie your worth to.
Fix
We've been here before. Not with this intensity, but with the same shape.
We used to write machine instructions by hand. Then we moved up to languages that read a little more like the human ones, and handed the instructions to a compiler. And the compiler didn't just translate—it reordered, optimized, and deleted, producing machine code most of us could never follow line by line. We gave up reading the machine instructions. We did not give up the craft. We moved it. We stopped proving our worth by understanding every instruction and started proving it by knowing what to ask for and how to check that we got it. We learned to trust the compiler and verify its work by other means. Tests. Static avalysis. Observability. Results.
AI is the next rung on that same ladder. And the engineers who are thriving right now aren't the ones who somehow read all 3,800 lines. They're the ones who moved what "understanding" means—from "I can read every line" to "I can specify it, test it, and stand behind how it behaves." Same instinct that let us trust compilers. Trust, then verify. Just higher up.
This is the whole difference between the two engineers I keep seeing.
Same trap. Same reverse-centaur bargain, same unreadable diffs, same company holding them responsible. One of them has their identity welded to understanding the code, and every diff they can't read is a small death—proof they're slipping, being replaced, turning into a fraud. The other moved their identity up a level, to judgment. What to build. What good looks like. How to prove it works. For them the same unreadable diff is just raw material to direct and check. The trap didn't change. Where they parked their worth did.
None of this lets the industry off the hook. Using people as crumple zones is a bad deal and a worse strategy, and it's worth naming loudly every time you see it. Do both. Push on the system where you have any leverage. And stop staking your identity on the one thing you no longer control.
If any of this is resonating, here's something to try. It costs nothing and takes ten minutes.
Write down why you came into this work in the first place—before the title, before the paycheck, back when it was just interesting. Then write down what "good work" would mean if you never read another line of code. What would you specify. What would you test. What would you refuse to ship. That second list is the new home of your craft—try it on and feel it out.
I still feel a pinch of unease when I ship code I can't fully read. I think that's just the job now. But unease and burnout aren't the same thing. One is the honest weight of the new and unfamiliar way to work. The other is what happens when you measure your worth by a skill the AI took, in a game the industry rigged, forgetting the part that was always yours.
Find that part. Then the 3,800 lines you didn't write go back to being what they always were—raw material. You're still the one who decides if it's any good.