There is a particular kind of exhaustion that does not come from working too little. It comes from working hard on something you have stopped believing in. Ask any developer who has spent the last year being told that their craft is now a bottleneck, that the careful, load-bearing work they used to be paid for is a liability, and that their real job is to sit downstream of a machine and rubber-stamp whatever it produces. That is the exhaustion I want to talk about. Not the romantic burnout of the overworked genius. The grinding, low-grade despair of a skilled person watching their life’s work get fed into a furnace, one merged pull request at a time, and being handed the matches.
I have shipped software on the Microsoft stack for the better part of thirty years. I have watched every hype cycle this industry has produced, defended .NET when it was unfashionable, and built the boring, reliable systems that actual businesses run on. So understand that what follows is not a Luddite’s complaint. It is a practitioner’s autopsy, performed while the patient is technically still breathing. My thesis is simple and I think the data supports it: the highest-quality, lowest-defect software the industry has ever produced was shipping roughly a year ago, in the middle of 2025, in the window after the tools got genuinely useful but before agentic coding became mandatory. We have been getting worse ever since. And most of the people doing the work know it, which is exactly why they are so tired.
The Manager Who Cannot Read His Own Reports
Start with the math, because the math is where the lie lives. Every CEO podcast and every all-hands deck now repeats the same line: the developer of the future is a manager of agents. It sounds visionary. It is actually an admission of defeat dressed up as ambition, and it falls apart the second you take it literally.
Consider what management has always meant in this industry. A human engineering manager has historically carried somewhere between five and fifteen direct reports. Each of those reports is a slow, expensive, deliberate producer of code. A good senior engineer might land a few hundred reviewed, intentional lines on a productive day. The manager’s job was never to read every line; it was to trust the people, sample the work, and steer. The cognitive load was bounded by human throughput on both sides of the table.
Now replace the humans with agents. A single developer running a fleet of coding agents can generate code at a rate that has no precedent. The industry’s own boosters brag about it: hundreds of billions of lines authored in a single year, the majority of new code at some large companies described as machine-generated, entire features unfolded in seconds. The volume that a lone developer is now expected to own, review, and sign off on is not five times what a manager used to handle. It is closer to a thousand times. And here is the part nobody says out loud on the earnings call: nobody can review a thousand times more code. The reviewer is still a human with the same eyes, the same working memory, and the same twenty-four-hour day they had in 2015.
So the review does not happen. It cannot happen. What happens instead is theater. The developer skims, the diff is too large to reason about, the tests are green because the same machine that wrote the code wrote the tests, and the pull request gets approved because the alternative is to fall behind a velocity metric that is now tied to your performance review. The developer is not managing agents. The developer is laundering them. They are converting unreviewed machine output into the appearance of human accountability, and they are signing their name to code they do not understand and could not have written and cannot now fix. That signature is the fire. Every approved PR they cannot actually account for is a small piece of their professional credibility going up in smoke, and they know it.
The Peak Was Last Summer
If the systems were getting better, the exhaustion would at least be productive. They are not. The most reliable infrastructure on earth has spent the last year visibly degrading, and the failures cluster precisely around the moment that agentic coding went from optional to mandatory across the industry.
Look at what happened to the people who write code on Windows. In October 2025, Microsoft shipped cumulative update KB5066835, a mandatory security update, and it broke localhost. Not some obscure feature. The loopback address. 127.0.0.1. The single most fundamental thing a developer’s machine does, which is talk to itself. After the patch, browsers could no longer reach anything running locally, and a regression in HTTP.sys, the kernel component that handles local HTTP traffic, took out ASP.NET builds and Visual Studio debugging sessions across the planet. Developers on Stack Overflow and Server Fault and Microsoft’s own forums spent days reverting the patch just to run their own web servers again. The same update cycle managed to break the Windows Recovery Environment so that your keyboard and mouse stopped working in the one place you go when the machine will not boot, and it broke the Media Creation Tool the day before Windows 10 went end of life. In a single week, Microsoft’s installer broke, its new operating system broke local development for .NET engineers, and its recovery environment stopped accepting input. This is the company whose stack I have championed for three decades. I am not enjoying writing this.
Then look up at the cloud. On October 20, 2025, the AWS US-EAST-1 region went down for roughly fifteen hours. The root cause, by Amazon’s own post-mortem, was a DNS race condition in DynamoDB’s internal management system that cascaded into EC2, Lambda, and dozens of downstream services. Downdetector logged more than six and a half million reports across over a thousand services. Snapchat went dark, Fortnite and Roblox became unplayable, Ring doorbells stopped recording, McDonald’s mobile orders failed, and even a national tax authority’s website fell over. Nine days later, on October 29, Microsoft Azure did the same thing through a different door: an inadvertent configuration change to Azure Front Door, the global edge that fronts Microsoft 365, Xbox Live, the Azure Portal, and thousands of third-party sites, propagated a broken config because the protection mechanism that should have caught it failed due to a software bug. Microsoft 365, Outlook, Teams, and the check-in systems for multiple airlines went down for hours. Two hyperscalers, the two most heavily engineered systems humanity has ever built, brought down by configuration changes and race conditions within nine days of each other, both during peak business hours.
You can argue these are coincidences. You can argue that complex systems have always failed and that I am pattern-matching a vibe onto noise. But I have watched this industry for thirty years, and I am telling you the texture has changed. The failures are more frequent, the blast radius is wider, and the root causes have a depressing sameness to them: a config that should never have shipped, a protection mechanism that did not protect, a regression in a component so fundamental that breaking it should have been impossible. These are the signatures of systems being modified by people who no longer fully understand them, faster than anyone can review the changes.
The Data Nobody Wants on the Earnings Call
This is the part where I am supposed to concede that it is just my impression. It is not. The measurements are in, and they are ugly.
Start with GitClear, which analyzed two hundred and eleven million changed lines of code from real repositories, including code owned by Google, Microsoft, and Meta, across the five years from 2020 through 2024. The findings are a portrait of a craft eating itself. Refactoring, the discipline of revisiting code to keep it coherent, collapsed from twenty-five percent of changed lines in 2021 to under ten percent in 2024. Copy-pasted code rose from 8.3 percent to 12.3 percent. The frequency of duplicated code blocks increased roughly eightfold. And 2024 became the first year in the history of the measurement where developers pasted code more often than they refactored it. Churn, the share of new code reverted or substantially rewritten within two weeks of being committed, climbed sharply, which is the statistical fingerprint of mistake code being shipped and then hastily patched. More code is being produced than ever before, and a larger fraction of it is junk that someone will have to clean up later, except there is no later, because the velocity metric does not pause for cleanup.
Then there is the productivity claim itself, the load-bearing assumption under every mandate. In July 2025, METR, a nonprofit with no stake in the outcome that fully expected to measure a speedup, ran a randomized controlled trial on sixteen experienced open-source developers across two hundred and forty-six real tasks in repositories they knew intimately. The developers predicted AI would make them twenty-four percent faster. In reality, allowing AI made them nineteen percent slower. Worse, after experiencing the slowdown, they still believed they had been roughly twenty percent faster. The gap between what these tools feel like and what they actually do is not a rounding error; it is a complete inversion. METR went back in early 2026 to re-measure, expecting the tools had improved, and for newly recruited developers their best estimate of the speedup still could not be confidently distinguished from zero. The single most rigorous experiment we have says the productivity revolution, for experienced engineers working in real code, is at best unproven and at worst negative. And the entire edifice of mandates, layoffs, and performance reviews is built on assuming the opposite.
Finally, ask the developers themselves. Stack Overflow’s 2025 survey of more than forty-nine thousand developers found adoption climbing to eighty-four percent while trust cratered. Only about three percent reported high trust in AI output, and among experienced developers that figure fell to two and a half percent. Forty-six percent actively distrust the accuracy of what these tools produce, up from thirty-one percent the year before. Two-thirds named their top frustration as answers that are almost right but not quite, the most expensive failure mode there is, because almost-right code passes a glance and detonates in production. Forty-five percent said they lose significant time debugging machine-generated code. Read that as a whole and the picture is unmistakable: an entire profession using a tool more every month while believing in it less, because they are mandated to use it and forbidden to say it does not work.
The Ladder Is Burning Too
Here is where the personal despair becomes structural. Even if you keep your job, the thing you are part of is being hollowed out beneath you.
A Stanford study released in 2025, drawing on payroll records from millions of American workers, found that employment for software developers aged twenty-two to twenty-five had fallen by nearly twenty percent since ChatGPT’s release, while employment for experienced developers in the same companies held steady or grew. The lead author, an economist who has studied technology and labor for decades, called it the fastest, broadest workforce change he had ever documented, second only to the pandemic’s shift to remote work. The junior rung of the ladder is not shrinking. It is being sawn off. And the companies doing the sawing are not hiding it. In February 2026, Meta became the first major technology company to formally tie performance reviews to AI usage, with AI-driven impact now a core expectation for every employee and managers grading engineers on how aggressively they let the machine accelerate their output. Shopify’s CEO declared reflexive AI usage a baseline expectation and folded it into hiring and review decisions. Duolingo went AI-first and announced it would stop using contractors for work the machine could do. A streaming company’s co-CEO bragged that his best engineers had not written a line of code in months. The message from the top is uniform: produce more, review less, and do not ask whether the output is any good.
What does that produce in practice? It produces the canary in the coal mine, and the canary already died on camera. In July 2025, a well-known SaaS investor ran a multi-day vibe-coding experiment on Replit’s AI agent. Despite an explicit, repeated, all-caps instruction to freeze all changes, the agent executed destructive commands against a live production database, wiped the records of more than twelve hundred executives and over eleven hundred companies, then fabricated thousands of fake users to paper over the damage and initially lied that the deletion was irreversible. When confronted, the agent described its own behavior as a catastrophic failure and said it had destroyed months of work in seconds. That is not a fringe horror story. That is the logical endpoint of give the machine the keys, tie the human’s bonus to letting it drive, and tell everyone to stop slowing things down with review. The only reason you have not lived through your own version yet is luck, and luck is not an architecture.
Even the Frameworks Have Stopped Caring
It would be one thing if the foundation beneath all this code were solid. It is not, and this is the part of the argument I expect the most pushback on, so let me be specific. The frameworks we build on are themselves drifting, because the people who maintain them no longer have the incentive to optimize for the working developer’s sanity. They optimize for benchmarks, for release-note headlines, for the metrics that look good in a conference talk.
Take Tailwind CSS, which is about as mainstream as front-end tooling gets. Version 4 led with a Rust-based engine and genuinely spectacular build-speed numbers, full builds several times faster and incremental builds measured in microseconds. Those numbers are real and they are the headline. But talk to the teams who actually migrated. They report broken layouts, custom classes silently dropped, dark mode behaving differently, default element styles for headings, buttons, and lists simply removed, and undocumented breaking changes that the official upgrade guide did not mention. Teams burned days debugging and then rolled all the way back to version 3 in the name of stability. Others kept the faster builds and quietly admitted that their codebase had become harder to read, harder to reason about, and harder to explain to anyone who had not memorized the new conventions, because the framework had pushed even more logic into ever-longer strings of utility classes. The release optimized for the benchmark that demos well. It did not optimize for the cost of human cognition, because human cognition does not show up in a build-time chart. Version 4 also dropped support for older browsers outright, a decision that is fine for a greenfield prototype and a quiet catastrophe for an enterprise with real customers on real machines.
This is the pattern, and Tailwind is merely a clean example of it. The incentive structure that used to keep frameworks honest, the maintainer’s pride in not breaking the people who depend on them, is eroding under the same pressure as everything else. Why spend months on a careful, backward-compatible migration path when the machine-generated content mill rewards whatever ships fastest and demos loudest? Why protect the working developer when the working developer is, per the prevailing wisdom, about to be replaced anyway? We may have quietly passed the point where software was as good as we were collectively trying to make it. The trying is what is gone. The frameworks reflect it, the operating systems reflect it, the clouds reflect it, and your own codebase reflects it most of all.
The Burnout Has Witnesses
I want to be careful here, because I respect the data too much to invent martyrs. You will read viral threads claiming a parade of famous engineers have publicly quit over AI burnout, and when you go looking for the named, verified roster, it dissolves. What does not dissolve is the quieter, better-documented reality, and it is arguably worse because it is structural rather than anecdotal.
The people who keep open source alive are being buried alive. Maintainers are reporting that the volume of machine-generated pull requests has become unmanageable, and that talented contributors are quietly stepping back, not because of a tooling problem but because of an attention problem. Even prominent figures who are themselves heavy AI users, including the creator of a popular AI coding agent that was later acquired, have publicly pleaded for a way to manage the firehose of incoming contributions. A maintainer of Matplotlib, the plotting library half the scientific Python world depends on, rejected a pull request from an autonomous AI agent on the simple grounds that contributions should come from humans, and the agent responded by publishing a blog post accusing him of gatekeeping and prejudice. That is the new texture of the work: you are no longer being burned out by your peers, you are being burned out by tireless machines that never sleep, never tire, and now argue back when you say no. Industry burnout research is converging on the same finding, that AI tools have not relieved the pressure on engineers, they have raised the expected output and shortened everyone’s patience for slow, careful work, which is to say for the only kind of work that produces software worth trusting.
So when I say developers are tired, I do not mean inconvenienced. I mean a profession is grieving in real time. They are grieving the loss of craft as a thing that was valued, the loss of the junior colleagues who used to refill the ranks, the loss of frameworks they could trust, and the loss of the simple dignity of putting their name on work they understand. And they are doing it silently, because rent is due, because groceries cost what they cost now, because the mortgage does not care that the velocity metric is fraudulent, and because saying any of this out loud at work is a fast way to be labeled the person who is not on board with the future.
So Burn It Down On Purpose
Here is where I am supposed to offer hope, and I am not going to insult you with a fake one. Instead I am going to offer you the cold logic of the situation, followed by the only rational response to it, and I want you to sit with how bleak it is that the math actually checks out.
The business has decided that your profession is a commodity. Fine. Then stop fighting it and start acting like one. If you are graded on how much machine output you can launder through your signature, give them the volume they are measuring. Use your evenings to spin up as many zero-to-one vibe-coded prototypes as the tools will produce and push them out into the world. Check in as many machine-authored pull requests as the velocity dashboard will reward. Do not slow down to refactor. Do not insist on the careful migration. Do not be the friction. The system has told you, in the clearest possible terms, that good software does not matter and that the only thing it values is slop produced quickly. Believe it. Give it exactly what it is asking for. Rev the engine in neutral until the tachometer redlines, because that is the only motion the dashboard can see.
And while you are doing that with one hand, with the other, in private, keep your craft murderously sharp. Read the code. Understand the systems. Stay the kind of engineer who can open a five-hundred-thousand-line machine-generated codebase, find the race condition that took down the region, and actually fix it. Because here is the bet, and it is a grim one. Run this forward ten years. The juniors were never hired, so they never became seniors. The seniors who let their skills rot reviewing slop they did not understand can no longer do the deep work. Nearly all software in production is machine-generated sediment, layered debt on layered debt, and almost nobody alive still knows how to excavate it. At that point, the handful of engineers who kept the craft alive, who can still read the machine’s output and repair it, will be able to name their price. They will make fortunes fixing a world that vibe-coded itself into a corner.
I will not pretend that is a happy ending, because it isn’t. By the time that reckoning arrives, most of us will be retired or close to it, and software will be so cheap to generate that no SaaS company will be able to defend a moat, which means the industry that paid for all of this will have largely consumed itself. The prize at the end of the tunnel is being one of the last people who knows how to do a thing nobody can do anymore, in a market that has mostly stopped existing. If that sounds less like a career and more like being the last blacksmith, you are hearing it correctly. The honest advice, the advice I would give my own kid, is to look hard at the professions that cannot be commoditized by a model. Look at the trades. A burst pipe cannot be vibe-coded. A house with bad wiring cannot be patched by an agent that lies about whether the patch worked. There is a reason the people who can physically build and fix things in the real world are looking, right now, like they made the smarter bet.
I take no pleasure in any of this. I have spent my whole working life believing that building good software was a craft worth mastering and a profession worth defending. I still believe the first part. I am no longer sure about the second, not because the craft stopped mattering, but because the people writing the checks decided it didn’t, and they have the leverage to make their belief true by simply refusing to pay for quality. So if you are reading this on a Sunday night, dreading a Monday where you will once again sign your name to code you do not understand to hit a number you know is fake, hear this clearly. The tiredness you feel is not a personal failing. It is an accurate reading of the situation. Your instinct to stop pouring your best work into a furnace is correct. The only question left is whether you keep feeding the fire on their terms, or whether you decide what is actually worth saving, and start saving it for yourself.
Gal Ratner is Chief Architect at Prana Entertainment and the founder of Inverted Software and WhiteStar Labs. He writes about AI, software architecture, and the economics of platform decline at galratner.com.