Building Got Cheap. Getting Chosen Got Expensive.

For eight years I lived inside a very simple piece of math. Ctrl+Play had units all over Brazil, and when a franchisee sent me the month’s results, the conversation was always about the same three lines: payroll, rent on the storefront, and whatever was left after those two.

Adam Smith wrote that same math in 1776. In The Wealth of Nations, he breaks the price of any commodity into three parts: wages, for whoever does the work; profit, for whoever risked capital; and rent, for whoever owns a scarce resource, which at the time was land.

An honest aside, because this is precisely the part of Smith that didn’t survive intact: Ricardo, and later Marx, attacked the idea that you can resolve price by adding up incomes. Price forms at the margin, between supply and demand, not by summing costs. I’m using the decomposition here the way it still works well: not as a theory of how price forms, but as a map of where each dollar of revenue ends up.

For most of economic history, producing more meant spending more on all three. More students required more teachers, more classrooms, more square meters in a well-located spot. Growth carried an almost proportional expansion of costs along with it.

AI appears to break that. And that’s where a piece of math begins, one I’ve done enthusiastically myself before looking at it more carefully.

The math that looks too good

Picture a software product built by a single person. AI helps write the code, build the interface, produce the content, answer customers, analyze metrics, run campaigns. Distribution is digital. Once it’s built, serving the next customer costs almost nothing.

At first glance, two of Smith’s three terms have evaporated. There are no wages, because an agent doesn’t get paid. There’s no rent, because the business occupies no physical space at all. So nearly the whole price would turn into profit.

I hear some version of this in almost every conversation about AI today. It’s seductive because the first half is true: you really can do with two people what used to require thirty.

But the math is wrong in both places. And the error is the same in both: the share didn’t disappear. It changed address.

Wages became capital (and came back as a variable cost)

AI didn’t eliminate labor. It turned labor into capital.

The effort you used to buy through payroll is now embedded in models, servers, and automations. Instead of hiring dozens of people, you rent accumulated productive capacity: systems trained on an absurd amount of human knowledge.

And here’s a caveat that usually gets skipped. Wages didn’t evaporate: they were paid upstream, and not always well. There’s human annotation and evaluation work holding these models up, much of it precarious, and there’s the portion of the training material nobody paid for, which is being argued in court right now. “AI doesn’t draw a salary” is only true if you look exclusively at your own payroll.

And there’s a detail that only shows up when the invoice arrives. Classic SaaS had a marginal cost near zero: the thousandth customer cost practically the same as the hundredth. A product with AI in the middle doesn’t have that property. Every request costs money. Cost became variable again, and proportional to usage.

That shifts the structure of the business in a way the 2020 spreadsheet never accounted for. A made-up example, so I’m not using anything from my own work: imagine a tool that resolves support tickets and charges per user per month. The customer who barely touches it pays the same as the customer who throws ten thousand tickets a month into your queue. Under the old logic, the heavy user was the loyal customer. Under the new one, that’s exactly where you might be losing money.

Payroll didn’t vanish. It became an infrastructure line, and that line grows precisely when the product works.

The land didn’t disappear, it moved

In the industrial economy, rent went to the owner of the soil, the mine, the building. I paid for well-located square meters, and the better the location, the more the property owner captured from the operation’s results.

In the AI economy, rent goes to the owners of digital infrastructure: cloud providers, chip manufacturers, distribution platforms, operating systems, marketplaces, social networks, and the companies that control the large models.

The new land might be a GPU, an API, an exclusive dataset, a privileged position in search results, or access to an audience that already exists. Rent is what you charge for access to something scarce that the other party can’t produce on their own. That still holds. It just changed owners.

But it’s worth separating two things that usually get thrown in the same bucket, because they behave in opposite ways. GPUs and cloud are reproducible capital: you can manufacture more, competitors are entering, and the price per unit of intelligence keeps falling fast, the opposite of a landlord raising the rent. That’s quasi-rent, a toll on a technological lead that competition tends to erode.

The rent that actually behaves like land is the gatekeeper’s: the app store taking its cut, the search result, the feed, access to an audience that already exists. That one has the only genuinely fixed supply in this whole story, because human attention doesn’t increase just because production did. That’s where the toll goes up instead of down.

So every dollar coming into that imaginary SaaS doesn’t split into wages, profit, and rent. It splits roughly like this:

compute + accumulated capital + platform rent + distribution + risk + profit

Notice that profit is last in line. It’s what’s left over, and what’s left over depends entirely on how much everyone else can charge before it.

What gets cheap for you gets cheap for your competitor

Here’s the point that changes the strategy.

I’ve written here, reading Reshuffle, that if the only thing that changes is speed, the advantage isn’t yours: it belongs to whoever sold you the tool. The economic version of that argument is harsher still: AI drives down your cost of building, but it drives down everyone’s cost, at the same time, with the same tool.

If anyone can put a product together in a few days, building stops being a barrier to entry. Code becomes abundant. Interfaces become abundant. Content becomes abundant. Even certain forms of knowledge become abundant. And what’s abundant doesn’t hold a price.

It’s worth being precise about what got cheap, because I’ve written almost the opposite here before. What AI made cheap is building the first version. Putting it into production is still expensive and still slow: integration, scale, governance, everything that doesn’t show up in the demo. Both things are true at once, and that difference is exactly what explains where the barrier moved: it left building and went to live in the places the demo doesn’t show.

