We Built Companies Around the Cost of Building

For most of the history of software, making things was expensive. That scarcity didn’t just affect how we built products. It shaped the company itself: roadmaps, prioritization, headcount, product management, design and engineering roles, approval processes, and ultimately who got to turn an idea into something real.

AI is removing that constraint incredibly quickly, and we’re nowhere near the bottom yet. This isn’t really an article about AI making developers more productive. That feels small and obvious. The bigger question is what happens to companies, products, and the people who make them when the scarcity they were organized around starts to disappear.

That doesn’t mean companies stop making decisions. It means a lot more of those decisions happen after the thing has been built.

The cost was real

Look at how software used to get made and the whole thing feels almost impossible from here. Huge teams, enormous specifications, specialized machines, long testing cycles, physical media. I don’t pretend to understand half of what’s going on in some of these old photographs. That’s almost the point. Making software was expensive. Changing it was expensive. Being wrong was really expensive.

A lot of the process we inherited made sense for the world it came from. When building something took months or years, and finding out you were wrong could send you back to the beginning, of course you planned the shit out of it. The process wasn’t necessarily the problem. The cost of being wrong was.

The order we built around

For most of my career, the process looked roughly like this:

1. Idea
2. research
3. explain
4. debate
5. prioritize
6. approve
7. build
8. test
9. iterate
10. launch
11. iterate

Eleven steps, and that’s the short version. I left out the reorg in the middle, the offsite where we re-prioritized the priorities, and the two weeks waiting for someone to get back from vacation. Everyone’s version was a little different. Nobody’s was short.

Before you spent the expensive resources, you tried to decide whether the idea deserved them. So we got good at deciding. We made roadmaps, wrote specs, estimated things, had design reviews, argued about priorities, made business cases and asked for headcount. There were always more ideas than people who could make them, so somebody had to decide which ideas got the people.

That scarcity did something useful: it killed ideas.

If there were twenty ideas and enough people to build three, seventeen were going to die. Probably a few good ones. Definitely a lot of bad ones. We called that prioritization. Underneath it was scarcity.

And scarcity shaped the company. Product decided what should be built. Design figured out how it should work. Engineering made it real. Management allocated the people who could do those things. It was never quite that clean, but access to builders was access to power. Want your idea to exist? Get it on the roadmap. Convince the PM. Get engineering resources. Make the case. Wait your turn.

That made sense when building was expensive. What happens when it isn’t?

The order is changing

This didn’t start with AI. Every time the feedback loop got cheaper, the way we worked changed with it. Prototyping got faster. Interfaces could be changed while you were looking at them. Spreadsheets let people who weren’t programmers make little pieces of software for themselves. The web made publishing almost free. Each time, some amount of planning got replaced by trying.

AI takes that much, much further.

Not every part of software is getting cheap at the same rate. Running something safely and reliably can still be expensive. But making enough of it to find out whether the idea works is getting astonishingly cheap.

1. Idea
2. build
3. learn
4. decide

Eventually it might simply be:

1. Need
2. software

That sounds ridiculous until you look at how quickly this stuff is moving. Today you still open an AI coding tool, explain what you want, watch it work, fix things, test it and go around a few more times. There’s enough friction that it still feels like building software. That won’t last.

I have no idea exactly what these tools will be capable of a few years from now. I’m not sure anyone does. But we all know they’ll be dramatically better, faster and cheaper than what we have today. The amount one person can make will keep going up, and the distance between having an idea and having working software will keep getting smaller. At some point, making software may not feel like making software at all. You’ll need something, describe it, and there it is. Maybe it lasts a year. Maybe an hour. Maybe you never even think of it as software.

We wrote every line of code. Then we reviewed code we didn’t write. Then we described what we wanted and stopped reading it at all. Each of those was a step closer to the idea and a step further from the work.

I can’t really imagine what happens when that becomes normal. Which is kind of the point.

Build before permission

We’re already seeing people build things that would have required a small team not long ago. Designers are making working software themselves. Product people can come into a meeting with the thing instead of a deck about the thing. Engineers can try five approaches instead of spending a week arguing about which one deserves to get built.

“I think this might work” is one kind of conversation. “Here, try it” is another. A lot of hypothetical conversation disappears when everyone can touch the thing we’re supposedly debating.

Case in point: this stupid little tool. It answers exactly one question — what should a shadow look like? The web already has a hundred of these. I made another one anyway, just for this post. Two minutes, maybe 74 cents, zero meetings.

So build it first. Not production. Not connected to customer accounts. Not running the bank. Use some judgment. But if we can answer a question by making something in three hours, spending three weeks debating whether we should make it is insane.

The important thing about AI isn’t that it writes code faster. It’s that the cost of finding out whether an idea is any good is collapsing. A lot of product development process is about to look insane.

Software becomes disposable

We’ve always treated software as something that should last. You build it, launch it, maintain it, add features, migrate it, support it and eventually have a meeting about whether anyone is brave enough to kill it. But if making software becomes cheap enough, why should all of it last?

