It's a design problem, not a prediction problem.

We keep trying to predict what people will do. What users will click, what employees will produce, what readers will share. Then we engineer incentives around those predictions. KPIs, OKRs, rewards, gamification, mission statements, performance reviews, contests. Seventy years of organizational design as a monumental effort to nudge a goal-driven agent toward the right behavior.

And yet the same patterns keep re-emerging. The metric gets gamed. The shortcut gets taken. The system keeps producing what it produces. We blame the people, the culture, the market. And we reach for another incentive.

The diagnosis is wrong. Behavior is not goal-driven. It's a structural affordance. People do what the structure makes easy, cheap, legible, and rewarding by default. The incentive layer doesn't override the substrate. It sits on top of it, hopelessly outweighed.

The motivation industry (incentives, KPIs, OKRs, rewards, gamification) is 70 years of symptom management.

Behavior emerges from structure

If you want the behavior to change, you don't motivate harder. You change the structure. Six moves do the work the entire incentive layer was trying to do:

1. Name the roles. Before behavior can be designed, the agents have to be legible. Not job titles. Roles. Who decides? Who synthesizes? Who verifies? Who overrides? A role is a typed slot in the system, with inputs and outputs. Anonymous agents produce anonymous behavior.
2. Enforce the boundaries. Roles only work if their edges are enforced in the substrate, not in policy. A boundary written into a process document is a suggestion. A boundary written into the API surface, the file layout, the permission scheme: that's a wall. The system decides whether crossing the wall is even possible.
3. Put signal in its channel. Every signal has a natural home. Errors belong on the error channel. Decisions belong in the decision log. Disagreement belongs in the disagreement record. When signals leak into the wrong channel, the system loses the ability to reason about itself. Bugs in the slack thread, decisions in meeting notes, errors swallowed silently.
4. Cheap path = right path. The path the substrate makes cheapest is the path that gets taken. If the right behavior requires extra effort, it doesn't happen at scale. Don't motivate against the gradient, the slope of least resistance. Flip it. Make the right way the default way, and the default way the cheap way.
5. Narrow waist between layers. The most composable systems all have the same shape: a thin, stable interface at the middle, with rich diversity above and below. TCP/IP. The Unix file. ATP, the cell's universal energy currency, the thin waist every metabolic pathway plugs into. A narrow waist lets layers above evolve independently of layers below. It lets entirely new species attach to either side without rewriting the whole stack.
6. Self-correction built in. No system gets the design right on the first pass. The ones that survive have feedback loops inside the substrate. Error correction baked into the operating primitive, not bolted on afterward. Democracy is one. Science is another. A pull request review is a small one. If your system needs an external committee to course-correct, it will eventually stop.

Foundation. Substrate. Content. Dynamics. Composability. Resilience. Static to dynamic to systemic. The arc is not arbitrary. Each move depends on the ones before it. You can't put signal in its channel if you haven't named the roles. You can't make the cheap path the right path if there's no boundary to push behavior toward. You can't build in self-correction without a narrow waist for the corrections to flow through.

The maxim of this move deserves its own name: pull, don't push. A push system spends authority to move people down a path they resist. Enforcement, reminders, dashboards of compliance. A pull system makes the desired path the cheapest one available, then gets out of the way. The behavior flows downhill on its own. Push is a policy wearing a hard hat. Pull is the affordance doing its quiet work. And the test is unforgiving: if the loop routes around your structure, the answer is never more force. It is a cheaper right path.

The lever is one layer deeper

Every time a system isn't producing what you want, the impulse is to push harder at the layer where the symptom is showing up. Sales are low. Incentivize the sales team. Code is buggy. Mandate more tests. People don't read the memo. Restructure the meeting cadence.

The lever is always one layer deeper than people are looking. The sales pipeline is producing what the pricing structure makes legible. The bug rate is producing what the build system makes cheap. The unread memo is downstream of which channel carried the signal. Don't tune the symptom layer. Find the affordance underneath it and redesign that.

This is what "keep what works" means at the substrate. Not keep what motivates. Not keep what we declared. Keep what the substrate makes durable. The roles that have proven legible, the boundaries that have proven enforceable, the channels that have proven to carry signal, the narrow waists that have proven to compose. Throw the rest of the scaffolding out. Most of it was symptom management anyway.

Part of an ongoing series on durable systems.