Error Signal

What It Is

An error signal measures the difference between an intended state and the actual state in a form the system can act on. It needs three parts: a declared target, a measurement, and a readable comparison between them.

A thermostat subtracts its thermometer reading from the setpoint. A compiler compares a file with the language's grammar and names the offending line. A test suite turns red. A market price reports the running difference between how much of something exists and how much people want. Participants correct against it without anyone administering the whole loop.

Try removing one part. Without a target, the measurement is just data: a number with no direction. Without a measurement, the target is an aspiration: a direction with no position. Without a readable comparison, the difference exists but cannot drive a correction. For control purposes, that is equivalent to having no signal.

Cybernetics puts this comparison in the control loop. Gradients relates learning rate to the signal's strength. Invokable structures asks whether anything can respond to it. In most of life, you have to construct the signal before any of those operations can happen.

A closer look

Build a usable error signal

Without a target, data has no direction; without measurement, the target has no position to compare against.

Read this diagram

Declare the target → Measure the actual state → Compare the two → Make a correction → Measure again.

No Signal, No Learning

Iteration changes the next attempt according to the previous attempt's measured error. Without the error term, you repeat the trial without a basis for correction. More effort alone does not turn repetition into learning.

Ten years of cooking without tasting is one year repeated ten times. A gym program run for months without logging the load is not training toward anything. The unnoticed plateau begins with lost measurement; improvement stops somewhere in the period you were no longer observing.

The learning gradient is the error signal. Where the signal is zero, the landscape is flat, so movement is a random walk regardless of the effort behind it.

The same requirement applies to maintaining a state. Unmeasured disturbances accumulate, and a process drifts from where you left it. Without measurement, the mechanism cannot distinguish stability from slow drift.

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

A thermostat and a compiler arrive with a way to report error. A test suite has one because you wrote it. Most life and work domains arrive without a target, measurement, or comparison. Nobody supplies a red test for whether your writing improved this month, your relationship is deteriorating, or your venture is closer to working. The domains that matter most are the ones without instruments.

You therefore need to build the signal, not just learn to read it:

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

Declare a target concrete enough to miss. Make the measurement easy enough to run routinely. Present the comparison in a form that suggests the next correction.

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

A tracked prediction can create an error signal for any decision. Without a prediction recorded beforehand, hindsight can supply a target that makes the outcome look intended. Write the expected outcome first, and your later self cannot quietly move that target. The result has something fixed to be compared against.

Self-judged domains specifically need a counterparty. When the same process chooses the target and scores its attempt, it always finds an approving interpretation of the evidence. An external judge supplies the only comparator you cannot renegotiate from inside that process. Its purpose is to make the comparison hold.

Properties of a Good Error Signal

A constructed signal is useful only if the system can afford to compute it and act on what it reports:

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

Aim the daily signal at a variable you can change. If it reports a gap but no available action can close it, the loop produces anxiety instead of adjustment. Revenue, for example, lies several causal steps beyond today's actions. Track the countable upstream acts that are yours to perform. Still measure revenue, but use it to calibrate the model connecting those acts to the outcome, rather than as the daily setpoint.

Speed and cost determine how often the loop can run. A comparison that takes a minute allows thousands of corrections while a quarterly comparison allows one. A crude, fast signal therefore usually beats a rich, slow one: many small corrections to an approximate measurement outperform one correction to a precise description of a state that has already changed.

The Loop: Signal → Correction → Recompute — and Caching

Compute the signal by comparing the measurement with the target.
Correct the state in response to the difference.
Recompute on the changed state to confirm that the error closed and find the next one.

Recomputation makes feedback constant rather than occasional. The value is the continuing assurance that each pass will measure deviations. This is also the cost you keep paying, which is why the comparison must be cheap.

Some of that work can be cached. When a resolved error generalizes, retain its resolution as a rule. A fixed bug becomes a test, so checking for it requires no further judgment. A rejected draft becomes a named rejection in a ledger. A recurring lapse becomes a standing boundary. You can direct live attention to new errors while the retained comparisons keep checking the old ones.

The ratchet describes a gain that is both made and held. Its pawl corresponds to this cache: the mechanism that prevents reopening a closed error. The lockfile applies that approach to judgment through a golden set, verifier, and rejection ledger. Pinning and versioning them lets “good” recompute identically next year on another system.

You can judge a domain's maturity by how much error-checking runs from these stored comparisons and how much still demands a fresh judgment on every 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)

“Do your best” removes all three requirements for an error signal. There is no target concrete enough to miss, no measurement that settles compliance, and no comparison to make. It creates questions the recipient cannot answer.

“Be more disciplined,” “care more,” and “raise the quality bar” fail in the same way. They sound like targets but do not distinguish a state that would satisfy them. Ask of any instruction, to yourself or another agent: what observation would settle whether it was followed? Without an answer, it supplies no signal, closes no loop, and produces no change.

Integration with the Mechanistic Framework

Connection to Cybernetics

The five-component control loop contains the mechanism. Sensors and a goal state produce the error signal; actuators consume it. Each of the listed ways a feedback loop can break prevents the signal from completing this circuit.

Connection to Gradients

Signal quality determines gradient strength. Strong, clear signals produce steep gradients and fast learning; weak, noisy ones produce shallow gradients and random walks. Before comparing their strength, you have to build a signal in a domain that has none.

Connection to Ratchet and Lockfile

A ratchet retains a closed error so it does not cost fresh work again. The lockfile stores judgment in versioned, recomputable form: golden set, verifier, and rejection ledger. The signal produces the gain; the retained comparison holds it.

Connection to Counterparty

A counterparty holds the comparison outside your own judgment. When you set the target and score the attempt yourself, you can rig the result. The external judge supplies a difference you cannot renegotiate internally.

Connection to Spell-Packet

A functioning instruction must name a distinguishable target state so deviation can be computed. “Do your best” fails that requirement. It is both a failed spell-packet and an instruction with no error signal.

Connection to EV Sensor Calibration

Motivation reads out a learned value estimator. That estimator trains only on lived action→outcome pairs: the difference between predicted and realized value. A life with few constructed error signals starves it of training data, leaving the felt motivation sensor with little recent evidence.

Connection to Invokable Structures

A goal is valid only when some structure can respond to its error signal. Without a mechanism to absorb the difference, it becomes anxiety. Constructing a signal and constructing what answers it are both necessary.

Connection to Legibility

Agents can act only on what they can read. A true but unreadable difference is useless for control. Installing instrumentation that makes the difference visible supplies something persuasion alone cannot.

Connection to Taste Compilation

A felt verdict is an error reading from a comparator running on one person's mind. Taste compilation turns that verdict into rules, exemplars, and verifiers that can run elsewhere. It applies the caching step to judgment.