I Finish Early Now, and I’ve Never Been More Tired.

It’s 10:40 on a Tuesday. The ticket landed in your queue forty minutes ago — one of the gnarly ones, the kind that used to eat a whole morning. You described it to the model in three sentences, watched it think, read the diff, ran the tests. Green. You merged at 10:41.

You lean back. The thing took twenty minutes. Two years ago it would have taken three hours, and you’d have earned the coffee you’re now holding at quarter to eleven with the rest of the morning wide open in front of you.

By every number that lands on a dashboard, that’s a win. You shipped. The tests passed. Your velocity this quarter is the best it’s ever been. If someone asked, you’d say AI made you faster, and you’d be telling the truth.

So here’s the part nobody puts on the dashboard: it’s Tuesday at 10:41, you’ve already “won,” and instead of feeling lighter you feel a low hum of something you don’t have a word for. Not tired exactly. Not bored. More like the feeling of having eaten three meals in twenty minutes — fed, technically, and slightly sick.

If you’ve got five years in, you’re shipping more than you ever have, and you still end most weeks emptier than you can explain to anyone who’d ask — this is for you. Not because you’re doing it wrong. Because you’re doing exactly what the tools and the numbers and your own sense of being a good worker are all telling you to do, and it’s quietly costing you something the numbers can’t see.

The story we’ve been told is that AI saves time. It doesn’t. It saves time and then immediately spends it back, and it hands you a bill in a currency the dashboard doesn’t track — your attention, your memory of your own week, and the quiet hours where work used to actually become yours.

You shipped it Tuesday, and on Thursday you couldn’t say why

Fast-forward two days. It’s Thursday standup. Someone asks, casually, why the Tuesday change handles retries the way it does — there’s an edge case in staging.

And you blank.

Not because you’re slipping. Because you never actually knew. On Tuesday the model proposed an approach, it looked right, the tests were green, and you nodded it through. You read the diff the way you read a contract you’ve decided to sign anyway — eyes moving, brain idling. You didn’t choose the retry logic. You approved it. Those are different acts, and only one of them leaves a trace you can find on Thursday.

This is the crack in the story, and it’s worth sitting with because it’s so easy to wave away. The work got faster. The understanding did not. Producing the change took twenty minutes; actually metabolizing it — building the mental model where you’d know, two days later, why the retries work the way they do — that still takes the two hours it always took. And you didn’t take them. Nobody takes them. The whole point of the tool is that you don’t have to.

We’ve had the data on this for a while, and it’s more lopsided than people expect. Even before AI, developers spent the smaller part of their day actually writing code — one large analysis of enterprise repositories put it at about 32%, with the rest going to maintaining, testing, and understanding code that already exists (SonarSource, 2022). The reason is structural, and a 2003 ACM Queue piece named it cleanly: writing is walking down a decision tree — you narrow toward one answer, and the narrowing builds the model in your head. Reading is the reverse. You’re handed the single answer and have to climb back up through every branch the author didn’t take, reconstructing why this and not that. Writing builds context for free. Reading makes you pay for it (ACM Queue, 2003).

AI flipped the ratio and nobody adjusted for it. Now nearly all the code crossing your screen is code you didn’t write — so nearly all of it carries the expensive kind of cost, the climbing-back-up kind, and you’re doing it forty times a day instead of five.

Here’s the finding that should stop you, because it’s the most carefully measured one we have. In a randomized controlled trial, METR had experienced open-source developers do real tasks on their own large codebases, with and without AI tools. The developers predicted AI would make them about 24% faster. It made them 19% slower. And — this is the part that matters — even after finishing, they still believed it had sped them up (METR, 2025). The speed was real on screen and false in the clock. The gap between how fast it felt and how fast it was is not a rounding error. It’s the whole subject of this essay.

The gap isn’t speed. It’s that you stopped taking the two hours

So let me say the thing plainly, because everything else hangs off it.

You are not tired because AI is hard. You’re tired because AI produces faster than you can understand what it produced — and you stopped giving yourself the time to close that gap.

The tool got faster at producing. You did not get faster at understanding. Everything wrong with your week lives in that gap.

The twenty-minute change didn’t actually take twenty minutes. It took twenty minutes plus a two-hour comprehension debt you didn’t pay — and that debt didn’t vanish because you skipped it. It went on a tab. It’s sitting there on Thursday when you can’t explain the retries. It’s sitting there as the low hum on Tuesday at 10:41. Multiply it across every ticket, every doc, every “just have the model draft it” — and by Friday you’re carrying a stack of work you shipped and never digested, each piece a little open loop your brain is quietly holding because it never got to close it.

That stack is the intensity. Not the volume of tasks — knowledge workers have always had too many tasks. The new thing is the ratio: you can now generate far more than you can absorb, and the absorption is the part that used to make the day feel like it added up to something. Strip it out and you get a day that is fuller and emptier at the same time. More shipped, less held.

The cruel detail is that none of this shows up where you’d look for it. Your output went up. Your reviews are fine. The trap, like most real traps, is invisible from inside the thing that sprung it.

