Let me paint you a picture.
It’s a Tuesday morning. I’ve just spent the entire weekend—and I mean the entire weekend—learning how to set up MCP servers. I’ve read the docs. I’ve watched the videos. I’ve broken things, fixed things, broken them again in new and exciting ways, and finally—finally—got everything humming along like a well-oiled machine.
I lean back in my chair. Sip my coffee. Feel that warm glow of competence that comes from genuinely understanding something complex.
Then I open X.
“Introducing Claude Agents: MCP servers are now just one small piece of a much bigger puzzle.”
I stare at the screen. My coffee goes cold. Somewhere in the distance, a floppy disk weeps.
⚡ Welcome to the Treadmill
If you’re building anything with AI right now, you already know what I’m about to say: the ground moves faster than your feet.
I don’t mean things are evolving quickly. I mean they’re evolving at a pace that makes Moore’s Law look like a leisurely stroll through the countryside. In the ’80s, we had the same Commodore 64 for years. The 6502 processor didn’t suddenly wake up one morning and decide it was now a RISC architecture. The SID chip didn’t release a patch note saying “we’ve deprecated all your sound routines, please rewrite everything by Thursday.”
But AI in 2025? It’s like someone strapped a rocket to a hamster wheel and told you to keep running.
Here’s roughly how my last few months have gone:
Month 1: “I’ll use ChatGPT to help me code. This is incredible. I’m 10x more productive.”
Month 2: “Actually, Claude is better for my workflow. Let me switch everything over and learn a whole new set of prompting techniques.”
Month 3: “Wait—MCP servers? I can connect my AI to my actual codebase and tools? This changes everything. Let me spend two weeks setting this up.”
Month 4: “Claude Agents are here. They can autonomously plan, execute, and iterate. MCP was just the appetiser.”
Month 5: “Hold on—now there are multi-agent coding teams? Multiple AI agents collaborating on different parts of my app simultaneously? What even is this?”
Month 6: stares at wall, questioning all life choices
Each time—and I cannot stress this enough—each time I thought I’d found my footing. Each time I’d invested real hours learning, configuring, and integrating. And each time, the announcement of the next evolution made my carefully constructed setup feel like I’d brought a typewriter to a quantum computing conference.
🏃 The FOMO Is Real
Here’s what nobody tells you about the AI revolution: the psychological toll of perpetual obsolescence.
Back in the C64 days, being “behind” meant you hadn’t read the latest issue of Zzap!64 magazine. The knowledge gap was maybe a month. You could catch up over a weekend with a cup of tea and a floppy disk swap meet.
Now? Being “behind” means you missed an announcement that dropped at 3am, got 47,000 retweets by breakfast, and by lunch there are already twelve YouTube tutorials explaining why everything you learned last week is “the old way.”
The FOMO is relentless. Every morning I’d wake up, check my feeds, and feel that little twist of anxiety: What did I miss? What’s changed? Is my stack still relevant, or did it age like milk overnight?
And the worst part? The people announcing these things are genuinely excited—as they should be. The progress is extraordinary. But when you’re the person mid-build, elbow-deep in implementation, hearing “everything just changed again” is like being told the rules of chess have been updated while you’re mid-game.
“Oh, by the way, knights can fly now and pawns have been replaced with something called quantum bishops. Good luck.”
🐇 Down the Rabbit Hole
The real danger isn’t the tools changing—it’s what it does to your behaviour.
I became a professional learner instead of a professional builder. My days started looking like this:
- 7:00am — Coffee. Check AI news.
- 7:15am — “Ooh, new framework. Let me read about it.”
- 8:30am — “This looks incredible. Let me try a quick prototype.”
- 11:00am — “Quick prototype” is now a full setup with dependencies and config files.
- 1:00pm — Lunch. Check AI news again. Another release.
- 1:30pm — “Maybe I should switch to this instead…”
- 4:00pm — I have built nothing. I have learned everything. I am exhausted.
- 5:00pm — My app is exactly where it was yesterday. And the day before. And the week before.
Sound familiar?
I was doing the tech equivalent of rearranging the furniture instead of building the house. Every new tool was a chance to optimise, to upgrade, to do things “the right way”—which, of course, would be “the wrong way” by next Tuesday.
📼 The C64 Didn’t Have This Problem
You know what was great about 1985? Constraints.
We had 64KB of RAM. One language that mattered (6502 assembly, thank you very much). One way to draw sprites. One way to make sound. The limitations weren’t frustrating—they were liberating. You didn’t waste time choosing between frameworks because there was nothing to choose. You just sat down and wrote code.
There was no “should I use React or Svelte for my C64 game?” There was no “is this the best state management solution for my sprite engine?” There was a blinking cursor, a keyboard that clacked like a typewriter, and the certain knowledge that whatever you built would run on this machine, with these specs, forever.
The paradox of modern development is that infinite choice creates infinite paralysis. When you can do anything, you spend all your time deciding what to do instead of actually doing it.
And AI has turbocharged this problem by making the options not just numerous but constantly changing. It’s like standing in a sweet shop where new shelves appear every five minutes and the shopkeeper keeps shouting “YOU HAVEN’T TRIED THIS ONE YET!”
🤔 A Moment of Clarity (Sort Of)
I was knee-deep in migrating my setup to the latest agent framework—my third migration in as many months—when my coding partner said something that hit me like a brick:
“Mate, have you actually written any app code this week? Or have you just been setting up tools to write app code?”
I opened my mouth to argue.
Closed it.
Opened it again.
Closed it.
He was right. I’d spent the week building the world’s most sophisticated development environment for an app that still didn’t have a login screen.
It was like buying a professional kitchen, installing every gadget, calibrating every thermometer—and then ordering takeaway for dinner because I’d run out of time to actually cook.
👀 Coming Up Next
That conversation was the turning point. The moment I realised that the AI treadmill wasn’t making me faster—it was making me busy. There’s a difference, and it took an embarrassingly long time to see it.
In the next post, I’m going to talk about shiny object syndrome—what it really is, why it’s the silent killer of side projects, and how I finally forced myself to stop chasing the latest thing and just build the damn app.
Spoiler: it involved a rule so simple it’s almost stupid. And it worked.
Next up: Shiny Object Syndrome: How I Stopped Chasing and Started Shipping.