error-signalcore-frameworksystem-design

Error Signal

What It Is

An error signal is the measurable delta between intended state and actual state that a system can act on. Three parts, each load-bearing: a declared target (the setpoint, the spec, the goal state), a measurement of where the system actually is, and a comparison whose output is legible enough to drive the next correction. The thermostat's error signal is setpoint minus thermometer reading. The compiler's is the diff between the grammar and your file, printed with a line number. The test suite's is red. A market price is an error signal the size of an economy: it is the running delta between how much of a thing exists and how much is wanted, and every participant corrects against it without anyone administering the loop.

Delete any of the three parts and the signal is gone. No target, and measurement is just data — a number with no direction attached. No measurement, and the target is just an aspiration — a direction with no position. No legible comparison, and the delta exists but nothing can act on it, which for control purposes is the same as its not existing.

The term is the missing keystone of the feedback vocabulary. Cybernetics puts "compute error signal" at the center of every control loop; gradients says learning rate is proportional to its strength; invokable structures defines a valid goal as one whose error signal something can answer. This page is about the object itself: what it is, why nothing improves without one, and — the part the textbook control loop omits — the fact that in most of life you have to build it.

No Signal, No Learning

A loop without an error signal is repetition, not iteration. The distinction is mechanical, not motivational: iteration means each pass differs from the last as a function of the last one's measured error. Remove the error term and the passes have nothing to differ by — you are running the same trial again with fresher fatigue and calling it practice.

This is why the quantity of effort in a domain predicts improvement so poorly. Ten years of cooking without tasting is one year of cooking, ten times. A gym program repeated for months without a logged load is not training toward anything; the lifter who plateaus without noticing has not stopped improving — they have stopped measuring, and the improvement stopped somewhere in the unmeasured dark. Gradients gives the formal version: the learning gradient IS the error signal, and where the signal is zero the landscape is flat — movement in a flat landscape is a random walk regardless of how energetically you move.

The same holds for systems that are not trying to learn, merely trying to hold position. A process with no error signal does not stay where you left it; it drifts, because every unmeasured perturbation accumulates. Nothing in the mechanism distinguishes "stable" from "drifting slowly" until a measurement does.

Loop	With error signal	Without
Practice	Each rep corrects the last rep's measured miss	Reps accumulate; skill doesn't
Software change	Red test names the break	Regression discovered by users, months later
Body maintenance	Blood panel deltas against reference ranges	"I feel fine" until the condition is advanced
A market	Price moves; producers and buyers correct	Shortages and gluts persist invisibly
Holding a standard	Deviation measured, corrected	Drift, discovered as a crisis

The Design Problem

The textbook loop assumes the error signal exists. A thermostat ships with one; a compiler ships with one; a test suite is one you wrote. But most life and work domains ship with no error signal at all — no setpoint, no measurement, no comparison. Nobody hands you a red test for "is this piece of writing better than last month's," "is this relationship deteriorating," "is this venture closer to working." The domains that matter most are precisely the ones that arrive uninstrumented.

So the operative skill is not reading error signals — it is constructing them. The design problem, stated as an instruction:

"Figuring out how we can create an error signal that we can have a constant loop on — recomputation and caching."

Construction means installing the three parts the domain didn't ship with. Declare a target concrete enough to miss. Build a measurement that runs without heroics. Make the comparison legible enough that the next action follows from it. The standard constructions:

Construction	What it installs	Domain it instruments
Test	A machine-checkable predicate over an artifact	Software, any generated output with a verifier
Metric with a target	A tracked number against a declared setpoint	Body weight, spend rate, output volume
Recorded verdict	A judgment written down, so future output can be compared to it	Taste domains — writing, design, quality (taste compilation)
Named counterparty	An external judge who adjudicates "done" and "good"	Deadlines, standards, anything self-judgment rigs (counterparty)
Tracked prediction	A pre-registered expected outcome, compared against the actual one	Decisions, models of the world — the delta is unfakeable because the prediction was written before

The last row deserves emphasis because it manufactures an error signal out of any decision. A choice with no pre-registered prediction can always be narrated as correct afterward; hindsight supplies whatever target makes the outcome look intended. Write the expected outcome down first and the comparison becomes honest — you have installed a setpoint that your later self cannot quietly move.

Self-judged domains need the counterparty construction specifically, because a loop where the same process sets the target and scores the attempt has a rigged comparator: the judge always finds a reading of the evidence that approves. The external agent is not there for accountability theater; they are there because they are the only comparator you cannot argue with from inside.

Properties of a Good Error Signal

Not all constructed signals are worth having. The engineering criteria:

Property	Why it matters	Good	Bad
Fast	Correction quality decays with delay; a slow signal reports on a system that no longer exists	Compiler error at save	Annual review
Cheap to recompute	The loop runs at the frequency you can afford to measure; expensive signals get computed once and go stale	Test suite on every commit	Focus-group study per change
Legible	The delta must be readable enough to imply the next correction	"Line 47: null check missing"	"Something feels off"
Hard to game	A signal you can move without moving the underlying state stops carrying information	Money paid, weight on the bar	Vanity metrics, self-graded rubrics
Aimed at the controllable layer	The signal must land on a variable your actuators can actually move	Reps completed, calls made	Outcomes three causal steps downstream

The last property is the subtle one. A signal on a variable you cannot influence produces error without producing correction — the loop fires and nothing legal absorbs it, which the organism experiences as anxiety rather than adjustment. Instrument the layer where your actuators live: not "revenue," which today's actions touch only through a long causal chain, but the countable acts that are upstream of it and fully yours to move. The uncontrollable outcome still gets measured — but as calibration for the model, not as the setpoint of the daily loop.

