The day I started believing — David Poblador i Garcia
davidpoblador.com:~/blog<br>/the-day-i-started-believing$<br>ca<br>sv<br>es
David Poblador i Garcia<br>Senior Technologist, Advisor
Founder at All Tuner Labs
~/
·<br>~/blog
·<br>~/projects
·<br>~/cv
·<br>~/appearances
David Poblador i Garcia<br>Senior Technologist, Advisor
Founder at All Tuner Labs
// navigation
~/
~/blog
~/projects
~/cv
~/appearances
// newsletter
[email protected]
// connect
follow on telegram
{const s=this.nextElementSibling;s.classList.remove('opacity-0');setTimeout(()=>s.classList.add('opacity-0'),1500)})" title="Copy RSS feed URL" aria-label="Copy RSS feed URL" class="text-neutral-400 dark:text-neutral-500 hover:text-accent transition-colors cursor-pointer"><br>copied!
// elsewhere
poblador.cat
poblador.se
es.davidpoblador.com
2048 enllà
Entre Dev y Ops
All Tuner Labs
// chat
Working through something? Grab a slot.
book a chat
Jun 19, 2026
The day I started believing
I'd boxed AI coding assistants in as a great autocomplete that would plateau, convinced senior engineers like me would spend years cleaning up after them. Then Claude Opus 4.5 reverse-engineered my way off a locked ISP router, software-only, the kind of work others had only managed by soldering hardware or exploiting dead firmware, and rebuilt it in an hour when my ISP broke it. On an already-old model. This is the day I stopped seeing these tools as a time-saver and started seeing them as the future.
I’ve used AI coding assistants since the first day they were genuinely worth using, and not as a curiosity or for the demo. I’ve used them daily, on real work, on systems other people depend on.
For a long time I was fairly sure I knew exactly what they were. They were a very good autocomplete, a tireless junior who never quite reads the style guide, a way to skip the boring parts of the job. Useful, occasionally astonishing, but bounded. I had a tidy mental model of where the ceiling sat, and I was comfortable working inside it.
That model is gone now, and what follows is the story of the day it finally broke.
The boilerplate years
Late last summer, around August and September, I fell in love with how much sheer tedium these tools could erase. Claude Code had gone generally available in May, OpenAI’s Codex had landed around the same time, Claude Opus 4.1 arrived in August, and then Sonnet 4.5 in September, billed as “the best coding model in the world.” Suddenly the scaffolding of a project, the wiring, the glue, the fortieth CRUD endpoint that looks exactly like the other thirty-nine, all of it could be generated faster than I could type the imports.
It was wonderful, and it saved me real hours. But the hours it saved were hours on work I already knew how to do, and that distinction turns out to matter more than it sounds. Boilerplate is, almost by definition, the stuff that’s already a solved problem in your head, so watching a machine produce it quickly is a relief rather than a revelation. I was delighted and unmoved at the same time.
What I actually believed
Underneath the delight I was holding on to a thesis, and it was a skeptical one. I believed these models were fragile in two specific ways.
The first was context. They forgot things: they lost the thread on anything large, drifted halfway through a refactor, and contradicted decisions they’d made twenty minutes earlier. Simon Willison was already busy naming the failure modes, context rot and context engineering, the whole emerging discipline of keeping the window honest, and to me all of that read as a hard ceiling on anything that didn’t fit inside one tidy head.
The second was conventions. If you didn’t invest serious time up front spelling out how you build things, the model would invent its own conventions, every single time, fresh ones in every session, cheerfully inconsistent with the last. Without a heavy scaffolding of instructions you ended up with a codebase that argued with itself.
So I drew what felt like the obvious conclusion, which was that we were plateauing. Plenty of people were saying the same thing. The tools would stay genuinely useful for small, well-modularized, well-behaved projects, and they’d flounder on anything big, gnarly, or load-bearing. The interesting work, the architecture and the judgment and the hard-won scars, would stay ours.
And here’s the slightly smug part I’m not proud of: I quietly decided this was job security. I figured those of us with decades of systems behind us were safe precisely because of all this. The future I pictured was a long career spent cleaning up after the machines, retrofitting taste into convention-less code and bolting real architecture onto things that had been generated without any. Twenty-five years of hard-won battles, monetized forever as cleanup duty. It was a comfortable theory, and it was also completely wrong.
November
The...