Code Is Not Cheap

If you’ve spent years learning to build software and you’ve started to quietly wonder whether any of it still counts, this is for you — and I think the honest answer is the reassuring one. The fundamentals matter now more than they ever have. Not the syntax, not the framework of the month: the judgment. The hard-won sense of why codebases rot, why architecture is a daily investment, why a shared language stops you from repeating yourself. That equity — the part you built before AI showed up — is exactly what lets you steer AI instead of being dragged along by it.

I want to make that case across a short series, and I want the first piece of evidence to be the thing you’re already looking at. This blog — Astro static output, React islands, a real Azure deploy pipeline — was just rebuilt and shipped fast, with heavy AI help. That’s the part everyone expects now. The part they don’t: it went fast because I could say where every piece goes and where the boundaries belong.

That confidence isn’t originally mine. The sharpest version I know comes from Matt Pocock, in a talk on building with AI. There’s a popular idea that AI makes code cheap — so cheap you stop reading it and just regenerate it. His answer:

Code is not cheap. In fact, bad code is the most expensive it’s ever been.

And the reason is mechanical, not sentimental. AI in a good codebase does really well — it compounds. In a bad one it stalls, and every regeneration leaves you with more code that makes the next change harder. So a messy codebase doesn’t merely slow you down; it caps how much of AI’s upside you can capture at all. Which turns the usual conclusion inside out: the better AI gets, the more your fundamentals are worth.

Here’s the honest version, because the honesty is the whole point. I didn’t walk in knowing this stack cold — I know React well, but Astro I’d only met in passing; I genuinely didn’t know it could compile an entire site down to static HTML with no server behind it. What I did know was the shape of the problem: what a deploy pipeline should do, why a deploy token has no business in a checked-in variable group, the difference between a React island that needs to hydrate and a page that should stay static, where the seams between content, layout, and rendering belong. None of that is Astro knowledge — it’s older than Astro, and it’s what let me direct the AI through a framework I was still learning, instead of the framework, and the AI, directing me.

It helps to be precise about the division of labor, and here I’ll borrow Pocock’s framing one more time. Think of the AI as a superb tactical programmer — a sergeant on the ground, making the actual changes, fast and tireless. What it lacks is the view from above: what the system should become, and which trade-offs you’ll regret in six months. That strategic view is yours.

And it isn’t abstract — you earned it somewhere demanding. If you’ve done front-end for any length of time, you’ve inherited one of those React codebases: components nested ten layers deep, props drilled through every floor, state smeared everywhere, where touching one thing quietly breaks three others you can’t see. Every front-end dev has worked in one. That experience is knowledge — you know in your body what bad structure costs, and no amount of prompting installs that overnight. It’s the sweat you banked before AI arrived, and it’s exactly what lets you steer the sergeant away from building you another tangle. That’s the moat.

But a moat is only leverage if you don’t have to stand on the wall and defend it by hand every single time — and that, more than anything, is what this series is about.

So that’s the premise; the rest of the series is the evidence — and here’s the part I nearly left out, even though it’s the foundation. Every post follows the same four-part shape: a failure mode I hit with AI → the old-software fundamental that resolves it → the skill that encodes that fundamental → the real artifact it produced. The skill is the spine. On its own, judgment is just you re-explaining yourself every session; a skill is a few lines of instruction that hand that judgment to the AI to apply on its own, every time. That’s the move that turns “I know what good looks like” into “the AI does what good looks like” — how sweat equity stops being something you spend and starts compounding.

The fundamentals underneath are the durable, unglamorous ones — a shared design concept, a ubiquitous language, deep modules with simple interfaces — and the artifacts are real: this blog, and tinkforge, browser-based PDF tools I’m building where the file never leaves your device.

Part 2 is the first instance, and where I’d start: the failure where the AI confidently builds something other than what you had in your head. The fundamental predates AI by decades — reach a shared understanding before you write code, the thing Fred Brooks named the “design concept.” The skill is grill me — interview me relentlessly about this plan until we reach a shared understanding — and the artifact is almost too on-the-nose: this very post began as one of those grilling sessions, an interview that became a plan and then the issues I built from.

There’s one older post here that doesn’t belong in the new stream: a 2022 piece on TypeScript and Blazor, from before any of this. I didn’t delete it — I moved it to the Archives, because it’s a small artifact of exactly the equity this series is about. It was written the slow way, by hand, and that’s the work that compounds into judgment.

So if you’ve been worried your experience is quietly depreciating, I think the opposite is true: it’s the most valuable thing you bring to this. Code is not cheap — and neither is the judgment that tells good code from bad. Next time: the first failure mode, and the small skill that turns judgment into something the AI can run for you.

The spark for this series is Matt Pocock’s work — his conference talk on building with AI, his open-source skills, and his writing at aihero.dev. Credit where it’s due.

╲│╱═▦ Cheena Vala — the Chinese fishing nets of Fort Kochi, Kerala. Teak-and-bamboo rigs introduced in the 1400s, still worked by hand at every tide.