Software's Flat-Pack Era

I’ve Always Thought of This as Woodworking

For my entire career, I have thought about building software the same way I think about woodworking.

A woodworker has a shop full of tools. Hand tools, power tools, jigs they built themselves for one specific cut. They know their woods. Soft, hard, the expensive exotics you only break out when the project earns it. They know joinery. When to cut a dovetail, when a mortise and tenon will hold, and when a pocket screw and some glue is honestly all the job needs.

None of that shows up overnight. You read, you plan, you ruin a few boards, and slowly you build the kind of understanding that lets you look at a problem and know how to come at it. That takes years. And nobody is a master of all of it. The person who can hand-cut joinery in their sleep might never have touched a CNC. That was always fine. The effort was the job, and the effort was the moat.

The Tools, the Woods, the Joinery

Software has always looked the same to me.

The tools are the languages and the runtimes. .NET, Python, JavaScript, whatever you reach for. The woods are the platforms. Web, desktop, mobile, embedded, each with its own grain and its own way of splitting on you if you cut it wrong. The joinery is everything that holds it together. How you host it, how you store the data, how the pieces talk to each other.

And like woodworking, nobody masters the whole thing. A backend person who can read a query plan like sheet music can be completely lost in a mobile layout. That was the deal. You picked your corner, you put in the years, and the time it took was exactly what made the skill worth anything.

Then It All Came Flat-Pack

Now, in what feels like the blink of an eye, all of it can be mass produced.

You describe what you want and a machine builds it. Not a snippet. The whole thing. On a good day it comes out like something from IKEA. Clean enough, assembled in an afternoon, does what it says on the box. On a bad day it is the shit that gets pumped out by TEMU. Looks fine in the photo, falls apart the second you put any weight on it.

Either way it is fast, it is cheap, and it gets the job done. That is new, and it is not going back in the box.

Would I Even Bother Learning It Now?

Here is the question I cannot shake. If I were a student today, would I care about data structures? The Gang of Four patterns? Fifth normal form? The OSI model?

I am not sure I would. And I do not fully know how I feel about that. Hold that thought, because I want to come back to it.

My Kids Think Software Just Exists

I can already see where this goes, because I watch it at home.

Very, very few of my kids’ friends understand how a computer actually works. Fewer than that understand what software even is. To them it is not a thing that someone designed and built. It is just there, like the weather. You open the app and it works, the same way you turn the tap and water comes out. Nobody is thinking about the pipes.

And here is the part people miss. This did not start with AI. We have been sanding the craft off the surface for years. Every layer we added to make things easier also put one more wall between the person and the thing underneath. That was mostly a good trade. But every one of those walls made software feel a little more like magic and a little less like something a person made out of parts. AI did not start that fire. It just poured a tanker of gas on it.

I Can Build the Bookshelf. I Also Just Buy One.

Back to the shop for a second.

I can build a bookshelf, some cabinetry or a TV stand. I can also just run to the store, buy the flat-packed version and screw the thing together while watching TV.

Is the store version good? It holds the TV. It holds the books. When it gives out in five years I drag it to the curb and buy another one. And most of the time, even knowing how to do it the right way, buying the box is the correct call. I am not going to hand-cut dovetails for a shelf that lives in the garage. That would be a waste of a life.

This is the part that keeps me from turning into the old man yelling at the machine. Good enough is not the enemy. Most of what we build does not need to be an heirloom. It needs to hold the TV.

A House of Cards, or Does It Matter?

So that is probably the future of most of what we make. Cheap, fast, replaceable, good enough. And maybe that is completely fine.

But I keep snagging on one thing. The only reason this works right now is that the people steering these tools came up the hard way. We can look at what the machine spat out and know, more or less, whether it is any good.

Whether we actually bother to look is a different conversation, and the evidence there is not flattering. METR ran a study where experienced developers using AI tools were measurably slower, by around 19 percent, while being convinced the tools had sped them up. Researchers at Stanford found that people with an AI assistant wrote less secure code and felt more confident it was secure. We are the generation that supposedly knows better, and we are already worse at catching the machine than we think we are.

So what happens when we age out, and everyone coming up has only ever assembled flat-pack? Who is left who can look at the output and actually know? Maybe it holds. Maybe it is a house of cards waiting for a stiff breeze. I honestly do not know. I suppose we will see.

What We Put in Place Now

“We will see” is not the same as “do nothing.” If this is where it is going, there is work worth doing now, while the people who remember how the joints are cut are still in the room.

Start with the fundamentals, since I promised I would come back to it. Fundamentals do not change. Knowing that you need caching, that the platform is going to constrain you, that the shape of your data matters more than almost anything else, that you cannot trust input from outside the door. That stuff is forever. What is not forever is the religion. Memorizing every particularity, having a holy war about tabs versus spaces, treating deep trivia as a personality. That was never really the point, and it is definitely not the point now. Teach the shape of problems. Let the trivia go.

Then change what you treat as the real artifact. If the code is the disposable thing the machine regenerates on command, then the code is not what you own anymore. The description of what it is supposed to do is. Specifications, written down and version controlled, become the thing you protect, and the people who think clearly about this are already moving that way.

Make verifying cheap and automatic, because verifying is the actual job now. Strong types, real test suites, evals, gates in the pipeline. The studies above are the whole argument for it. If a human eyeballing the diff is your safety net, you do not have a safety net. Build guardrails the machine has to pass through, so good enough cannot quietly rot into broken.

Write down the why, not just the what. Right now my generation is the institutional memory, and that is not a plan that survives us. The reasoning behind a thing has to live somewhere a person, or an agent, can actually find it later.

And get serious about being able to see inside what you run. When you are operating something you did not build, observability stops being a nice-to-have. Logs, traces, the ability to open the box when it breaks. Nobody’s mental model of this system is in the room anymore, so the system has to be able to explain itself.

None of this is a guarantee. I do not know if it is enough. But I would rather be the guy who can still cut the joint by hand, standing in a house full of flat-pack, than the guy who never learned and is just hoping the shelves hold. Until we know which way this breaks, that is the bet I am making.