Speed and cost jointly set the loop frequency, and loop frequency compounds: a signal that recomputes in a minute permits thousands of corrections in the time a quarterly signal permits one. When choosing between a rich slow signal and a crude fast one, the crude fast one usually wins — many small corrections against an approximate measure outperform one large correction against a precise measure of a state that has since moved.

The Loop: Signal → Correction → Recompute — and Caching

The full cycle has three strokes and a memory:

Signal — the comparison runs; the delta lands.
Correction — the system moves against the delta.
Recompute — the comparison runs again on the corrected state, confirming the error closed and exposing the next one.

Recomputation is what makes the signal constant rather than occasional — the loop's value is not any single reading but the standing guarantee that deviation gets measured on every pass. This is why "cheap to recompute" sits in the properties table: the recompute step is the one you pay for forever.

But a loop that only recomputes is condemned to re-derive old verdicts at full price on every pass. The missing operation is caching: when an error closes and its resolution generalizes, bank the verdict as a rule so the loop never re-pays for it. The fixed bug becomes a test — that error is now checked mechanically, at zero marginal judgment, forever. The rejected draft becomes a named rejection in a ledger; the recurring lapse becomes a standing boundary. Live attention migrates to the frontier — the errors that are still new — while cached comparisons hold the territory behind it.

Caching is where this page hands off to its neighbors. The ratchet is the general law of banked gains — errors closed AND held closed — and the cache is exactly the pawl: the mechanism that makes re-losing a closed error illegal. The lockfile is the mature form of the cache for judgment domains: golden set, verifier, and rejection ledger are all cached error signals, pinned and versioned so that "good" recomputes identically next year on whatever system runs it. A domain's maturity can be read off this ratio: how much of its error-checking runs from cache versus how much still requires live judgment per pass.

Failure Modes

Failure mode	Mechanism	Signature	Fix
No signal	Loop runs open; deviations accumulate unmeasured	Drift — discovered late, as a crisis that was years in the making	Construct one (see the design table); crude and fast beats absent
Noisy signal	Delta is mostly variance; system corrects against noise	Thrash — perpetual course changes, no net movement	Aggregate samples; fuse multiple independent sensors before correcting
Gamed signal	The measure is optimized instead of the state it proxies	Goodhart — metric improves while the domain decays	Pick harder-to-game measures; rotate proxies; audit against ground truth
Signal on the wrong variable	Instrumenting what is measurable instead of what is controllable or causal	Optimizing the thermometer — the reading improves, the room stays cold	Re-aim at the controllable layer; treat downstream outcomes as calibration, not setpoint
Signal ignored	Measurement exists but never reaches the actuators	Dashboards nobody acts on; data as decoration	Wire the reading to a decision point; a signal that changes nothing is overhead
Zero-error-signal instruction	A directive that defines no target state, so compliance is uncomputable	"Do your best" — the loop it initiates can never close	Every instruction must name a distinguishable state (spell-packet)

The last row is the linguistic form of the whole page. "Do your best" is the canonical bad instruction because it is an error signal with all three parts deleted: no target concrete enough to miss, no measurement that could settle compliance, no comparison — only spawned, unanswerable questions. Whole categories of guidance fail this way: "be more disciplined," "care more," "raise the quality bar." Each is a setpoint-shaped noise. The audit for any instruction, to yourself or any agent: what observation would settle whether this was followed? No answer, no signal; no signal, no loop; no loop, no change.

Integration with the Mechanistic Framework

Connection to Cybernetics

The parent frame. The five-component control loop is the machine this page's object runs inside: sensors and goal state exist to produce the error signal, and actuators exist to consume it. A broken feedback loop is, in every listed variant, an error signal failing to complete its circuit.

Connection to Gradients

The strength dimension. Gradient strength is error-signal quality: strong clear signals make steep gradients and fast learning; weak noisy signals make shallow gradients and random walks. This page adds the construction problem — gradients assumes a signal to measure the strength of; most domains require you to build one first.

Connection to Ratchet and Lockfile

The cache. A ratchet banks a closed error so the loop never re-pays for it; the lockfile is the versioned cache for judgment domains — golden set, verifier, and rejection ledger as pinned, recomputable error signals. Signal generates the gain; the lock holds it.

Connection to Counterparty

The comparator you cannot rig. Self-judged loops fail because the same process sets the target and scores the attempt; a counterparty is an externally held error signal — the judge whose delta you cannot renegotiate from inside.

Connection to Spell-Packet

The linguistic instance. A functioning spell must emit an error signal — name a target state distinguishable enough that deviation is computable. "Do your best" is that page's type specimen of a bad cast and this page's type specimen of a zero-error-signal instruction; same defect, two lenses.

Connection to EV Sensor Calibration

The inner instrument. Motivation is the readout of a learned value estimator trained only on action→outcome pairs — which are exactly error signals: predicted value against realized value, lived. A life poor in constructed error signals starves that estimator, and the felt result is a motivation sensor with nothing recent to go on.

Connection to Invokable Structures

The consumption side. A goal is valid only if structures exist that can respond to its error signal; a delta with no mechanism to absorb it dissipates as anxiety. This page builds the signal; that page builds what answers it.

Connection to Legibility

The readability requirement. Agents act on what they can read, not on what is true — so an illegible delta is no delta, for control purposes. Instrumentation over persuasion is error-signal construction under another name.

Connection to Taste Compilation

The judgment pipeline. Felt verdicts are raw error readings from a comparator that runs on one processor; compilation converts them into recomputable form — rules, exemplars, verifiers — which is precisely the caching step of the loop, applied to taste.