Definition #
[Incentive Recursion] is the physics by which every incentive structure in an operation is itself the output of an incentive structure operating one layer up, cascading through the operator’s own posture toward design or default. The recursion runs upward from cast behavior through incentive design through operator posture through [Causal Read], and downward from operator posture through [Reward Structure Architecture] configuration through cast, kitchen manager, and Guest layers. It is not a single-direction cascade; it is a loop that either compounds or contracts across every turn.
Corollary and manifestation of [The Summers Principle] at the incentive dimension. Every incentive is either designed or defaulted, and the operator who installs incentives is themselves subject to anticipated incentives whose validity depends on the accuracy of their [Causal Read]. Sits under [The Summers Principle] as the physics that runs the design-or-default choice through the incentive layer.
Runs on the two branches of [Reward Structure Architecture] — [Transactional Reward] and [Relational Reward]. When [Transactional Reward] dominates the architecture, the recursion runs on contracting nodes and produces the contracting cascade. When [Relational Reward] holds load-bearing positions at compounding-outcome nodes, the recursion runs on compounding nodes and produces the compounding cascade. The recursion is the physics; the reward branches are what it runs on.
Mechanism #
Every incentive in an operation is the output of an incentive one layer up. The cast member’s per-shift behavior is the output of the cast comp mechanism installed at the cast comp node. The cast comp mechanism is the output of the operator’s decision at the reward-architecture layer. The operator’s decision at the reward-architecture layer is the output of the operator’s own [Causal Read] on cause-effect between reward configuration and compounding outcome. The operator’s [Causal Read] is itself the output of the operator’s incentive to run [Causal Read] discipline — which comes from the operator’s posture toward design or default at the layer above the reward architecture. Every layer’s incentive structure is produced by the layer above it. This is the recursion.
Incentives act through anticipation, not through delivery. [Incentive Recursion] runs on anticipated rewards, not on delivered rewards. The cast member does A because they anticipate B on a timeline they read at a confidence level their [Causal Read] supports. Whether B arrives is a separate question from whether the anticipation drove the action. The action is a bet on the anticipation. Delivered rewards feed back into the [Causal Read] and update the anticipation for the next cycle, but the operative mechanism at the moment of action is anticipation, not delivery. This is why [Causal Read] is upstream of [Incentive Recursion] — the read discipline determines what the anticipation looks like, and the anticipation is what actually drives the behavior.
The two-directional cascade. The recursion runs both downhill and uphill, which is what makes it a recursion rather than a one-way cascade. Downhill from the operator layer: the operator’s posture sets [Reward Structure Architecture] configuration, which sets the mix of [Transactional Reward] and [Relational Reward] at every node, which sets the anticipated rewards driving cast and kitchen manager behavior, which sets what cast and kitchen manager behavior produces at the Product and Guest layers. Uphill from the cast layer: cast behavior produces outcomes, outcomes feed back through the [Causal Read], the [Causal Read] updates the operator’s model of cause-effect at the reward layer, and the updated model shapes the operator’s next reward-architecture decision. If the [Causal Read] is disciplined, the uphill loop compounds — actual outcomes update the model against observation and the operator’s anticipations grow more accurate with each turn. If the [Causal Read] is broken, the uphill loop contracts — outcomes get attributed to external causes, the model does not update, the operator’s anticipations remain calibrated to Transactional-dominant defaults, and the downhill cascade regenerates the same architecture whose failure was just observed.
Compounding nodes. When the operator’s [Causal Read] is accurate and the operator overrides the natural weighting bias, they install [Relational Reward] mechanisms at compounding-outcome nodes. Design incentives cascade through the operation — cast behavior aligns to compounding outcomes, kitchen manager behavior aligns to compounding outcomes, Guest Experience aligns to compounding outcomes, Profit aligns to compounding outcomes — and each layer’s success reinforces the operator’s causal model. The strengthened model raises the [Causal Read] confidence on Relational alternatives at the next decision point, which increases the operator’s willingness to install further Relational mechanisms at nodes where the natural weighting bias would otherwise suppress them. The recursion compounds. Each turn of the loop makes the next turn easier and the [Causal Read] more accurate. The operator gets better at design work over time because the recursion is running on compounding nodes.
Contracting nodes. When the operator’s [Causal Read] is broken or the operator defers to the natural weighting bias, they install [Transactional Reward] mechanisms across most nodes including nodes whose outcomes are compounding. Default incentives cascade through the operation — cast behavior aligns to short-term visible signals, Guest experience degrades to whatever cast produces on Transactional-dominant incentives, Profit runs on extraction rather than compounding — and each layer’s degradation reinforces the operator’s broken causal model. The misses get attributed to external causes (cast being difficult, kitchen manager not stepping up, Guests being demanding, market conditions), so the model does not update. The [Causal Read] confidence on Relational alternatives stays suppressed, and at the next decision point the operator defaults to Transactional again because their [Causal Read] cannot see the causal chain from Relational investment to compounding outcome. The recursion contracts. Each turn of the loop makes the next turn harder and the [Causal Read] less accurate. The operator gets worse at design work over time because the recursion is running on contracting nodes.
The operator is inside the recursion. The operator is not designing the incentives from outside the system. The operator is themselves subject to anticipated incentives — their own draw structure, their own time allocation, their own compounding investments, their own [Causal Read] discipline (or absence). The operator who reads their own reward layer as pure Transactional is running a Transactional-cadence [Causal Read] on every downstream decision because that is what their own reward layer has trained the [Causal Read] to expect. The recursion runs through the operator as one of its layers, not around them as an external designer. Naming this is load-bearing because operators consistently treat themselves as outside the incentive system they are configuring, when the physics puts them inside it as a specific layer whose configuration cascades downward and whose [Causal Read] gets updated (or fails to update) upward.
The [Causal Read] as the load-bearing layer. Every other layer of the recursion runs mechanically. Given a [Reward Structure Architecture] configuration, [Incentive Recursion] will run the corresponding cascade — compounding or contracting — through cast, kitchen manager, Guest, and Profit layers. The layer where the recursion’s direction gets determined is the [Causal Read] layer. Disciplined [Causal Read] work at the operator layer produces accurate anticipations, which produces disciplined [Reward Structure Architecture] design, which produces compounding cascade downward, which produces observation that feeds back to strengthen the [Causal Read] — the loop compounds. Undisciplined [Causal Read] work at the operator layer produces bias-dominated anticipations, which produces Transactional-defaulted [Reward Structure Architecture], which produces contracting cascade downward, which produces observation that gets attributed externally and does not update the [Causal Read] — the loop contracts. The [Causal Read] is the layer where the recursion either compounds or breaks.
The recognizable moment. [Incentive Recursion] becomes visible to the operator when they recognize that the pattern they are reading at the cast layer — cast members responding to visible short-term rewards rather than to design outcomes — is the same pattern running at their own layer, and that the two patterns are causally connected. The operator’s own bias toward Transactional-cadence rewards at their own layer is producing (through the [Reward Structure Architecture] they configured) the Transactional-cadence rewards at the cast layer that they are complaining about. Once the operator sees the recursion, they cannot un-see that adjusting cast-level rewards without adjusting operator-level rewards is treating a downstream symptom of an upstream configuration.
Where it applies. Every operation. Every node in every architecture. The recursion is not optional — it is the physics of how incentive structures actually operate. The only variable is whether it is running on compounding nodes ([Relational Reward] at load-bearing positions, disciplined [Causal Read]) or on contracting nodes ([Transactional Reward] dominance, [Causal Read] running on defaults).
The stakes. An operator who does not see [Incentive Recursion] as a recursion — a loop running through their own layer — treats incentives as levers they pull from outside the system. They adjust cast-level rewards, watch the adjustments drift back to default, and read the drift as external. They adjust kitchen manager comp, watch the adjustment produce short-term compliance and long-term stall, and read the stall as external. The recursion is regenerating its default state faster than they can adjust downstream nodes because they are not adjusting the upstream layer — their own [Causal Read] and their own reward layer configuration — that determines the recursion’s direction. Naming the physics as a recursion makes the operator-layer intervention point visible.
Load-Bearing Distinction #
Not [Reward Structure Architecture]. [Reward Structure Architecture] is the design layer — the configuration of reward mechanisms across nodes. [Incentive Recursion] is the physics that runs on that configuration. The architecture is what gets designed or defaulted; the recursion is how the designed-or-defaulted architecture produces the cascade. Operators who collapse the two miss that the architecture can be reconfigured (design work at the reward layer) while the recursion physics remains constant (the loop runs on whatever architecture is installed).
Not [Transactional Reward] or [Relational Reward]. The two reward classes are what the recursion runs on. [Incentive Recursion] is the recursion physics itself. When [Transactional Reward] dominates, the recursion produces contracting cascade; when [Relational Reward] holds load-bearing positions, the recursion produces compounding cascade. The physics is one layer above the reward classes.
Not [Causal Read]. [Causal Read] is a discipline the operator runs. [Incentive Recursion] is the physics that runs through the [Causal Read] as one of its layers. The [Causal Read] is the layer where the recursion’s direction gets determined, but the recursion is not the same term as the read discipline itself. [Causal Read] is what the operator does; [Incentive Recursion] is the physics of how what they do cascades through the whole system.
Not [The Summers Principle] itself. [The Summers Principle] is the parent principle — every choice is either by design or by default. [Incentive Recursion] is the specific manifestation of that principle at the incentive dimension, showing how the design-or-default choice cascades through a recursive loop rather than through a one-way decision. Naming [Incentive Recursion] as its own term keeps [The Summers Principle] as the parent and lets the recursion hold the specific loop physics at the incentive layer.
Not one-way cascade. [Incentive Recursion] is a recursion, not a cascade. A one-way cascade would run from operator down to cast and stop. The recursion runs down and back up — the downhill cascade produces outcomes that feed back through [Causal Read] to update the operator’s model, which shapes the next downhill decision. Operators who read the mechanism as one-way cascade miss the uphill loop that either compounds the [Causal Read] against observation or contracts it against external-attribution.
Not something the operator designs from outside. The operator is inside the recursion as one of its layers. Their own draw structure, time allocation, [Causal Read] discipline, and posture toward design or default are inside the recursion, cascading downward and feeding upward like every other layer. Operators who treat themselves as external designers of the incentive system they operate inside miss the operator-layer intervention point.
The term is load-bearing because operators who cannot see the physics as a recursion running through their own layer cannot make the operator-layer intervention that determines the recursion’s direction. They spend design work at downstream nodes, watch the cascade regenerate its default configuration, and read the regeneration as external instead of as the recursion physics running unchecked. Naming the recursion surfaces the loop and locates the operator as the load-bearing layer.
Diagnostic Tests #
Test One — The Recursion-Direction Test. The operator asks whether their operation’s overall trajectory across recent cycles is compounding or contracting. Compounding: positioning capital building, cast capability accumulating, Guest re-encounter compounding, meaningfully differentiated value strengthening, Profit slower per cycle but compounding across cycles. Contracting: cost squeeze producing this-cycle margin, cast turnover trending up, kitchen manager stall or departure, Guest tolerance eroding, capital reserves depleting even when Profit numbers look strong. The direction is the aggregate diagnostic of whether [Incentive Recursion] is running on compounding or contracting nodes.
Test Two — The Attribution-Pattern Test. The operator lists the misses in the operation over recent cycles and reads how each was attributed. Attribution to external causes (market conditions, cast difficulty, kitchen manager gap, Guest behavior, vendor problems) is the diagnostic that the uphill loop of the recursion is running broken — outcomes are not feeding back to update the [Causal Read]. Attribution to internal causal chains (reward-architecture configuration produced this behavior, [Causal Read] miss produced this decision, weighting bias suppressed this alternative) is the diagnostic that the uphill loop is running disciplined and the [Causal Read] is updating against observation.
Test Three — The Operator-Layer-Match Test. The operator reads what their own reward layer looks like — draw structure, time allocation, compounding investments, [Causal Read] discipline cadence — and asks whether the cast and kitchen manager reward layers look mechanically similar. If the operator’s own layer is pure Transactional and the cast layer is pure Transactional, the recursion is running consistently downhill and the operator can trace cast behavior directly to their own reward-layer configuration. If the operator’s layer holds Relational components and the cast layer does not, either the cascade is being blocked at a specific layer (find where) or the operator is running Relational at their own layer without disciplined [Causal Read] discipline behind it, and the Relational components will collapse under cash pressure while the Transactional cast layer regenerates.
Test Four — The Design-Effort-Where Test. The operator lists the reward-architecture adjustments made in recent cycles and reads which layer received the design effort. If all the adjustments are at cast-layer nodes with no changes at operator-layer nodes, the design work is happening at the downstream layer while the upstream layer regenerates the default configuration. The recursion will regenerate the cast-layer default faster than the adjustments hold because the upstream layer is producing the pattern the downstream adjustments are trying to break.
Test Five — The [Causal Read] Discipline Test. The operator asks whether they are running disciplined [Causal Read] work — building causal models explicitly, naming confidence at both dimensions (certainty and immediacy), holding anticipations across multiple cycles, updating the model against partial observation, running [The Operator’s Own Audit] on cadence — or whether they are pattern-matching from short-cycle observation. Pattern-matching from short-cycle observation is the natural weighting bias running unchecked. Disciplined [Causal Read] work is the override mechanism. The presence or absence of the discipline is the diagnostic tell of whether the recursion’s [Causal Read] layer is running disciplined or defaulted, and therefore whether the whole recursion is compounding or contracting.
Family Position #
Corollary of [The Summers Principle]. Sits inside Perspective at the physics-layer altitude, cross-Fundamental in application — the recursion runs across Product, People, Performance, and Profit through the reward mechanisms installed at every node.
Perspective application. Perspective on incentives determines whether the operator sees [Incentive Recursion] as physics or as a set of individual levers. The operator whose Perspective treats incentives as levers pulled from outside the system misses the recursion entirely; they design at downstream nodes and read regeneration as external. The operator whose Perspective reads the incentive layer as a recursion running through their own layer can see the operator-layer intervention point. Perspective is the entry point for the physics becoming legible.
Product application. The Product — the Guest Experience — is a compounding outcome that requires the recursion to be running on compounding nodes to produce reliably. When [Incentive Recursion] runs on Transactional-dominant [Reward Structure Architecture] at Product-side nodes, the recursion produces cast behavior aligned to single-cycle outcomes and the Product degrades to whatever functional GX single-cycle behavior can produce. When the recursion runs on Relational-load-bearing configuration at Product-side nodes, the recursion produces cast behavior aligned to compounding GX quality and the Product compounds across cycles.
People application. The People fundamental sits directly inside [Incentive Recursion]. Cast development, kitchen manager development, cast promotion pathway, cast recognition patterns are all People-side outputs of the recursion running through People-side reward mechanisms. Operations diagnosing People problems should read the recursion — what is the [Reward Structure Architecture] configuration at People-side nodes, is it running compounding or contracting cascade, is the operator layer producing the ceiling that the People layer is running under.
Performance application. Performance is what the recursion produces at cast-behavior level. Cast members respond to anticipated rewards read through their own [Causal Read] on the reward mechanisms installed at their nodes. If Performance is failing at compounding-behavior nodes, the recursion is running Transactional-dominant at those nodes and the behavior cannot be produced by the reward structure that is running. Performance adjustments made without recursion-level diagnosis produce short-term compliance that drifts back to the default the recursion regenerates.
Profit application. Profit is the aggregate output of [Incentive Recursion] across cycles. Compounding recursion produces compounding Profit. Contracting recursion produces extraction Profit that runs strong through cost squeeze and finite-base depletion until the base runs out. The Profit curve’s shape — flat early then compounding vs. strong early then collapsing — is the operator’s aggregate diagnostic of which direction the recursion is running.
Cross-References To Locked IP #
Parent:
- [The Summers Principle] — the parent principle; [Incentive Recursion] is the physics through which the design-or-default choice cascades at the incentive dimension
Related:
- [Reward Structure Architecture] — the design layer that [Incentive Recursion] runs on; the architecture is what gets designed or defaulted, and the recursion is how the designed-or-defaulted architecture produces the cascade
- [Transactional Reward] — the Road 1 branch that the recursion runs on when [Transactional Reward] dominates the architecture; produces the contracting cascade
- [Relational Reward] — the Road 2 branch that the recursion runs on when [Relational Reward] holds load-bearing positions; produces the compounding cascade
- [Causal Read] — the load-bearing layer of the recursion; where the recursion’s direction gets determined, either compounding through disciplined causal work or contracting through natural weighting bias
- [The Operator’s Own Audit] — the applied discipline for keeping the [Causal Read] layer of the recursion running against observation rather than against memory
- [Two Roads] — the family-level parent principle whose branches ([Transactional Reward] and [Relational Reward]) determine what the recursion runs on
- [The Operator’s Read] — the aggregate read discipline through which the operator reads the recursion running in their operation
- [Meaningfully Differentiated Value] — a compounding outcome that requires the recursion to run on compounding nodes to accumulate
- [Positioning Capital] — a compounding asset that requires the recursion to run on compounding nodes to build
Opposing patterns:
- [Static Decline] — the operator condition where the recursion has drifted to contracting cascade and the operator has stopped reading the direction; the aggregate diagnostic of contracting recursion at the operator condition level
- [Hacksterism] — the shortcut posture that treats incentives as levers to pull rather than as a recursion running through the operator’s own layer
- [Transactional Arbitrage] — the extraction pattern that runs when the recursion is contracting; the aggregate output of Transactional-dominant [Reward Structure Architecture] running through [Incentive Recursion]
- [The Affordability Lie] — the framing that arrives when the recursion is contracting and the operator cannot see the [Relational Reward] alternatives as fundable; the lie hides that the contracting recursion is producing the margin pressure being cited as the reason Relational cannot be funded
Why This Matters #
Operators do not fail at incentive design because they cannot set individual reward mechanisms. They fail because they cannot see the physics as a recursion running through their own layer. Without the recursion named, incentive adjustments happen at downstream nodes, drift back to the default configuration the upstream layer is regenerating, and get read as external — cast being difficult, kitchen manager gap, Guest behavior, market conditions. The regeneration is the recursion running on whatever configuration is installed, and adjustments at downstream nodes cannot outrun the upstream layer’s cascade.
The operator-layer intervention is the load-bearing move. The operator’s own [Causal Read] discipline, their own reward-layer configuration, their own posture toward design or default at the reward-architecture layer — these are the intervention points that determine the recursion’s direction. Every other intervention is downstream and gets overrun by regeneration. This is why every operator who has read every comp benchmarking study and every incentive-design framework and cannot get their reward decisions to hold has been trained at the downstream layer when the work is upstream. The industry teaches downstream because downstream is where the visible mechanisms live. What the industry does not teach is that the mechanisms are outputs of a recursion, not levers on a static system.
The [Causal Read] as the load-bearing layer is where the framework’s teaching converges. [Reward Structure Architecture] gets designed or defaulted based on the operator’s [Causal Read]. [Transactional Reward] dominates by default because the natural weighting bias suppresses the [Relational Reward] anticipations, and the suppression happens inside the [Causal Read] layer. [Relational Reward] holds load-bearing positions only when disciplined [Causal Read] work overrides the bias at each Relational node. The recursion’s direction — compounding or contracting — is determined by whether the [Causal Read] layer is running disciplined or defaulted. Naming [Incentive Recursion] as physics with a load-bearing [Causal Read] layer surfaces where the design work has to happen for the recursion to run compounding rather than contracting.
[Incentive Recursion] is load-bearing across the framework because it is the physics that connects [The Summers Principle], [Reward Structure Architecture], the [Transactional Reward] / [Relational Reward] pair, and [Causal Read] into one operating system. Without the recursion named, each of those terms operates as a separate insight, and the operator cannot see the loop that runs through all of them. With the recursion named, the operator has a single physics — an incentive loop running through their own layer, in both directions, determined at the [Causal Read] layer by disciplined work or by natural bias — that ties the framework’s incentive teaching together into one operating physics.
Operating Consequence #
Locate yourself inside the recursion. The operator stops treating themselves as the outside designer of the incentive system and starts reading themselves as a specific layer inside the recursion. Their own draw structure, time allocation, compounding investments, and [Causal Read] discipline are the operator layer whose configuration cascades downward through [Reward Structure Architecture] and feeds upward through the [Causal Read] update loop. Every downstream intervention runs against the operator layer’s cascade unless the operator layer is being adjusted too.
Diagnose direction before adjusting nodes. Before making any reward-layer adjustment, the operator reads the recursion’s current direction — compounding or contracting — using the aggregate diagnostics (Profit shape across cycles, compounding-base build vs. finite-base depletion, attribution pattern for misses, operator-layer-match with downstream layers). Adjustments made without direction diagnosis run without knowing whether the recursion is regenerating the pattern the adjustment is trying to break.
Intervene at the operator layer first. When the recursion is contracting, the operator intervenes at their own layer first — their own [Causal Read] discipline, their own reward structure, their own draw configuration — before adjusting downstream nodes. The operator layer sets the ceiling for the recursion’s direction. Downstream interventions without upstream intervention produce short-term drift and long-term regeneration.
Read misses as internal, not external. When outcomes miss anticipations, the operator refuses external attribution as the default read. Every miss is a candidate for internal causal analysis — what did the reward-architecture configuration produce, what did the [Causal Read] miss, what did the weighting bias suppress. External attribution feels honest to the operator (market conditions are real, cast difficulty is real, Guest behavior is real) but it is also the mechanism through which the uphill loop of the recursion runs broken. Refusing default external attribution is how the [Causal Read] gets updated against observation.
Install [Causal Read] discipline as the recursion’s compounding driver. The operator installs disciplined [Causal Read] work as an operating cadence — explicit causal models, two-dimensional confidence naming, cross-cycle anticipation holding, cadenced model update, [The Operator’s Own Audit] on schedule. The discipline is what runs the recursion compounding rather than contracting. Without the discipline, the [Causal Read] layer defaults to natural bias, and the recursion contracts by physics regardless of the operator’s stated intent.
Refuse the levers-from-outside framing. The operator refuses framings that treat incentives as levers pulled from outside the system. “Let’s adjust cast comp” without “and here is what shifts at the operator layer” is treating cast comp as a lever on a static system. Every incentive adjustment is a change to one layer of the recursion; the operator names what happens at the adjacent layers when the adjustment runs.
Read regeneration as the recursion’s tell. When downstream adjustments drift back to default, the operator reads the drift as the recursion regenerating from the upstream layer that was not adjusted. They do not increase the downstream adjustment; they move upstream to the layer producing the regeneration. Regeneration is the physics revealing itself, not resistance to change.
Watch the [Causal Read] layer as the direction-determining layer. The operator treats their own [Causal Read] discipline as the layer where the recursion’s compounding-or-contracting direction gets determined. This is where the design work has to happen for every other layer to hold. Compounding-cascade cast reward mechanisms cannot hold if the operator’s [Causal Read] on Relational alternatives is running unchecked bias. The [Causal Read] discipline is the leverage point across the whole system.
What Changes Tomorrow #
Tomorrow the operator picks a specific behavior pattern in the operation they have been reading as an external problem — cast turnover, kitchen manager stall, Guest recovery not happening, meaningfully differentiated value work stalled, positioning capital not building — and runs the recursion trace on it. Not the cast-comp read. Not the individual-mechanism read. The recursion trace.
The trace runs both directions. Downhill from the operator layer: what is my draw structure, my time allocation, my compounding investments, my [Causal Read] discipline cadence? What is the [Reward Structure Architecture] configuration that my operator layer has produced? What mix of [Transactional Reward] and [Relational Reward] runs at the node where the behavior pattern shows up? What anticipated rewards is that mix producing at the cast or kitchen manager or Guest layer where the behavior pattern lives? Uphill from the behavior pattern: what does the behavior tell me about the anticipated rewards driving it? What does that tell me about the reward mechanism at that node? What does that tell me about the [Reward Structure Architecture] configuration? What does that tell me about my own [Causal Read] on the causal chain from configuration to outcome? Where in the uphill loop am I attributing externally when internal attribution is available?
When the trace completes, the operator has located the layer where the recursion is producing the pattern they were reading as external. The intervention happens at that layer, upstream of where the pattern shows up. If the trace lands at the operator layer — the operator’s own [Causal Read] discipline is running unchecked bias, the operator’s own reward layer is producing the ceiling that downstream layers are running under — the intervention is at the operator layer first. Downstream adjustments wait until the upstream intervention is running.
The frame the operator now runs is that incentives are physics, not levers. The physics runs as a recursion through the operator’s own layer, in both directions, and its direction gets determined at the [Causal Read] layer by whether disciplined causal work overrides the natural weighting bias. Every behavior pattern in the operation is an output of the recursion running on whatever configuration is currently installed. Adjusting downstream mechanisms without adjusting the upstream layer that regenerates them is treating a symptom of the recursion instead of the recursion itself. The operator’s design work is at the recursion layer — the [Causal Read] discipline, the operator-layer reward configuration, the [Reward Structure Architecture] mix — or the design work does not hold.