You didn’t get the time back — you spent it before it landed

Now ask the obvious question. The model handed you two hours and forty minutes back this morning. Where did they go? Why didn’t you spend even one of them understanding the thing you shipped?

Because you never saw the time as yours to keep. It landed at 10:41 and you’d already reached for the next ticket before it touched the ground.

This is the part I want to be honest about, because it’s not flattering and it’s true: nobody assigned you the second shift. You volunteered it. The empty stretch of morning didn’t read as rest you’d earned — it read as slack to be filled, maybe even as a small problem with your day. So you filled it. Another ticket. A “while I’m at it” refactor. The doc you said you’d get to. Five tabs open because the model can hold five conversations and so, apparently, can you. By 11:15 the won morning is gone and you’re moving faster than you were before you “saved” the time.

And the organization around you is doing the exact same thing at scale, which makes it almost impossible to feel like a choice. When the cost of producing a draft, an email, a code change drops to near zero, the demand for drafts and emails and changes doesn’t hold steady — it explodes. Economists have a name for this: when something gets cheaper to produce, we don’t consume less of it, we consume dramatically more. Cheaper code means more code. Faster emails mean more emails expecting faster replies.

The telemetry is blunt about where that lands. Microsoft, looking at trillions of signals across Microsoft 365, described what it called the “infinite workday”: meetings after 8 p.m. up 16% year over year, after-hours chats climbing, nearly a third of active workers back in their inbox by 10 p.m. (Microsoft Work Trend Index, June 2025). A separate study of 443 million hours of real work activity found that after AI adoption, workloads got heavier, not lighter — email volume up 104%, chat up 145%, and daily focused time down by 23 minutes, with workers spending around two hours a week just cleaning up low-quality machine output (ActivTrak, reported in Inc., March 2026).

Read those numbers next to the productivity story and they don’t fit — unless you stop expecting AI to give time back and start seeing what it actually does. It doesn’t shorten the day. It raises the throughput of the day, and then everyone — your company, your team, and most of all you — quietly resets “normal” to the higher number. The saved time was real. You just spent it before it had a chance to feel like yours.

The job used to rest you, and you never noticed

Here’s something nobody mourns because nobody clocked it as valuable: the old workday was full of holes, and the holes were the point.

The build took four minutes — you stared out the window. The big query ran — you got up for coffee. There was a half-asleep ticket every Thursday afternoon that asked almost nothing of you, and it functioned, though no one would have dared call it this, as rest. You weren’t slacking. You were doing what every system that runs for a long time without breaking does: alternating load with recovery. The work paced itself, and the pacing was invisible because it was built into the materials.

AI found every one of those holes and filled it. The build still takes four minutes, but now you prompt a second model in another window while you wait. The coffee still brews, but you’re answering Slack on your phone over the machine. The half-asleep Thursday ticket is gone — the model clears it in thirty seconds, and the thirty seconds you saved became the down payment on a harder ticket. Every pocket of slack got optimized into output. The day went from interval training to a flat sprint with no marked finish.

And it turns out the holes were doing real work. A meta-analysis of micro-break studies found that even short pauses — under ten minutes — measurably restore energy and attention and cut fatigue, with the effect strongest for exactly the kind of focused cognitive work you do all day (PLoS One, 2022). The corollary is the part that explains your Friday: chronic exhaustion comes as much from the absence of recovery as from the presence of work. You can be wrecked by a day that wasn’t even long — if it never once let you downshift. Which is the modern AI workday in one sentence. Not longer. Just gapless.

This is where the treadmill comes in, because it’s the only honest picture of the thing.

You’re on a treadmill that speeds up every time you match its pace. Keep up, and the reward is a faster belt. Keep up with that, and it goes faster still. The cruelty isn’t the speed — it’s the feedback loop, where competence is punished with more load. But here’s the detail people miss when they reach for this metaphor: the speed dial is not on the wall where the machine controls it. It’s under your hand. And you keep nudging it up — taking the extra ticket, opening the fifth tab, filling the won morning — because at this point slowing down doesn’t feel like rest. It feels like quitting. The old job came with intervals built into the belt. AI handed you one that only turns one way, and then handed you the dial and walked off.

A week you can’t remember is a week you can’t compound

Go back to Thursday standup, the retries you couldn’t explain. Now widen the lens. It’s Friday at 5 p.m. — can you actually reconstruct what you shipped on Monday? Walk it back, hour by hour. Most weeks, if you’re honest, it’s fog. And we file that under ordinary busyness, the price of a full week. It isn’t. It’s a specific, measurable consequence of how you produced the work, and the cognitive science on it is old and settled.

The first piece is the generation effect: people remember what they produce themselves far better than what they’re handed to read, a result replicated steadily since 1978. The act of generating — choosing the word, deriving the answer, writing the line — is the act that lays down the memory. When the model generates and you approve, you skip precisely that step. You get the output and forfeit the encoding.

