Mike Wirth has written something that feels both obvious and disorienting. As AI agents handle more of the code generation, software development shifts from 'code as product' to 'specs as product'.
The implications ripple outward fast.
Code as output, not craft
For decades, code was the asset. You wrote it. You maintained it. You protected it. The codebase was the product.
But if an AI agent can generate functionally equivalent code from a detailed specification in seconds, the value moves upstream. The specification becomes the thing worth protecting, sharing, and selling.
Code becomes what Wirth calls a 'build artifact' - generated output, not the source of truth. Like compiling a binary from source code, except now the source is a specification written in natural language or structured formats.
Foundation specs as assets
Wirth suggests that foundation specs - detailed, reusable specifications for common systems - will become shareable, composable assets with their own market.
Think of it like this. Today, you might use a library or framework as a building block. Tomorrow, you might use a specification - a detailed description of how a particular system should behave - and let an AI agent generate the implementation.
These specs could be versioned, licensed, sold. They'd have DRM. They'd be packaged and distributed. The spec for 'a secure authentication system with OAuth2 and MFA' becomes a product in itself.
What this means for developers
If you're a developer, this feels like either liberation or threat, depending on how you look at it.
On one hand, you spend less time writing boilerplate. Less time debugging syntax. More time on the hard problems - architecture, user experience, edge cases that require human judgement.
On the other hand, if code generation becomes trivial, the skill of writing code becomes less valuable than the skill of writing specifications. And that's a different discipline entirely.
Writing a good specification requires clarity, precision, and an understanding of how systems interact. It's closer to architecture than implementation. Not everyone who's good at coding is good at this.
Composability and ecosystems
Wirth goes further. If specs are composable, you get ecosystems of specifications. A spec for a payment gateway. A spec for a recommendation engine. A spec for real-time collaboration.
Combine them, and an AI agent generates a full application. The developer's role becomes curating, configuring, and connecting these specs - not writing the code from scratch.
This mirrors what happened with cloud infrastructure. You don't run your own servers anymore - you configure AWS. You don't write your own databases - you configure Postgres. Now, you won't write your own implementations - you'll configure specs.
The questions this raises
Who owns the spec when it's collaboratively refined by humans and AI? How do you version control a specification that's iteratively improved by agents? What does code review look like when the code is generated on-demand?
And here's the uncomfortable one. If code becomes a commodity, what happens to the craft of programming? Does it survive as a niche discipline for those building the AI agents themselves? Or does it evolve into something else entirely?
Wirth doesn't have all the answers. But he's asking the right questions. Because this shift - from code as product to specs as product - isn't a distant future. It's happening now, quietly, in pockets of the industry.
Worth watching closely.
Read Mike Wirth's full piece on the Meticulous blog.