I Used to Be a Magician
On Claude Fatigue, and how we might all become absolutely dumb, stupid people (starting with me)

TL;DR
- I love AI, and it made me faster than ever. It also made me more tired and absent than ever. I call it Claude Fatigue.
- From the outside, building now looks easy. The hard part didn't disappear, it became invisible.
- The cost of building has collapsed, but the cost of caring hasn't. That's where I want to spend my time again.
The magician
For years, my team called me a magician. It wasn't only speed. An idea would come up in a meeting, and by the time it ended, a first version was often running: the right feature, built on the right architecture, smooth and good looking.
I could do that because the whole architecture lived in my head. I could see where the new thing would plug in, which tables it would touch, which service would break. Building while we were still talking about it felt natural.
It even became a running joke on Slack. People rarely asked me to fix something. They asked for "a quick Robin magic", usually with a magic wand emoji.
Today, part of that superpower is available to almost anyone with a laptop and a subscription. I want to write honestly about what that does to builders: the speed, the fatigue, and the question of why we were building in the first place.
Why I build
I've been building complex systems since I was 14. It started on a big French private server of an online game, where I shipped content, tools and a game launcher to hundreds of players, on a codebase so painful we could barely compile it.
That's where I fell in love with building. The pride of shipping something. Players telling you instantly what they loved or hated. And a clear reason behind every feature: make the world better for the people in it.
What AI changed
Then AI coding agents arrived. In a couple of years, the distance between an idea and running software collapsed.
These days, AI is part of almost everything I build. Millions of tokens a day, building features for Onepilot with Claude Code. Things that used to take weeks now take an afternoon, and things I would never have had time to try now get tried.
I recently asked Claude Code to summarize my last three months. The answer: 247 sessions, about 7,900 prompts and roughly 520 active hours, with around 730 commits in October alone. A fraud detection module, a new version of our agents' browser extension, a billing engine, a self-serve audit tool for prospects, and a lot more.
To put that in perspective: about 80 prompts a day, weekends included, and roughly the working hours of a full-time engineer's entire quarter, alongside everything else a co-founder does.
This is the dream, and I mean it. Everything I wished I could do as a kid, I can now do before lunch.
I use it every day. Everything that follows comes from someone who loves these tools, not from a skeptic.
And it's not just me. Designers ship apps, ops people write their own tools, founders prototype a product over a weekend. Everyone can build now, and that part is genuinely wonderful.
And yet, I feel less relevant than I used to. The gap that made me the magician has narrowed. When anyone can go from idea to working feature in an hour, it gets much harder to see the difference between something fast and something right.
Claude Fatigue
Worse, I often feel like a zombie. I've started calling it Claude Fatigue. I'm surely not the first to use the term, but I came up with it on my own, and it fits. It's not tiredness from working too much. It's a specific kind of numbness.
You prompt, wait, read a diff, correct, approve, and start again. Across several threads at once, all day. By evening you've shipped a lot, and you can barely remember any of it.
You're present and productive, and somehow absent from your own work.
You review more than you make. You decide less than you approve.
The summary made it concrete. Six of my sessions ran between 20 and 32 active hours each. On my busiest days I had 15 or 16 sessions open in parallel, and worked an estimated 14 to 16 hours.
And sometimes I worry about something bigger. Half joking, I keep telling people: "We're going to become absolutely dumb, stupid people." Starting with me. When you stop thinking things through because a machine will do it for you, the thinking muscle doesn't stay the same.
The research is starting to back up my joke:
- We remember less of what we make. In MIT's "Your Brain on ChatGPT" study, people writing essays with ChatGPT showed the weakest brain connectivity of all groups. 83% of them couldn't quote a single sentence from the essay they had just written. In the group writing on their own, it was 11%.
- We learn less while we build. In a randomized trial run by Anthropic, developers learning a new library with AI scored 17% lower on a comprehension quiz than those coding by hand, about two letter grades, without being significantly faster. The biggest gap was on debugging.
- We think less critically when we trust the tool. A Carnegie Mellon and Microsoft survey of 319 knowledge workers found that the more people trusted AI, the less critical thinking they applied to its output.
- We give up sooner when it's gone. A 2026 study from Carnegie Mellon, MIT, Oxford and UCLA found that people who got used to AI help were more likely to give up on problems, and performed worse, once it was taken away.
And IQ scores were already slipping before any of this. A Northwestern study of nearly 400,000 Americans found that verbal reasoning, matrix reasoning and number series scores declined between 2006 and 2018.
To be fair, none of this proves AI makes us dumb. Most of these studies are small, short, and measure narrow tasks. But they all point the same way: the thinking you hand over is thinking you stop practicing. Nobody knows yet how far that goes, and it scares me. The good news: the same Anthropic study found a way out. Developers who used AI to ask questions and understand, not just to generate code, kept their skills.
Someone recently asked me when I last lost track of time while building something. I couldn't remember. For someone who learned to code at twelve and spent nights building things for the pure joy of it, that answer hit hard.
The illusion of easy
From the outside, it now looks 100% easy. Someone in ops or admin builds an app on Lovable in two days, so the conclusion follows naturally: developers should be working at five times their old speed.
It's very hard to argue with. A demo is visible; everything behind a real product isn't. And every explanation sounds like an excuse.
But as a developer, you know what's going on behind the screen. You refine, again and again. You go through thousands of prompts. You dispatch dozens of reviewer agents to hunt for blind spots, check that the feature will scale, and make sure it lands on the right server, the right pod, with the right permissions. And you make sure it's secure: customer data stays where it belongs, nobody sees what they shouldn't, and no clever request can open a door you didn't know existed.
That work didn't disappear with AI. It just became invisible. A prototype in two days and a product people can rely on for years are not the same thing, and the gap between them is exactly where engineers live.
We lived this recently. A colleague built a first draft of a new hiring platform on Lovable, and as a draft it was genuinely impressive. Then the real questions arrived.
Can we trust the code? Will it scale to a million applicants? How do we secure ID documents? What will storage cost? How do we migrate everyone already in the old system? A few days later, we decided to move it out of Lovable.
Not because the draft was bad, but because a product is more than a draft.
Knowing all this doesn't protect me. I feel the illusion of easy every day. Sometimes it's exciting, and sometimes it just fries my brain.
It starts with an idea for a feature. You think the LLM is going to make it great, so you don't really think it through yourself.
You prompt, then prompt again, and again. Eight hours later, you're not sure what you're building anymore. This happens to me several times recently.
And I'm not alone in misjudging it. In a 2025 METR study, experienced open-source developers were 19% slower with AI tools on their own projects, yet afterwards they believed they had been 20% faster.
My own history shows it plainly. One feature started as a brainstorm from a slide deck: nearly 300 prompts in one brainstorm session, then straight into a production module, with no separate spec step in between. Over five weeks it collected almost two fixes for every feature, and the rule at its core was redefined three times.
It's hard to prevent, because everything around us pushes the same way: go faster, be better. If I used to ship ten times faster than an average experienced developer, the unspoken expectation, from others and from myself, is that I should now be at a hundred times.
It's almost an ego thing. And when you look at it closely, it doesn't make much sense.
And I have to be honest: I'm part of that pressure too. As a co-founder, I'm also one of the people asking our teams to go faster, to do more with AI, to ship this week instead of next month. And it's not just me. Around the leadership table, most of my fellow founders and directors aren't engineers. From where they sit, the demos look like magic, so the question comes naturally, sometimes implicit, sometimes explicit, every time we talk about product and the roadmap: why didn't we ship the whole Q1 roadmap in two weeks? It's a fair question from the outside. It's just a very hard one to answer from the inside. I'm writing this as someone who feels the pressure and creates it at the same time.
Fast, but toward what?
Speed was supposed to free us. Sometimes it traps us instead. When building is almost free, we build everything, and we stop asking whether it should exist.
The long game suffers first. Features pile up faster than anyone can understand them. Code gets written that nobody truly owns, and maintenance becomes someone else's problem, usually future me.
Then quality quietly slips. "It works in the demo" becomes the bar. Craft, the part where you sweat the details because you care, gets skipped because the next feature is already one prompt away.
I relearned this the hard way this year. A new version of our agents' extension ran smoothly for months with more than a hundred people using it. Then we tripled the load in a few minutes, and reality turned out to be much harder than the demo.
And finally the purpose blurs. I started building to make things people loved. Somewhere along the way, the goal became shipping more.
Some days, after a full day of agents and diffs, I wonder if I wasted my time. Not because nothing got done, but because I'm not sure any of it mattered. That's the scary part: AI is amazing, and it's also very good at making you feel busy.
Some engineers are leaving software altogether. They say it's not the same job anymore, not the one they dreamed of and worked so hard for, and they're turning to manual work instead: woodworking, cooking, building with their hands.
Honestly, I couldn't understand them more. When your craft becomes supervision, wanting to feel something real take shape under your hands isn't running away. It's looking for exactly what drew you to building to begin with.
What I think is really happening
I don't think this is only my story. Two things are shifting for everyone who builds.
First, the edge is moving from execution to judgment. Typing speed and syntax are cheap now. What still matters is knowing what should exist, how the pieces fit, and what to throw away. The architecture I carried in my head is still the hard part. It just no longer looks like magic from the outside.
Earlier this year, I told my team that AI can understand you, but it can't do magic and guess what you meant. That still holds. The magic didn't move into the machine. It moved into knowing what to ask for.
Second, flow is disappearing. Making things by hand had a rhythm that absorbed you. Supervising agents is constant context switching, at a pace no human used to sustain.
Underneath both is one simple fact.
The cost of building has collapsed, but the cost of caring hasn't.
Deciding what matters, holding a quality bar, and thinking in years instead of sprints still take time, attention and taste.
The flip side is beautiful, though. A teenager today can build alone what used to take a whole team years. That's the world I would have wanted, as long as we don't forget why we build.
What I want to try
I don't have this figured out. But I want to take my own feelings seriously instead of just pushing through them.
The same summary also holds the counter-example. The cleanest stretch of the last three months was a small tool that went from discovery to deployed in four days. It was split into small numbered tickets, with one focused session each. Small, scoped, intentional: that's how I want to work more often.
So here's what I want to try:
- Design before I prompt. Sketch the architecture myself before involving an agent, and sometimes write the core of a feature by hand. Not for speed, but for authorship.
- Slow down. Fewer parallel threads, more depth. Sheer volume can quietly become a treadmill where speed is the goal instead of the thing you're building.
- Raise the bar on what deserves to exist. Fewer features, built to last, that I fully understand. Before asking "can I build this?", ask "should this exist, and will I still be proud of it in a year?"
- Build something just for joy. No business stakes. Not to be productive, but to remember what it feels like to love what you're making.
Nostalgia as a compass?
Nostalgia is a weird feeling. I used to think it was about missing the past. Now I think it points at something missing in the present.
I've come to think that what I'm feeling is a kind of grief. Part of my identity was built on a specific edge, seeing the whole system and turning it into a real product before anyone else, and that edge feels like it has been taken away by something bigger than me.
Naming it that way helps. Grief is not ego, and it's not a verdict on my worth. It's what happens when something that made you feel valuable disappears, and it deserves to be acknowledged before you can move on.
I don't miss the slow builds or the servers crashing at midnight. I miss being absorbed, curious, and proud of something I made with care. That kid who fell in love with building is a big part of why I'm an entrepreneur today, and I don't want AI to make me forget him.
None of this makes me want less AI. I'll keep using it every day, and it still amazes me. I just want to use it in a way that keeps me thinking, and keeps me proud of what I build.
The cards have been reshuffled for all of us. Maybe the question is no longer how fast we can build, but whether what we build will still matter in a year, and whether we still feel anything while building it. If you're a builder and you feel the same, I'd love to hear from you.
About the author
- Obsessed with turning complex operational chaos into scalable systems. At Onepilot, our AI-native platform and a network of 2,000+ independent freelancers run customer support for 300+ brands, handling millions of interactions a month, including the complex, multi-turn workflows traditional BPOs can't touch. Self-taught since age 12. Forbes 30 Under 30. 🚀 Scaling to $35M ARR and beyond. 🛠️ Building the future of automated business infrastructure.
Comments
Join the discussionThank you for formulating what we all feel ! I quite strongly agree with most of this and want to share another word of hope. It ties directly into "the edge is moving from execution to judgment". Judgement may be less visible, but good, rational, judgement can still look like magic from the outside ! Human hardware is pretty terrible at this, piling bias higher than we can look, but that also means that correct decision making can look quite counter-intuitive and sorcerous. See this as an opportunity to reclaim another magic; one that is, at least in my opinion, even more valuable.
Very interesting, thanks for the insight!
"The hard part didn't disappear, it became invisible" is the line that sticks. The agent ships the plumbing faster than anyone can rebuild the map of the architecture you used to carry in your head. Does scoping and writing the spec before prompting bring some of that map back for you, or does it still feel borrowed?
A little, yes. Writing the spec first makes the model far more efficient, since it’s guided instead of freelancing. Also it’s often even better than me at drafting the spec and the architecture too, which leaves less for me to think through. Maybe the answer is to challenge its choices more, instead of just approving them
Your own three-month summary holds the answer you land on: the 300-prompt brainstorm that went straight into production with no spec step (two fixes per feature, the core rule redefined three times) against the small tool that went from discovery to deployed in four days because it was scoped first. The fatigue mostly comes from deciding by approving diffs, one at a time, all day. We built Halfcycle around that: the deciding happens first, one question at a time with you, inside Claude Code or OpenAI Codex, and the agents build from those answers, so less of your day is approving things you won't remember. Worth trying npx halfcycle on the next feature you'd otherwise brainstorm for 300 prompts. Of the three times that rule was redefined, how many could a question asked before the build have caught?