The second piece is the Google effect, named in a 2011 study in Science: when your brain knows some external system is holding a piece of information, it quietly decides not to keep it, and remembers where to find it instead of what it is (Sparrow et al., Science, 2011). There’s newer, thinner work — an fMRI preprint suggesting the brain treats offloading like a deliberate decision to forget (PsyArXiv, 2025; preprint, so hold it loosely). The settled part is enough: you have turned the model into the external system that holds your own work, and your brain is doing what it’s built to do — letting go of what it believes it doesn’t need to carry.

So the forgetting isn’t a flaw in you. You engineered it, one approved diff at a time.

And this is the one that should bother you most, because it’s about the next ten years and not just this Friday: expertise is mostly memory of your own work, refined. The senior you became was built out of thousands of remembered Tuesdays — the bug that bit you, the design that aged badly, the call you got right and watched pay off. A week you can’t remember can’t turn into any of that. You can ship hard for a year and come out the other side as the same engineer you went in as — busier, better-decorated, not one inch deeper. The output compounded for the company. Nothing compounded for you.

The pile doesn’t vanish. It just stops being defensible

It would be one thing if the undigested work simply sat there quietly. It doesn’t. It comes back, and it comes back in three places.

It comes back in the codebase. GitClear’s telemetry across millions of lines of real repositories shows the signature of all this generation: heavy AI users author several times more code, but churn — code reverted or rewritten within two weeks of being committed — has climbed sharply, copy-pasted blocks have multiplied, and refactoring has fallen off a cliff (GitClear, 2024–2026). Plain version: a meaningful slice of the work you “finished” at 10:41 wasn’t finished. It comes back to be redone, because nobody — including you — ever built the model that would have made it right the first time. And the review that’s meant to catch it can’t: the classic Cisco/SmartBear study found defect detection collapses once a review runs past about 400 lines, and the model hands you 600-line diffs before lunch (SmartBear, 2005). Past that ceiling, review becomes rubber-stamping. You approve. Your reviewer approves. The flaw ships, fully witnessed, fully unexamined.

It comes back in the room. Design review, someone asks why it’s built this way. “The model suggested it” is a non-answer, and everyone in the room hears it as one, even the ones too kind to say so. You can’t defend what you never digested. The commit carries your name and no one’s understanding — least of all yours.

And it comes back at 2 a.m. Every shipped-but-not-understood thing is an open loop, and open loops are exactly what the mind keeps worrying at when it’s finally supposed to be off. The low hum from Tuesday at 10:41 — that’s the sound of forty loops nobody closed.

You’re not anxious because you’re behind. You’re anxious because you’re ahead on paper and can’t account for a single piece of it.

That’s the bill the dashboard never prints. More output, less defensible. A codebase that quietly redoes your work, a review process that waves it through, and a nervous system that never gets to mark the day finished — because some part of you knows it isn’t.

Defend the two hours

The fix is not to use AI less. It’s good at what it’s good at, and going back to typing everything by hand is just nostalgia with extra steps. The fix is to stop treating the time it hands back as inventory to refill — and to start treating it as what it actually is: the comprehension and recovery time that used to be built into the day, that you now have to put back by hand, because the tool stripped it out and won’t replace it for you.

One principle holds the whole thing up: finishing early is not permission to do more. It’s permission to understand what you just did — or to stop. That sentence runs directly against every instinct the last two years trained into you, which is exactly why it’s the one that matters.

Concretely, four moves, in rough order of how much they’ll cost you to actually do:

• Bank some of the time. When the model hands back two hours, keep one. Let finished be finished. The genuinely transgressive act in 2026 is to ship at 10:41 and not reach for the next ticket — to let the won morning stay won.
• Pay the comprehension debt on the things that matter. Not everything; most of what you ship truly doesn’t need it. But the load-bearing change — the one you’ll get asked about Thursday — take the two hours, read it the slow way, build the model in your head. Do it so the question has an answer and the work becomes yours.
• Leave a trace. Two lines at the end of the day on what you shipped and why. A developer journal does two jobs at once: the act of writing it forces a moment of real encoding, which is the direct antidote to the forgetting tax, and it leaves the week a memory you can actually compound into expertise.
• Put one trough back. A real pause — not a tab-switch dressed as a break, an actual gap where nothing is loading and nothing is generating. The research says even a few minutes restores more than you’d guess. Build it in on purpose, because nothing in your tools will build it for you.

None of this is about managing your tasks better. You have never been more efficient at tasks in your life — that’s the whole problem. It’s about managing the one thing the tools can’t expand: the rate at which a human being can absorb, recover, and remember.

So here’s where I’ll leave you, back on the treadmill. You can’t make it slower by running harder — running harder is the input that speeds it up. The only way off the escalation is to put your hand on the dial yourself and turn it down, which will feel, every single time, like falling behind. It isn’t. It’s the difference between a year that makes you a deeper engineer and a year that just makes you a more tired one.

Next Tuesday it’ll be 10:41, you’ll have won the morning, and you’ll feel the reach for the next ticket before you’ve decided anything. That reach is the entire essay. Notice it. Then keep the morning instead.