What Scaffolding Survives Model Improvement — and How Do You Know When a Line Turns Harmful?

The questions#

Three #oq/now items from the harness-evolution cluster, answered as one synthesis:

1. Harness Shrinkage as Models Improve — does all prompt scaffolding eventually migrate into the model, or does some remain (organization-specific style, security rules, brand voice)?
2. Instruction Compounding — Anthropic's compounding list is hand-curated per release; is there a detectable signal that flags which prompt lines have become compounding, so pruning is not a manual reread?
3. Build for the Next Model — the bet depends on a reliable release cadence; what happens if model improvement stalls?

Answer 1: No — requests migrate, five other classes don't, and one flows backward#

The question's examples (org style, security rules, brand voice) all survive, and the sorting rule is already in the corpus: the bitter lesson bites on structure that encodes a human prior about the task — that migrates inward as capability grows; structure that encodes boundaries, records, identity, or serving arithmetic has no "inward" to migrate to (The Bitter Lesson's deployment exemption). Applied across the cluster, what shrinks is exactly one class — behavior requests (be thorough, verify, use the to-do list, start a loop), which dissolve as the model performs the behavior natively, and past their expiry date turn actively harmful (Instruction Compounding: native tendency + instruction = additive overshoot). The Fable 5 Pokémon result is the clean demonstration: the vision/navigation scaffolding wasn't improved, it was deleted (Harness Shrinkage as Models Improve).

What remains, by class:

1. Boundary enforcement. Tests, linters, schemas, hooks, isolation, permissions — the contract with external reality (Where Does Agent Harness Work Remain Durable as Models Improve?, layers 2/4/5). The July evidence strengthens this class: on Opus 5, constraint-form instructions (stay in scope, delegation caps) keep working on the very model where request-form instructions compound (Instruction Compounding's asymmetry — Least Agency written as a prompt). Security rules survive because they are constraints, not requests — and the agent-security corpus independently concludes enforcement must sit outside the manipulable model regardless of how capable it gets.
2. Organization-specific record. Repo-local decisions, specs, conventions: "a smarter model can infer more from code, but it cannot infer a current decision that was never recorded" (Where Does Agent Harness Work Remain Durable as Models Improve?, layer 1). Org style lives here to the extent it is arbitrary choice rather than general competence — no training run can learn which of two defensible conventions your team picked.
3. Deliberate identity. Character/brand voice is the documented counterexample to shrinkage: capability changes between models while character is deliberately held stable — the pruning discipline runs in reverse there, preserving continuity across capability jumps (Claude Character as Product). Identity scaffolding isn't compensating for a capability gap, so capability growth doesn't obsolete it.
4. Inference/deployment structure. KV-cache tricks, quantization, serving paths encode no task prior; they compound rather than shrink (The Bitter Lesson, Gemma 4 worked example).
5. Human-facing legibility. The harness that keeps the human in the loop (HTML plans, review surfaces, the allocator's 99% scaffolding) grows as models improve, because the binding constraint moves from "can the model do it" to "can the human stay in the loop" (HTML as the New Markdown, Compute Allocator).

And one class flows in the opposite direction: communication calibration. The same Opus 5 guide that orders verification lines deleted orders length instructions added, because four output channels lengthened by default and effort controls none of them (Output Length Calibration). The launch-cadence pass is therefore bidirectional by design: capability scaffolding out, communication scaffolding in (Harness Shrinkage as Models Improve).

So the durable form of the thesis: "harness shrinkage" is really request shrinkage. The system prompt converges not toward empty but toward a residue of constraints, records, identity, and calibration — with the enforcement moved out of prose into mechanisms wherever possible.

Answer 2: Yes in principle — the signature is ablation non-inferiority plus inverted dose-response#

The compounding mechanism (native behavior + instruction = past the useful point) implies signals that distinguish a compounding line from both a live line and mere dead weight:

• Ablation non-inferiority (the decisive test). Remove the line; a compounding line predicts quality holds or improves while tokens fall — Anthropic's own criterion, "removing them reduces wasted tokens with no loss in quality" (Instruction Compounding). A live line degrades on removal; dead weight holds quality with negligible token change; a compounding line holds or improves quality with a large token drop. This is the falsifiable per-line test the page's own third open question names.
• Inverted dose-response (the cheap fingerprint). The behavior at the center of the biggest instances was detected empirically as performance declining at higher effort — the effort-inversion signature (Unproductive Self-Verification). The generalization: escalate the instruction (stronger phrasing, higher effort) and watch the metric; a helpful line improves or saturates, a compounding line inverts. Inversion under escalation is detectable from eval deltas without per-line ablation.
• Native-behavior baselining (the pre-filter that orders the work). For each request-form line, test whether the uninstructed model already performs the behavior — the to-do-list trajectory (aggressively prompted → spontaneous → deemphasized) is exactly this signal read manually across releases (Harness Shrinkage as Models Improve). Lines duplicating a now-native behavior are the compounding candidates; constraint-form lines can be skipped entirely (the asymmetry says they don't compound). This turns Cat Wu's read-the-whole-prompt pass into a ranked shortlist.
• What not to use: the model's own read. The same guide shows self-referential signals mislead — naming thinking tags increases leakage, i.e. surfacing the failure by name makes it worse (Instruction Compounding). Behavioral ablation beats asking the model about its prompt.

Status: the signature is identifiable from existing evidence, but no source in the corpus has automated it — the per-release compounding list remains hand-curated, and token-count telemetry as a continuous monitor (verification inflation showing up as step/token growth on fixed tasks) is proposed here, not measured anywhere. Partially answered.

Answer 3: The bet is a cheap call option on the release cadence — a stall costs the premium, not the firm#

"Build for the next model" fails gracefully because of how its own proponents structure it (Build for the Next Model):

• The downside is bounded by prototype economics. The strategy is explicitly a portfolio of cheap prototypes — "list everything, prototype all of them, let the others sit and bake, retry at each model leap" (Ambrosino). Prototypes-in-waiting are option premiums; a stall means the options expire unexercised, and the loss is the (deliberately small) prototyping cost — provided the team kept demand validation separate from capability betting (the Build for the Next Model/problem-solution-fit reconciliation: the prototype answers capability risk, never market risk).
• Effective capability keeps rising for a while after training-side progress stops. Latent Capability Overhang is the hedge: released models already do far more than anyone has extracted, and extraction (scaffolding, test-time compute, cost-down) continues improving without a new release. A stall in the release cadence is not an immediate stall in what products can ship — the frontier moves from "wait for the model" to "mine the model," the overhang page's own flip side of this bet.
• The crutch becomes correct engineering again. The strategy's core claim is that engineering around a capability gap is a depreciating asset because the next release deletes it. Remove the cadence and the depreciation stops: "wait for the model" gaps reclassify as durable-harness gaps, and the previously-wrong move — building the compensating scaffolding — becomes right. Ambrosino's "too AGI-pilled for the moment" correction (match the interaction shape to present capability, as Claude Code's local question-asking form did) stops being a waypoint and becomes the standing posture.
• The competitive surface shifts to the durable layers. In a stalled-but-diffused future, differentiation stops coming from surfing the capability frontier and moves to what never migrated inward anyway: verification infrastructure, org-specific record, identity, and human-facing legibility (Answer 1's survivor classes; Where Does Agent Harness Work Remain Durable as Models Improve?). Harness re-accretes to the equilibrium the frozen capability level sets, the launch-cadence pruning pass stops finding lines to cut — and instruction compounding stops worsening, since no new native behaviors appear beneath stale instructions.

So the asymmetry that makes the bet rational survives the stall scenario: calibrated to the next concrete release (not an AGI strawman), with cheap prototypes and separated market validation, the strategy pays a small known premium in the stall world and captures the release in the world where the cadence holds. What it does not survive is miscalibration — shipping products whose core loop depends on absent capability, which is vaporware in both worlds.

One consolidated takeaway#

The three answers share one spine: sort scaffolding by what it encodes, not by what it looks like. Task priors (behavior requests) migrate inward, expire, and then invert into harm — so they need a per-release detector, and the ablation/dose-response signature is that detector's spec. Boundaries, records, identity, serving structure, and human-facing legibility never migrate, so investment there is stall-proof. And the product strategy built on the migration (build for the next model) is safe exactly insofar as its bets are confined to the migrating class and priced as options — the moment a bet's downside exceeds a prototype's cost, it has wandered into the durable class and should be engineered, not awaited.