Most Code Should Be IKEA

Coding will become a lost art, like traditional craftsmanship.

I don't mean this as doom and gloom. I mean it literally: hand-writing code is becoming what hand-carving furniture once was. Beautiful, respected, the pinnacle of a certain kind of skill. And increasingly, not the way most things get made.

The craftsman's arc

Master craftsmen used to spend decades perfecting their trade. A furniture maker would apprentice for years learning to cut dovetail joints by hand. A blacksmith would forge thousands of blades before achieving consistency. The work was slow, painstaking, and the results were works of art.

Then came machines. Factories. Assembly lines.

Suddenly, you didn't need a lifetime of mastery to produce functional, affordable goods. A factory worker with a few weeks of training could operate a machine that cut perfect joints every time. The handmade stuff was still better in many ways - more durable, more beautiful, more personal. But for most purposes? The machine-made version was good enough. Often more than good enough.

Scale, speed, and accessibility trumped perfection for most applications. Master craftsmen didn't disappear, but they became specialists. Artisans. Their work shifted from "the only way to make things" to "a premium option for those who value it."

The same thing is happening to code

Hand-crafting elegant, optimized, beautifully architected code has long been the mark of a great engineer. We take pride in clean abstractions, efficient algorithms, and code that reads like prose. Code review isn't just about catching bugs - it's about maintaining craft standards.

And in some domains, this still matters deeply. Aerospace software. Medical devices. Safety-critical systems. Financial trading engines. When milliseconds count or lives are at stake, you want engineers who've spent decades understanding every edge case.

But for most software? AI generates it faster than humans type.

You've seen it yourself. Describe a feature in plain English, and AI produces working code in seconds. Code that follows patterns you'd have to look up. Code that's often cleaner than a rushed first draft, because it's seen millions of examples of how this particular problem gets solved.

Hand-writing volumes of code with meticulous care? It's becoming less important. Not worthless - there's still value in understanding what the AI produces. But no longer the main differentiator.

Where the bottlenecks moved

If generating code is cheap, what becomes expensive?

Understanding requirements. Before you can tell an AI what to build, you have to actually know what to build. Talking to users, understanding their problems, translating vague desires into concrete specifications - this is still deeply human work.

Verification. AI generates code fast, but is it correct? Does it handle edge cases? Is it secure? The gap between "code that runs" and "code you can trust" requires careful review. AI can help spot issues, but someone has to know what questions to ask and when to be skeptical.

Iteration speed. The winner isn't who writes the most beautiful code. It's who ships something users want, learns from their feedback, and iterates fastest. AI dramatically accelerates the code-writing step, but the thinking, observing, and deciding still take human time. You still have to wait for users to try your product.

Trade-off navigation. Every technical decision involves trade-offs. Speed vs. maintainability. Features vs. complexity. Shipping now vs. getting it right. These judgment calls require understanding the business context, the team's capabilities, the timeline, the stakes. AI can help think through options, but it doesn't have the full picture.

Accountability. When something breaks at 3am, someone has to own it. When a security vulnerability ships, someone answers for it. AI can write the code, but it doesn't take responsibility. The human in the loop isn't just reviewing - they're signing off.

The bottleneck has shifted upstream and downstream. The code in the middle? It's becoming a commodity.

The IKEA analogy

Like master carpenters, great coders will always be respected. There will always be work for people who can hand-tune a kernel, optimize a database query that's costing millions, or build something so novel that no AI has seen anything like it.

But most furniture is IKEA. And honestly? It's fine. It does the job. Most people don't need hand-carved dovetails. They need a bookshelf that holds books.

Most software doesn't need to be a masterpiece. It needs to solve the user's problem. If AI can produce that solution faster and cheaper, that's not a tragedy. It's progress.

The craft isn't dead. It's just not the main thing anymore.

What this means for builders

If you're a developer, this isn't a reason to panic. It's a reason to shift emphasis.

Get better at understanding problems. The highest-value skill is figuring out what to build, not how to build it. Spend more time with users. Develop better intuition for what matters.

Get faster at iteration. If the code is cheap to produce, you can afford to experiment more. Try things. See what works. Throw away what doesn't. The cost of generating code has dropped; take advantage of it.

Get comfortable with AI tools. The developers who thrive will be the ones who treat AI as a power multiplier, not the ones who resist it out of pride in their handcraft.

Keep your craft sharp for when it matters. There will always be moments when deep technical understanding is irreplaceable. You just don't need to flex it on every CRUD endpoint.

The new shape of building

I built Kibbler because I wanted to code from my phone. But the more I use it, the more I realize what I'm actually doing is directing rather than typing.

I describe what I want. I review what the AI produces. I course-correct. I approve or reject. I'm still very much in the loop, still very much responsible for what ships. But the act of translating my intent into syntax? That's increasingly handled for me.

It's a different kind of building. Less like writing code by hand, more like conducting an orchestra. You still need to understand music. You still need to know what good sounds like. But you're not personally playing every instrument.

Some will mourn this transition. I get it. There's something satisfying about the craft, about knowing you personally shaped every line. But there's also something satisfying about shipping faster, building more, spending less time on syntax and more time on substance.

The craft isn't dead. It's evolving. And for most of us, that's more than okay.