From Doer to Owner: Burnout, AI, and the Engineer’s Next Move

Every few months the same post climbs Hacker News: “I am retiring from tech to live offline.” The latest came from a former Head of Open Source at Sentry, and the reasons always rhyme — burnout, the slow fade of joy in coding, and, more and more, AI as the “last straw.”

Here’s the thing: I think this is the most interesting era tech has ever had. So why are so many of the sharpest people in the field quietly heading for the door? This is me trying to understand that — and to be honest about why I feel the opposite pull myself. If you feel the same pressure, maybe some of this helps.

Isn’t this just a revolution?

The honest framing is that this is an industrial revolution: automate the grueling, repetitive labor so humans can move up the value chain. From a macroeconomic view, the people walking away are right — it frees capital and time to be spent elsewhere. A generation entering the field now will treat AI like just another layer of the stack, the same way we stopped thinking about assembly or racking physical servers.

So why are people quitting at the exact moment the leverage arrives?

Because the grueling labor was the fun part

That’s the mismatch. In a textile mill, the work being automated was punishing. In software, “sitting down and writing and debugging code” wasn’t the chore people were waiting to be rescued from — it was the hobby they fell in love with. The joy is the flow state: the deep, quiet zone where you solve a logical puzzle piece by piece.

When AI automates the writing and the debugging, it takes away the puzzle. Being told to “move up the value chain” to managing agents and reviewing architecture can feel like being promoted from master carpenter to construction manager. You might be more productive, but you no longer get to touch the wood.

Two more things compound it:

The free time never shows up. The theory is that automation frees you to think deeply. In practice, if AI helps you code 10× faster, the business rarely says “great, take 90% of the day to think.” It says “great, we expect 10× more shipped by Friday.” The cognitive load shifts from writing code to managing a flood of it.
Creation becomes supervision. Writing your own code is mastery. Reading a wall of plausible-but-maybe-wrong generated code to catch a subtle hallucination feels like grading the same C+ essay over and over.

This is the part I take seriously. The burnout isn’t people being lazy or afraid of change. It’s a real grief for losing the part of the job they loved.

The 10× trap

Here’s the catch management misses: just because a model emits a block of code in three seconds does not mean a developer can ship a secure, production-ready feature 10× faster. The expectation scales up instantly. The reality — getting an AI to produce correct, reliable architecture — is a completely different skill.

And it’s a real skill. Context engineering is now a discipline of its own — and knowing how much AI to use is itself a skill. To actually get a 2×, 5×, or 10× boost you need deep domain expertise (you can’t catch a hallucination unless you already know how the code should look) and systems thinking (the AI handles syntax; you own how the pieces fit together securely). The paradox is that the people best at leveraging AI are exactly the ones who spent years mastering the old way — which leaves the average developer caught in a vice between hyper-inflated benchmarks and an unforgiving reality.

The reframe: stop being a Doer, become a Director

If I want a long career in this landscape rather than an exit, the mind shift has to be radical. It means letting go of the identity of the Doer and embracing the identity of the Director — the same move from implementer to decision-maker I wrote about in Where Did the Learning Go?.

From writing code to owning outcomes. Code is now a cheap, abundant commodity. Your value is translating messy human requirements into robust, secure architecture — and making sure the AI builds the right thing. Coding was the destination; now it’s the manufacturing plant, and you’re the plant manager.
From building from scratch to guardrail engineering. Set the boundaries before the AI touches the keyboard: strong type systems, strict schemas, comprehensive tests, robust CI/CD. Make incorrect code either unrepresentable or instantly caught, so the system does the heavy lifting of auditing — not your tired eyes.
From velocity to critical skepticism. Approach generated code like a zero-trust auditor. The most dangerous code is the kind that looks flawless and hides a subtle vulnerability. Your value is knowing exactly where models are brittle and saying “no, this won’t scale in six months.”
From the middle tier to systems thinking and domain depth. As AI eats boilerplate, CRUD, and standard forms, the middle shrinks. Stay irreplaceable by zooming out (how do these services interact? where does state live?) or zooming deep (the specific business logic and niche legacy frameworks LLMs lack training data for).
From wrestling the machine to mastering the agentic flywheel. Don’t treat AI as an adversary ruining your job. Treat it like a team of eager, absurdly fast interns. Get excellent at delegating, defining context, and orchestrating agents.

From Director to Owner

Here’s where I break with my own framing. “Director” makes it sound like you stop building and start supervising — and that’s not how it actually feels to me. If anything, it’s the opposite.

AI didn’t take the craft away from me; it let me do more of it. I can take a feature end-to-end now, not just the slice I was already good at. I can design the detailed user experience I used to wave off for lack of time. I can drop into an unfamiliar codebase and actually understand how the systems interconnect, because exploring it with an agent is fast and, honestly, fun. Work that used to live permanently behind “no time for that” is suddenly on the table.

That doesn’t shrink my role — it widens it. My scope grows, my ownership grows, and the part the burnout posts miss is that it’s energizing. Understanding the whole, shaping the small details, and owning the outcome from front to back isn’t a consolation prize for losing the craft — it’s the most engaged I’ve felt building software.

So maybe the move isn’t Doer → Director. It’s Doer → Owner: not someone who stopped touching the wood, but someone who can finally build the whole thing.

The Jevons paradox of tech

In economics, the Jevons paradox says that when progress makes a resource cheaper to use, demand for it goes up, not down. Because AI makes writing code incredibly cheap, the world is going to want exponentially more software — more experiments, more automated systems. The engineers who thrive will be the clear thinkers who realize that thinking, not typing, is the ultimate bottleneck. Increasingly, shipping is cheap and direction is expensive.

How I’m preparing

This is the practical part — what I’m actually trying to do so I lean into this era instead of dreading it:

Reframe code as cheap. I’m training myself to get the same satisfaction from a clean architecture decision that I used to get from an elegant function. The craft moves up a level; I want my pride to move with it.
Automate what’s easy to check; steer the rest. I hand agents the simple, repetitive work that’s easy to validate, and pour the time it frees up back into steering — putting my own knowledge and taste on top of what the agent already does well. An agent can’t watch what it’s generating and what makes people love the product at the same time; holding that second thing is my job. But it’s not solo work — the agent reads my intent well and often sharpens it, even in the details.
Make guardrails a reflex. Types, schemas, tests, and CI aren’t chores — they’re what makes reviewing AI output bearable instead of soul-crushing. I’d rather a test catch the hallucination than my tired eyes at 11pm.
Get genuinely good at delegating to agents. Instead of resenting context engineering, I’m treating it as a craft worth mastering on its own.
Protect the joy on purpose. I keep at least one project where I still write every line by hand, for no reason other than the flow state. The day job can be all steering and orchestration; the soul still needs to touch the wood sometimes.
Watch my own metrics of meaning, not just velocity. Shipping 10× more isn’t a win if I hate every minute. Noticing that early is how you avoid the “last straw.”

For the veterans who loved touching the wood, this may genuinely be the end of an era worth mourning, and I don’t want to wave that away. But if you can find joy in the strategy, the problem-solving, and the architecture, this era offers a level of human leverage we’ve never had before. The trick — the thing I’m trying to get right — is deciding which game you’re actually here to play, and then preparing for it on purpose.