Building got cheap. Ideas didn't.

For most of the history of software, the hard part of turning an idea into a product was building it. Engineering was the moat — the thing that separated the people who could ship from the people who could only describe. If you had an idea but couldn't build, you needed someone who could, and they were scarce and expensive.

That moat is draining, fast. I direct coding agents to build; the artifact under my hand is the spec and the review, not the keystrokes. And I'm not special — this is quietly becoming the default. Which means the interesting question is no longer can you build it. It's what is the competition actually about now?

The scarce skill kept moving up

Watch where the valuable skill has lived over just three years.

First it was prompt engineering. Same model, two people: one coaxed genuinely useful work out of it, the other got mush. Phrasing was the edge. That was the peak conversation of 2023–2024.

Then we wired LLMs to tools and let them take actions in the real world — read files, call APIs, run code. The agent era. The skill shifted from "what do I ask" to "what can it do."

Now it's moved again — to context engineering. Tobi Lütke named it and Andrej Karpathy made it stick: think of the model as a CPU and its context window as RAM; the discipline is deciding what gets loaded for the next step. Prompt engineering didn't die — it became a small footnote inside the larger craft of building and directing agents.

Each step moved the scarce skill up the stack, away from "how do I phrase this" toward "how do I orchestrate a system that does real work." Building agents and directing them well is the golden skill of this era — but, as we'll get to, it's the entry fee, not the prize.

The agents got genuinely good

It's worth being blunt about how far this has come, because a lot of people are still arguing with the 2023 version of the technology.

These aren't autocomplete toys. Claude Code alone authors over 300,000 GitHub commits a day — on the order of a tenth of all public commits — and the frontier agents sit near 88% on SWE-bench Verified. Inside most serious engineering orgs, the question stopped being whether to build with agents and became which ones.

The tired line that "LLMs write junk code" is now simply out of date, and the strongest evidence isn't a benchmark — it's Mythos. When Anthropic built a model so good at finding security vulnerabilities that it decided not to release it publicly — a model that turned up thousands of high-severity bugs, including ones that had survived decades of expert human review, and wrote working exploits on its own — the question "can AI match a good engineer on code quality?" stopped being interesting. Google's Big Sleep did the smaller, public version: twenty fresh open-source vulnerabilities, and it caught a live SQLite exploit before attackers could use it. Reading code well enough to find a flaw humans missed for twenty years is a quality argument, not a hype one.

The honest caveat: point an agent at a vague goal and it will still write confident garbage. But that's a direction problem, not a model problem — which is exactly the point of everything that follows.

When building gets cheap, the moat moves

For decades, big companies held a structural advantage that was easy to miss because it was so obvious: they could afford armies of engineers. That was the moat. Coding agents are commoditizing it. The work that used to need 50 to 200 engineers, a founder with a handful of agents can now seriously attempt.

This isn't a thought experiment. The share of new startups with a solo founder has climbed sharply — roughly a quarter to over a third in a few years, per Carta. Sam Altman and Dario Amodei are openly betting on the first one-person billion-dollar company arriving by 2026–2028. Two- and three-person teams are reaching nine-figure valuations on "AI-first" principles — one visionary and a fleet of agents doing what used to take a department.

Which is also why writing code by hand is quietly becoming a disqualifier. Not because handcrafted code is bad — it isn't — but because the person next to you ships ten times faster at comparable quality by directing agents well. Speed was always a feature. Now it's nearly free to whoever learned the new skill, and brutally expensive to whoever didn't.

So what actually wins

Here's the part that catches engineers off guard: when everyone can build, building stops being the differentiator. The contest moves to the thing that was always the real bottleneck and just spent decades hidden behind the engineering one — knowing what to build.

Taste. Market sense. A real grasp of the economics and the marketing — what users actually need, what a business will actually pay for, which one idea out of ten that all sound good is the one worth executing. Directing agents well gets you into the game now; it doesn't win it. The winners are the people who pair the new building leverage with old, unfashionable judgment about markets and people.

And the last ingredient is the cheapest and the rarest: doing. The tools are on the table today — not next year, today. The gap that's opening isn't between people with access and people without; everyone has access. It's between the people building with them and the people still writing think-pieces about whether they should.

The barrier that kept most ideas locked up — the ability to build them — is falling away. What's left is the part that was always the real contest: having an idea worth building, the taste to build it well, and the nerve to actually ship it.

Building got cheap. Everything that was ever hard about it is still hard.