It also doesn’t mean software is worth less, and this is where a lot of people overshoot the conclusion. A cheap input tends to raise the value of its complements, and cheaper production has historically expanded markets rather than shrinking them. There will be far more software in the world, not less. What changes isn’t the size of the pie. It’s who manages to keep a slice of it.

That’s why I distrust extraordinary margins as a signal of advantage. The likely pattern is: someone finds an opening, launches with a minimal cost structure, enjoys six months of spectacular margins, and then thirty similar products show up, prices fall, and what looked like a technological advantage turns into a commodity. That isn’t AI breaking economics. It’s economics working exactly as Smith described: competition compressing profit down to the ordinary rate, only much faster than before.

None of this is theoretically new, by the way. David Teece described the mechanism in 1986: when an innovation is easy to imitate, profit doesn’t stay with whoever invented it, it goes to whoever controls the complementary assets: distribution, brand, relationships, service. AI didn’t create that rule. It just brutally shortened the window in which it plays out.

What AI radically increased is the capacity to produce. It did not increase, in the same proportion, human attention, buyer trust, or a company’s willingness to change its own processes. Those three places are where scarcity went to live.

I learned this the analog way

The funny part is that this lesson is nothing new for anyone who has run a physical business.

Any competitor could copy Ctrl+Play’s curriculum. Several did. It wasn’t hard, it wasn’t expensive, and there was no way to stop it. What couldn’t be copied in six months was something else: the brand a mother trusts enough to leave her kid there three hours a week, a franchisee network that already knew how to operate, the relationships with schools, the repertoire of a thousand mistakes we had already made.

I spent a while thinking the product was the asset. The product was the easy part.

Software is discovering this now, at AI speed. Same lesson, different costume.

A jump to 2031

Let’s say it’s 2031.

Someone who understands a market well puts together, in a few weeks, the equivalent of what would have been an entire startup in 2026. Their agents research the sector, talk to customers, build the product, test versions, produce campaigns, and handle a good chunk of support.

There are millions of tiny software companies. Many are run by one or two people and bring in revenue that used to require a full team. And most of them earn very little, because for almost any piece of software there are hundreds of competent alternatives. Building got cheap. Getting chosen got expensive.

The valuable companies in that scenario aren’t the ones with the best code. They’re the ones that control some form of scarcity: a brand people trust, a community that’s hard to reproduce, proprietary data accumulated over years, deep integration into the customer’s operation, access to a distribution channel, specific knowledge of an industry.

And per-seat software loses ground to whoever sells outcomes. The customer doesn’t pay for a recruiting system license, they pay for qualified candidates. They don’t buy a collections tool, they buy a reduction in default rates. It makes sense: once software performs the work rather than merely assisting the worker, charging for the tool becomes a strange way to charge.

But there’s a price built into that which almost nobody mentions. Selling outcomes means taking on risk. Whoever charges for reduced defaults answers for it when defaults go up. And that’s a very specific kind of scarcity: it isn’t hard to copy because it’s technically complex, it’s hard because it requires someone willing to put their name on the line. That doesn’t scale with more GPUs.

And it’s worth remembering that charging for outcomes isn’t a new idea, and its track record is poor. Risk-sharing contracts, outsourcing with performance targets, and performance-based media have existed for decades, and they stall in almost the same two places every time: attribution, because nobody agrees whose merit it was, and procurement, because the customer’s legal team doesn’t know how to sign a contract like that. What might be different now is that the vendor controls the entire execution, not just the tool. If they do the work, it gets harder to argue about whose result it was.

In that world, the classic split between those who work and those who own capital gets blurry. A person with a handful of agents is, at the same time, worker, manager, and owner of the means of production. That democratizes entrepreneurship in a genuine way, and concentrates wealth in an equally genuine way, because the owners of the models, the chips, and the channels collect a toll on millions of businesses built on top of them.

It has never been easier to start a company. And it has never been harder to build an advantage that lasts.

What I take from this

Smith would recognize this dynamic without effort. Technology swaps the instruments, not the forces: competition compresses profit, capital seeks returns, owners of scarce resources charge rent.

The mistake I catch in myself is a different one, and it’s an executive’s mistake: celebrating the cost line. How many hours AI gave back, how much more the team delivered, how much we avoided spending. It’s the easiest metric to compute and the most misleading, because my competitor will compute the same savings soon enough, with the same tool, and then neither of us has moved.

The better question is boring and much harder to answer: what got scarcer in my market, and do I have any of it?

In my case, the most concrete answer so far has been context. I wrote recently about documentation nobody reads and how it’s never been more useful: operational knowledge turned into text precise enough for a machine to act on. It isn’t glamorous, it doesn’t show up in a demo, and it takes a while to pay off. But it’s the only part of this process my competitor can’t download ready-made from anywhere, because it’s made of what my operation learned and theirs didn’t.

I might be wrong about the timeline. On this subject, almost everyone is. What seems solid to me is the direction.

In the past, owning the land meant owning the place where wealth would be produced. In the coming years, wealth should end up with whoever owns the trust, the data, the distribution, and the context in which AI gets applied.

---

If this topic interests you, I’d love to exchange ideas. Find me on LinkedIn.