This is an addiction narrative wearing a developer blog's clothes. The author, maintainer of LibreWeddingPlanner, traces a clean arc from first hit to rock bottom to recovery — and the mechanism he describes will be instantly recognizable to anyone who has watched their own craft atrophy under the weight of convenience. The piece works not because the argument is novel (it isn't) but because the self-examination is forensically specific. The escalation sequence is the strongest section. It starts with autocomplete, moves to function generation, then test generation, then full-ticket implementation, then multiple simultaneous agents across git worktrees. Each step feels rational in isolation. The author captures the precise moment autonomy inverts: you're no longer directing the agents, you're reviewing their output, and the review quality degrades because you no longer understand the codebase well enough to catch errors. The TDD practitioner who can't spot a test that doesn't test the right scenario — that's the gut-punch detail. The economics of attention get an underrated treatment here. The author's observation that a 5-minute AI task plus 2 days of review is worse than 20 minutes of focused solo work is the kind of counterintuitive math that productivity culture refuses to engage with. Context-switching costs are real, compounding, and invisible to managers tracking ticket velocity. The $30 in tokens burned by a stalled agent doing nothing is a small, perfect emblem of the broader waste. There's a useful structural honesty about the social dynamics too — the author literally ran to disable co-author attribution on commits, wanting to pretend the code was his own. The shame of not understanding your own PRs, the anxiety about code review, the fear of being exposed as an 'AI shepherd' rather than an engineer — these aren't technical problems, they're identity problems, and the piece treats them as such without melodrama. The recovery section is thinner than the fall. Going back to TDD, small PRs, 2-line descriptions, and understanding your own code reads more like a return to baseline than a revelation. But that's honest — the insight isn't that there's a better way to code, it's that the better way was the way you already knew before you outsourced your judgment. The author doesn't claim AI is useless; he claims it made him specifically worse, and provides enough evidence to make the case. The piece has real blind spots. It's entirely about solo-developer experience within a team context — there's no engagement with how AI tools might work differently for genuinely collaborative coding, pair programming, or codebases where understanding is already distributed. The 'even if it costs me my job' line is dramatic but unexamined; the economic coercion angle deserved more than a throwaway. And the Google search-quality conspiracy theory about intentional AI degradation is unsubstantiated speculation dressed as rhetorical common sense. Still, as a first-person account of skill atrophy through automation dependency, this is unusually precise. It names specific behaviors — the verbal whip demanding output, the unread PR descriptions, the pretense of authorship — that most developers using these tools will recognize and have not yet articulated to themselves.
