I have quit AI coding tools twice. The first took three months and almost no thought. The second took six months and a lot more of it.
Writing it down so I can check later whether I was right.
The first time
Seven years now, since 2019. Contract work, freelancing, full stack roles, a stretch as head of software at a small startup, senior engineering. What I sold was speed of pickup. Unfamiliar stack, a deadline, and I would be useful by Friday.
ChatGPT arrived late in 2022. Copilot landed in my editor early the next year, back when it was only autocomplete, and I liked it immediately. Chat came after, and I liked that too. It was good at the boring parts.
Three months in, I was reaching for it before I had finished reading the problem. Skim the error, take the suggestion, move on. When it was wrong I asked again instead of thinking. The part of the job where you sit with something confusing until it stops being confusing had gone missing.
So I turned it off. No announcement, I just stopped, and wrote everything by hand for three years.
What brought me back
This year when working, we hit one of those weeks where two days had to hold a week of work. My colleague had been telling me to try Claude Code for a while. That week he stopped suggesting and started insisting.
Coming back was a little disorienting. I had left an autocomplete in a text editor. I returned to a command line tool that edits files, runs commands, drives a browser, spawns parallel copies of itself, and loads whole libraries of instructions and integrations. Not a better version of what I left. A different thing.
And it worked. We shipped. I enjoyed it for a while.
Six months later I was trying a new one every few days. Claude Code, Codex, OpenCode, whatever had been posted that morning. I had stopped evaluating tools and started using them the way you use a phone. That was the second warning, and this time I read before deciding.
Everything got faster, including the parts you do not want faster
The speed is real. You watch a feature appear in an afternoon, and the first few times it is genuinely impressive.
What took longer to notice was everything else that sped up. Technical debt, because code nobody on the team wrote piles up faster than code somebody did. Outages, for the same reason. The card. The feeling of having achieved something, which also leaves faster, because you did not do the thing you are being congratulated for. The dopamine, and the crash behind it.
None of that is output. A merged pull request is not revenue, and a green build is not a customer. In open source it is starker: shipping more does not give you stars, or installs, or one person who depends on your project. Those come from somebody deciding your work is worth their time, and nothing in this stack moves that number.
So ninety percent of your days feel quick while a line runs the other way underneath. The debt keeps compounding. The gap between your engineers and the code they own widens every sprint. Two years in, the team is slower than before any of this started, and nobody can name the week it went wrong, because it was not one week, but the whole process itself.
That is the part I find hard to forgive. Not that the tools are bad. That they feel excellent while the bill runs up somewhere you are not looking.
What it costs you
We all know that learning something new opens up new neural pathways in our brains.
Learning something hard is cutting a path. The first pass is slow and miserable: research, choose wrong, back out, choose again. Do that enough in one area and the path shortens, until what took two weeks becomes something you simply know.
I wanted a desktop app in Rust with real graphics. That meant learning Rust, then how desktop apps are put together in it, then which UI library and what each one costs you, then how pixels actually reach the screen. wgpu came out as the conclusion, understood rather than recommended. Weeks of work, nothing shippable.
Next time I repeat none of that research. The decision collapses into one step, and that collapse is what those weeks taught and bought.
When a model runs this research, you get the answer and skip the collapse. Code lands, ticket closes, nothing moves in your head. An year of that is an year of shipped work and no new paths. Which is strange, because cutting those paths is exactly what these companies do to their own models. Odd thing to hand over.
The other half sounds soft and matters more. I started programming because solving something myself felt good, and that is why I am still here seven years later. It does not survive becoming the person who approves suggestions. You cannot outwork someone doing it for fun, and a model is not having fun.
We are measuring the wrong things
Job posts now want people who have "accelerated their workflow with AI". Interviews turn into a tour of how many tools someone has installed and how much a single prompt can produce.
It is not only hiring. Inside the company the dashboard counts pull requests merged, lines changed, tickets closed. All of it measures motion, all of it rises the moment you let a model write, and none of it says whether the system got simpler or whether anyone still understands it.
This is the part that makes me angry, because it inverts the job. Seven years taught me the best change is the smallest one that works, and every line nobody needed is debt somebody pays later. By the numbers we have chosen, deleting four hundred lines is a bad week. We built a signal that rewards the opposite of the work and called it seniority.
The bill is quiet too. Every capability you bolt on sits in the context window on every request, so more instructions and integrations mean more tokens, forever, growing with the codebase. Then the building is billed, and the review, the tests, the fixes, the pull request checks, all on the same meter. Not bitterness. Just noticing that the incentive is for the loop to continue.
The fatigue nobody puts in the pitch
The problem was never bad output. The output is nearly right.
It reaches ninety nine percent fast. Then you lose an afternoon on the last one percent, each round costing real money and returning a slightly different near miss. Eventually you accept something you would not have written, or fix it yourself, which is what you would have done at the start.
Anyone who has managed people knows micromanaging is exhausting, and not only for the person being managed. You carry the task around. You check, check again, cannot put it down, and finish the day tired without being able to point at what you did.
That is exactly what this feels like.
It is not delegation. Delegation means handing something over. This is handing it over and standing behind it the whole time. I review the plan, the diff, the commit. People who advocate for using these tools properly say the same: always read the code before it ships. They are right, and what they describe is micromanagement, all day, every day.
Hand work to a person and I expect it back finished. With the best setup I can build, the best instructions, the best tools wired in, it still gets things wrong, so I never stop watching.
Then the loop at night. One more prompt should fix it. It does, and breaks something else, so one more prompt. I have lost whole evenings in there and come out with a bill and a branch I did not trust.
Writing the prompt is work too. A good one is close to a small spec and takes real time and thought. Then you send it and wait, and the waiting is what I resent most. Too short to start anything else, too long to sit still, so you open Instagram, or a video, and your attention is gone. Hours pass where you were neither working nor resting.
Sleep slips. Focus slips. I spent months calling this a tooling problem when it was a fatigue problem.
What I keep in my head
What I would hate to lose in the other direction is this. When I have written a codebase myself, I carry an index of it. Wake me at three in the morning and ask where something lives and I can tell you, because I typed it and went through every file.
The industry is now spending real money rebuilding that index artificially. Instruction files that grow with the project. Retrieval systems, the commercial ones and open ones like CocoIndex. They work, they cost, they grow, and none of it is anything the person who wrote the code did not already have for free.
This matters most on the worst day. Production breaks, and the instinct now is to paste it into the tool, often fine. But the outages I have seen were rarely code problems. A provider had a bad hour and nothing failed over. A reroute did not exist. One environment variable was missing in one place. There was no status page, so nobody knew what was down. A model living inside one repository cannot see any of that, and if you have not touched the code in six months, neither can you.
That is when it gets expensive, and the cost is trust, not tokens.
Which is why the market is about to get strange. Companies are cutting engineers because the tools look like a replacement. Then something goes badly wrong and they go and find a senior person who can work without them. If that keeps happening, being one of those people is worth more than it was three years ago, not less.
The part that is most dangerous for everyone
Every provider puts it in the policy. Anthropic says commercial usage, meaning the API and Claude for Work, is not used for training by default. OpenAI has said the same about API traffic since March 2023.
I do not believe it. That is a feeling rather than a receipt, and I am telling you it is mine.
The promise is narrow and the pipeline is wide. Prompts get captured and processed for reasons nobody disputes: analysis, personalisation, evaluation, safety review, working out whether a new version beats the old one. None of that is called training, and none of these companies own every layer they run on.
The exceptions they publish are already wide. Press thumbs up or thumbs down and the whole conversation goes in and can be kept for five years. Prompts and responses sit in abuse logs for a month unless you are approved for something stricter. Consumer plans are different again, and that is what most individual developers and small teams are on, including people running these coding tools on a personal subscription. Almost nobody knows which side of that line they are on.
These are policies, not properties. Anthropic's page was revised in August, the consumer terms changed last year. I am being asked to make a call about intellectual property that matters for ten years on the strength of a document that can be rewritten next quarter, by a company with every reason to rewrite it.
Picture a company with something genuinely new in its stack. Closed source, years of work, the piece the business rests on. Its engineers build it with the same assistants as everyone else, because that is how work happens now. Every design argument, every refactor, every careful explanation of why the hard part has to work that way, typed into someone else's system.
Now picture a model two years from now with the shape of that thing somewhere inside it. Someone asks for it in plain language and gets most of the way there over a weekend. The company still owns its code. What it lost was being the only people who knew how.
I am designing an open source context engine right now, in a space where the strong products are closed, so this one is not abstract for me. If I can imagine asking a model to rebuild someone else's architecture, I have to assume someone can imagine doing it to mine.
What I am doing
In October I stop. Not cutting down, not being disciplined about it. Stopping, the way I did in 2023, because the middle has never held for me.
I want to be fair about the cost. These tools are very good at starting things: scaffolding, boilerplate, config, a first draft in a language you do not know yet. I will be slower without them and I am not going to pretend otherwise. The models will keep improving, and if one ever reasons through a system instead of predicting the next likely token, I will come back and say so.
I do not know how this goes down at work. That conversation is still ahead of me and I may not get everything I want from it. OSS Labs is simpler, because it is mine. Everything there gets written by hand.
If you are in your first ten years of this, that is the part I would push on. Not the ethics, not the politics. Just whether the thing you are trading away is the thing you were planning to be paid for in ten years.