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.” A notable one came from a former Head of Open Source at Sentry, and the themes rhyme across every essay: burnout, the fading joy of coding, and AI cited as the final straw.

Yet I find myself feeling the opposite: this feels like the most fascinating era software engineering has ever entered. Why are so many experienced practitioners heading for the exit just as leverage peaks? This post is an attempt to unpack that contradiction, understand the genuine grief behind the burnout, and explain why expanding ownership has kept me energized.

An industrial revolution in software

The honest framing is that we are witnessing an industrial revolution for digital labor. The goal of automation is to eliminate grueling, repetitive tasks so humans can move up the stack. From a macroeconomic perspective, engineers walking away are rational: capital and time get freed for other pursuits. A new generation entering tech will treat AI as standard infrastructure, just as earlier generations stopped worrying about assembly language or racking physical servers in data centers.

Why, then, are seasoned engineers quitting at the exact moment this leverage arrives?

The grueling labor was the craft

That is the emotional mismatch. In a textile mill, the manual labor being automated was punishing physical toll. In software, sitting down to write and debug code was never the chore people wanted to escape: it was the hobby they fell in love with. The joy came from the flow state, solving a complex logical puzzle piece by piece in quiet concentration.

When an AI model generates the code and resolves the bugs, it also takes away the puzzle. Being instructed to “move up the value chain” to manage agents and review architectures feels like promoting a master woodworker to construction site manager. You might oversee more square footage, but you no longer touch the wood.

Two workplace dynamics make this worse:

The promised free time rarely materializes. In theory, automation buys time for deep contemplation. In practice, when an engineer codes five times faster, leadership rarely says: “Spend 80% of your day thinking.” They ask for five times more features shipped by Friday. The mental load shifts from solving problems to triaging an endless torrent of generated code.
Creation turns into grading. Writing original code is an act of mastery. Reviewing hundreds of lines of plausible-looking AI code to catch subtle hallucinations feels like grading C-plus student essays all afternoon.

This burnout is not laziness or irrational resistance to progress. It is genuine grief for the loss of a craft people spent decades refining.

The leverage trap

Management frequently falls into an arithmetic trap: just because an LLM produces a code block in three seconds does not mean an engineer can deliver a secure, production-ready system ten times faster. Expectations scale instantly, but getting an agent to produce sound, resilient architecture is a completely different discipline.

Context engineering is now its own craft, and knowing how much AI to use is itself a skill. To extract true leverage, you still need deep domain expertise (you cannot detect a hallucination unless you already know what good code looks like) and systems thinking (the model handles syntax while you ensure components integrate safely). The paradox is that the people best equipped to direct AI are the veterans who spent years mastering the fundamentals. When those fundamentals are dismissed as obsolete, engineers feel trapped between inflated benchmarks and unforgiving production realities.

The reframe: from Doer to Director

Navigating a long career through this transition requires an identity shift. It means letting go of being solely a Doer and stepping into the role of a Director, echoing the shift from implementer to decision-maker explored in Where Did the Learning Go?:

From writing code to owning outcomes. Code has become an abundant commodity. Your true value lies in translating ambiguous human needs into reliable architectures, ensuring the system solves the right problem. Coding was once the destination; today it is the manufacturing line, and you run the plant.
From building from scratch to engineering guardrails. Establish boundaries before the agent writes a line: strict schemas, expressive type systems, comprehensive test suites, and tight CI/CD pipelines. Make invalid states unrepresentable so automated tests do the heavy auditing rather than your tired eyes.
From velocity to critical skepticism. Treat generated code with a zero-trust mindset. The most dangerous code looks clean while masking concurrency or scalability bugs. Your value is recognizing brittle assumptions early and knowing what will fail six months down the road.
From the middle tier to systems thinking and domain depth. As AI commoditizes standard CRUD and boilerplate forms, the undifferentiated middle shrinks. Irreplaceability comes from zooming out to distributed system interactions, or zooming deep into complex business rules and legacy systems where public models lack context.
From resisting tools to orchestrating flywheels. Rather than treating agents as adversaries devaluing your skill, view them as an eager team of junior assistants. Cultivate excellence in structuring context, setting constraints, and delegating cleanly.

Beyond directing: becoming an Owner

Here is where my own perspective diverges from conventional advice. “Director” can sound detached, as if you stop building and merely supervise others. That does not match my daily experience.

AI has not taken the craft away from me; it has unlocked more of it. I can now take an entire product end-to-end, rather than staying confined to the narrow technical layer I used to specialize in. I can design thoughtful user interfaces that I previously skipped due to time constraints. I can explore unfamiliar codebases rapidly, asking questions and testing hypotheses with an agent alongside me. Work that was once permanently shelved under “no time for that” is suddenly achievable.

This does not diminish the developer’s role; it broadens it. Ownership expands, scope widens, and taking responsibility for the complete arc from concept to production is genuinely energizing. Understanding the whole picture and shaping the fine details is not a consolation prize: it is the most engaging way I have ever built software.

The true evolution moves from Doer to Owner: not an engineer who abandoned the craft, but one who can finally build the entire system end-to-end.

The Jevons paradox of software

In economics, Jevons’ paradox observes that when efficiency gains make a resource cheaper, consumption of that resource increases rather than decreases. Because AI makes code generation cheap, the world will demand exponentially more software: more bespoke tools, more operational automation, and more rapid experimentation.

The engineers who thrive will be those who recognize that clear thinking, not typing speed, is the ultimate bottleneck. As software creation costs plummet, shipping is cheap and direction is expensive.

Practical adjustments for the new era

Here are the specific habits I practice to stay energized:

Treat code as cheap without lowering standards. I train myself to draw the same pride from a clean architectural boundary that I once took from an elegant function. The craft has moved up a level, and my sense of craftsmanship moves with it.
Automate what is easy to verify; steer the rest. I delegate mechanical, easily testable tasks to agents, reclaiming focus for architectural direction and user experience taste. An agent cannot judge what makes a product delightful to use; maintaining that quality bar is the human’s job.
Turn guardrails into second nature. Types, schemas, and test suites make reviewing AI output sustainable. Automated regression tests catch hallucinations far more reliably than late-night manual code reviews.
Master delegation as a first-class skill. Instead of fighting prompt formulation, I treat context engineering as a serious discipline with its own standards and patterns.
Protect the tactile joy of coding. I maintain at least one side project where I write code entirely by hand, purely for the meditative flow of problem-solving. Even when daily work centers on steering agents, touching the raw material keeps instincts sharp.
Track personal meaning alongside velocity. Shipping faster is hollow if the day-to-day work feels alienating. Paying attention to that satisfaction curve is how you prevent burnout before it starts.

For practitioners who fell in love strictly with manual implementation, this transition represents a genuine loss, and acknowledging that grief matters. But for those drawn to strategic problem-solving, architectural design, and holistic ownership, this era offers unprecedented leverage. The real task is deciding which game you want to play, and preparing for it deliberately.

On this page

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