Maybe someone makes a tool for twelve people on Monday, it solves a problem for six weeks, and then it disappears. Maybe an agent makes something for one task and nobody ever uses it again. Maybe interfaces themselves become temporary, assembled around whatever someone is trying to do right now. Make it. Use it. Throw it away. That sounds wasteful by the old rules. By the new ones it might be completely normal.

We’ve spent most of the history of computing treating software as an asset, something expensive enough to make that you naturally wanted to keep it. Cheap creation changes that. It doesn’t make everything else cheap. Security still matters. Customer data still matters. Reliability matters. Maintenance definitely matters. Somebody still has to answer when the thing everyone depends on stops working.

Making something and committing to it are not the same decision.

Abundance

Photography is probably the easiest analogy. Film made every exposure cost something, so you thought before you pressed the shutter. You had 24 or 36 shots. You probably didn’t take fourteen nearly identical photographs of your lunch. Then digital photography made the marginal cost of another photograph basically zero.

We didn’t start taking 20% more photographs. We started taking pictures of everything. Our dogs. Our dogs again, slightly to the left. Our food. The parking spot so we remember where the car is. Twelve versions of the same sunset, all kept. Something at Home Depot we told ourselves we’d need.

The second world is obviously better. More people can make photographs. We capture things we never would have captured before and experiment without worrying about wasting film. We also created an absolutely staggering number of photographs nobody will ever look at again.

Software may be heading for the same kind of abundance. When the cost of making something collapses, you don’t just get the same amount of stuff made faster. You get vastly more stuff. And we’re nowhere close to understanding how much more.

Then comes the mess

This could genuinely be a golden age of making. Millions of people who could never turn their ideas into software suddenly can. Strange little ideas get tried. Tiny markets become viable. Individuals get extraordinary leverage. People closest to a problem stop waiting for someone else to solve it.

Now imagine everybody doing it.

The problem won’t necessarily be bad software. Bad software is easy. Nobody uses it and it disappears. The dangerous stuff is pretty good software. Someone makes a little tool on Tuesday. Seven people use it. Someone hooks it into something else. Someone adds a feature. Seven users become seventy. A year later 400 people depend on it and nobody is entirely sure who owns it.

We already do this with spreadsheets. Every company has some version of FINAL_FINAL_v7.xlsx, created by Susan, who left four years ago, that apparently controls a meaningful percentage of the business. Now imagine everybody can make software that easily. And then imagine the machines can too.

We could drown in pretty good software: software that was cheap enough to make, useful enough to survive, and not important enough for anyone to properly own. The old constraint killed a lot of this stuff before it existed. That constraint is going away. We’re going to need another one.

Permanence should be expensive

I don’t think the answer is more approval. In fact, companies that respond to AI by wrapping creation in more process are going to get smoked by companies that don’t. Making someone write a spec, get three approvals and wait for the next planning cycle before spending an afternoon testing an idea makes no sense when the experiment itself is cheaper than the meeting.

Let people make things. Let teams try stupid ideas. Let agents make things. Most of it should probably disappear. But get much more serious about what survives.

Maybe the new gate happens later. Let almost anything get made. Be much more selective about what gets adopted, connected to important systems, shown to customers, maintained, secured and supported forever. A prototype becoming infrastructure should be a decision. An experiment becoming part of the product should be a decision. Something getting access to customer data should definitely be a decision.

Creation should become almost free. Permanence should remain expensive.

That puts the gate somewhere else. We used to gather as much evidence as we could before deciding what deserved to be built. Now the thing itself can become part of the evidence. We still have to use judgment, but we’re judging something people can actually try.

What happens to us?

There’s an uncomfortable question here for designers and engineers. If almost anyone can make the artifact, what exactly are we for?

Designers and engineers still matter, but producing the artifact is becoming a smaller part of their value. As more people become capable of making the thing, the advantage moves elsewhere.

Taste matters. Judgment matters. Knowing which problem is worth solving matters. Knowing when something is good enough to teach you something and when it isn’t. Seeing the one strange idea in fifty attempts that’s actually new. Knowing what deserves another afternoon and what deserves the next three years.

Engineering changes too. Generating code is getting cheap. Knowing what belongs in a permanent system, what needs to scale, what can fail, what needs to be secure, what should be rewritten and what should simply disappear is not.

AI isn’t making expertise disappear, I think it’s exposing which parts of expertise were really just scarcity.

The calm before the storm

Right now this still mostly looks like faster software development: smaller teams, weekend apps, designers writing code, engineers making nicer interfaces, lots and lots of demos.

I think we’re going to look back and laugh at how small we thought this was. When digital cameras showed up, people used them like film cameras. Same pictures, they just stopped paying to develop them. Nobody was photographing their parking spot yet. That’s about where software is. Faster development is the same pictures without the developing costs. The parking-spot phase hasn’t started.

That changes who makes things, what a product is, how long software lives, how companies allocate resources, and what design and engineering are worth. It probably changes what a software company even is. I don’t know exactly what that world looks like. Nobody does. But this feels like a golden age of making and the calm before a storm at the same time.

For most of my career, the question was: is this worth building? Soon that question may barely matter. We’ll build it and find out.

The harder question comes after:

What deserves to last?