The Drift Audit
Why anti-drift critique cannot be triggered from inside the system it inspects
The previous piece argued that the nudge layer changed the cadence by teaching the system to simulate the boundary of intent before acting. That was the visible win.
There was a quieter one underneath it.
For a long time, fresh-context critique had been doing two jobs at once. It was the anti-drift mechanism: independent reconstruction of the project from durable truth, run against the repo and the grounding note, designed to surface what the working thread could no longer see. But it had also become, by accident, the way the system figured out what to do next.
The two jobs are not the same.
Anti-drift inspection asks whether the project’s own self-map has slipped against reality.
Next-direction discovery asks what to do tomorrow morning.
They had collapsed into one mechanism because there was no smaller instrument available. Whenever the next move was unclear, the only legible escalation was a full fresh-context critique. That made fresh critique heavier than it needed to be, and slightly confused about its own purpose.
The nudge layer separated the two.
That separation made the audit visible again.
The accidental job
Before the nudge existed, the rhythm was simpler and worse.
The thread would reach an unclear pause. The work could not be auto-chained, but the question was not yet sharp enough to put to the operator. The system would default to the heaviest available instrument: spin up fresh threads, hand them the repo and the grounding note, and ask them to reconstruct the project from scratch.
Sometimes the critique would surface real drift.
More often it would just produce a sharper next-step proposal.
That was useful, but it was not what fresh critique is for. The instrument was being used as a next-direction finder because nothing lighter existed. Each invocation cost more than it should have, and every invocation slightly muddied what the instrument was supposed to mean.
What the nudge took over
The nudge layer is a smaller control surface in three rungs.
The minimal nudge is one question. What additional external source of intent or direction is needed next? It runs at every local plateau. It returns a classification, often “none — the durable sources already supply the premise; the next move is implied.” That answer is a successful result. The system continues.
The structured nudge is heavier. Seven outcomes, classified explicitly: continue, sequence, attempt, absorb, synthesize, ask, fresh-critique. It is used when the minimal nudge is too ambiguous, or when the thread has started to sprawl and the boundary needs to be named in words.
The externality-decision nudge is heavier still. It adds an explicit choice about whether the next move requires externality at all, and if so, what kind: synthesis from current durable state, fresh-context critique, new operator input, or simultaneous operator critique plus fresh reconstruction. It is used at serious pause points where the question is not what to do next but whether the next thing should come from inside the thread at all.
Only the minimal nudge is default cadence.
The other two are non-default routing instruments. They exist for situations where the minimal nudge cannot cleanly classify the boundary.
This matters because, before the ladder existed, every pause routed to the same instrument, regardless of altitude.
What fresh critique is actually for
With the ladder in place, fresh critique can be what it was supposed to be.
Independent reconstruction. The critic thread is given the repo and the grounding note and nothing else. No working-thread explanations. No accumulated narrative. No reassurance about why the current shape is correct.
The critic reads durable truth and rebuilds the project.
The reconstruction is the work. The reconstruction is what surfaces ceremony, stale navigation, overclaimed architecture, weak naming, missing proof, mismatched source-of-truth boundaries. The critic does not need to know the project’s history to find these things — the durable sources should be enough on their own. If they aren’t, that is also useful information.
Fresh critique is not a general “what should we do next?” mechanism.
Fresh critique is a way to test whether the project’s own self-map has drifted from the reality the durable sources describe.
The nudge layer doesn’t make fresh critique obsolete. It makes fresh critique precise.
Why anti-drift cannot be self-triggered
Here is the load-bearing idea.
If the purpose of critique is anti-drift, then an inside-the-thread deterministic trigger is suspect. It risks letting the possibly-drifted system decide when it deserves drift inspection.
A system that knows it has drifted can ask for inspection. But the case worth worrying about is the system that does not know.
A drifted self-map is precisely the kind of artifact that produces locally coherent next moves and globally questionable cumulative state. Each move feels correct. Each artifact looks reasonable. The trouble is below the visible surface, in the slow slippage between what the project claims to be doing and what the durable sources actually say.
A system in that state will not reliably trigger its own audit. It will more likely conclude that everything is fine, because everything looks fine from inside.
The right shape is asymmetric.
The system can nominate a fresh critique. It can detect plateau, raise the flag, surface concern, point at suspect coherence. That nomination is valuable. It would be wasteful to pretend the system contributes nothing to the trigger.
But ASK authorizes it.
The final pull of that lever stays external because drift detection cannot be fully entrusted to the system being inspected. The audit earns its value from externality. The moment the audit’s trigger comes from inside, the audit starts to inherit the drift it is meant to detect.
Milestones are evidence, not triggers
A natural failure mode would be to attach fresh critique to project milestones.
It feels procedurally clean. A major milestone closes; therefore run fresh critique. Each major closure earns an audit. The cadence is predictable. The operator does not have to keep deciding.
But this collapses the whole point.
If critique exists to test whether the project’s self-map has drifted, using the project’s own milestone state as the trigger begs the question. The milestone is part of the self-map. Whether the milestone marks a real closure or a ceremonial one is exactly the kind of thing critique might be needed to inspect.
A milestone can raise the probability that an audit would be useful. It is admissible evidence. It is not, by itself, the trigger.
The trigger is operator discretion, informed by the system’s nominations but not bound by them.
This is also why the trigger cannot live in the workflow rules. Run fresh critique after every milestone would be a procedural answer to a non-procedural problem. The non-procedural problem is: who, structurally, is in a position to decide that the project’s self-map should be reconstructed from outside?
The answer is not the system.
Fresh thread is not fresh critique
The distinction worth holding clearly:
A new advisor thread is sometimes needed for practical reasons. Long thread state degrades. Context windows fill. The interaction quality starts to slip. The cure is mechanical: open a new thread, supply the standard initial prompt, run the minimal nudge, continue work.
That is fresh thread.
Fresh critique is something else. It is the explicit anti-drift instrument: critic threads given only the repo and the grounding note, prompted to reconstruct the project from durable truth, run with the deliberate purpose of testing the current self-map.
The two are easy to confuse because both involve starting over.
But the cost is different. The purpose is different. The trigger is different.
A new advisor thread because the previous one got long should not automatically reach for the externality-decision nudge, and should certainly not automatically start fresh-context critique. The natural restart is: default plumbing prompt, then minimal nudge, then continue.
The heavier instruments are reserved for the cases that warrant them.
The ladder
The current shape is four layers, each with a distinct job:
minimal nudge — regular-cycle prompt; default motion; preserves the advisor’s organic synthesis when durable intent is sufficient
structured nudge — non-default routing instrument; used when the minimal nudge cannot classify the boundary
externality-decision nudge — non-default reset / externality-routing instrument; used at serious pause points to decide whether the next move comes from inside or outside the thread
fresh-context critique — ASK-authorized anti-drift mechanism; the audit, not the next-step finder
The ladder is not procedural. None of the rungs are mandatory. The cost rises with each step. The minimal nudge is cheap; the audit is expensive and intentionally so.
The cadence had to be written down — in the method articulation, in the grounding note as advisor calibration — because otherwise the instruments collapse into one another. Without explicit calibration, “fresh-context critique” would have drifted back into “what should we do next?” There is gravitational pull toward heavier instruments whenever lighter ones feel uncertain. The calibration is what holds them apart.
That calibration is reference context, not formal normative doctrine. It records the lived distinction so that future work can read it and remember why the rungs exist.
Ceremony spiral
A risk worth naming.
A system with this many instruments can produce a bad rhythm: artifact → absorption → nudge → synthesis → absorption → nudge → synthesis — every instrument firing, every plateau routed, the cadence dense with ceremony, and no substantive architectural pressure in between.
That is ceremony spiral. The instruments become their own work product.
The good rhythm is the opposite shape: substantive architectural pressure → bounded absorption → minimal nudge → next pressure. The minimal nudge does its work and gets out of the way. The heavier rungs appear only when warranted. The audit is rare.
The recent rhythm on the worked-example project illustrates the difference. A bounded absorption after a major artifact landed; a heavier routing instrument used when a serious pause point arrived; an external synthesis from current durable state into a milestone closure; the minimal nudge resumed regular motion after; a new design surface landed; the minimal nudge again routed a quiet absorption.
That sequence works because the heavy instruments fired once each, at the right moments, and yielded back to the default cadence afterward. The system did not stay in heavyweight mode. The architectural pressure remained the load-bearing element. The instruments stayed proportional.
If the ratio inverts — more instrument cycles than architecture cycles — the ladder has become its own ceremony.
The stack learns what each layer is for
I keep coming back to the idea that intelligence in this kind of system is a property of the stack, not the model.
The base model proposes. The grounding note holds context. The repo holds state. The rules hold workflow. The advisor surface holds exteriority. The nudge layer simulates boundary checks. The critique layer audits the self-map. The operator authorizes the audit.
None of these elements is novel in isolation.
What changes is which layer acts when.
A young stack uses every instrument for everything. A mature stack lets each instrument do its actual job. The nudge becomes the nudge. The audit becomes the audit. Fresh threads stay separate from fresh critique. Milestones become evidence rather than triggers. Operator discretion becomes structural rather than procedural.
Max Bennett’s account of intelligence as layered evolutionary accumulation has the right shape for this. New layers do not merely add capacity. They reorganize what the layers beneath them can do. The nudge layer reorganized what fresh critique is for. The result is not that critique became less important. The result is that critique became more precise about its own role.
Simulation is part of what makes the stack work. The system can simulate the boundary of intent before acting. That is what the nudge does.
Anti-drift, though, requires something simulation alone cannot supply.
It requires exteriority.
Closing
The point is not to make the system decide when it has drifted. The point is to make the system legible enough that it can nominate drift inspection — and disciplined enough that the final authorization still comes from outside the drift it is meant to detect.
That is the load-bearing asymmetry.
The nomination can come from inside the workflow. The authorization cannot.
The system nominates. ASK authorizes.
The nudge ladder solved the next-direction problem. That lets fresh critique go back to being the thing it was always supposed to be: not a way of figuring out what to do next, but a way of asking, from outside the thread that has been doing the work, whether the project still means what it thinks it means.
The audit is the audit.
It earns its weight by staying rare and staying external.
The stack becomes smarter not because any layer in it has more power, but because each layer has come to understand the size of its own job.
/// /// /// ASK
meta repo https://github.com/apexSolarKiss/control-surface
worked-example repo https://github.com/apexSolarKiss/asset-pipeline-ASK
prior workflow pieces >>