Anyone can make software now. A store manager can describe a tool in a paragraph before breakfast and be using it by lunch.
When the cost of writing code falls to almost nothing, everything we believed about where the value in software sits has to move.
1. Code is no longer the scarce thing
A prototype that took a team a quarter now takes one person an afternoon. Features, screens and integrations can all be generated, regenerated and discarded. When anything can be built, building stops being an advantage. Whatever stays expensive becomes the thing that matters.
2. Better now means easier to connect to
If every team can produce its own tool, the measure of a tool changes. The question becomes how cleanly it takes data in and hands data on, and to how many other things. A small tool that ten others can read from beats a large one that nobody can. The axis of betterment has rotated from capability to compatibility.
3. All software is data changing hands
Strip any application down and the same thing remains. A record arrives, something is done to it, a record leaves. The order comes in, the picker confirms, the shelf count changes, the invoice goes out.
Every one of those handoffs carries an agreement, usually unwritten: what the record looks like, who owns it, how often it moves, how much error is tolerated, which way it flows, which version is current. That agreement is the contract. It is the only part of the system two parties have to hold in common, which makes it the only part that is expensive to change.
4. The interface is liquid
Fix the contract and the screen stops mattering. The same handoff can appear as a spreadsheet to the planner, a three-button card to the store associate, a chart to the regional head, a voice prompt to the driver, and nothing at all to the agent that only needs the record.
None of these has to be designed twice. Each can be generated for one person and one task, and thrown away tomorrow. Teams that fight about screens are fighting over the cheapest layer in the stack. The argument worth having is about what crosses the boundary.
5. Contracts grow in a few known ways
Use cases expand, and contracts move with them. They move in a small number of predictable ways.
- Extend. A new optional field is added. Every existing tool keeps working, and new ones read the addition.
- Split. One contract becomes two when a role specializes, as when "stock received" divides into "received" and "put away".
- Compose. Two contracts join to form a third, as when sales and stock combine into availability.
- Tighten. Tolerance narrows as trust in the data grows: end-of-day becomes hourly, approximate becomes counted.
- Version. A breaking change ships as a new version beside the old one, and the old one retires on a date everyone can see.
The first four are routine. The fifth should be rare enough to be an event. That asymmetry is the whole trick: the layer that changes slowly is what makes the layer that changes daily safe.
6. Sophistication lives in the protocol
Rich interaction used to mean a richer interface. With explicit contracts it means a richer exchange.
An agent proposes a reorder, a person approves it, a scale confirms the delivery weight, and all three write to the same record with their names attached. A value can be provisional until confirmed, disputed and then resolved, partially filled, traced back to whoever asserted it. People, agents and machines become equal participants because they agree on what they are passing, not on how it looks. The interesting design work moves out of the pixels and into the handshake.
7. The end state is a library of tiny tools
Put the claims together and a different shape of company software appears. A registry of contracts that changes slowly and is owned by named people. On top of it, a growing shelf of very small tools, each readable in one sitting, each built by whoever needed it, each honoring the contracts and each safe to throw away.
The tools turn over constantly. The contracts compound.
Own the contracts. Let the software be cheap.