Principles Are Loops

Most principles die as posters. They get written down once, hung where the operator can see them, and then quietly violated by the same operator running the same patterns the principle was supposed to break. Three months later the principle is wallpaper. Six months later the operator can't remember whether the principle was active policy or an aspirational note from a sharper version of himself.

The poster problem is not a discipline problem. It is an architecture problem. A principle that lives only in prose competes for the operator's attention with every other piece of prose he encounters during the day. The principle loses by default because prose is passive and reality is active. The principle that wins is the one that has been encoded into the operator's machinery — the one that runs whether the operator remembers it or not.

Dalio said it the cleanest:

The sentence has been quoted ten thousand times. The part everyone skips is the second half. The principle is not the algorithm; the principle becomes the algorithm. The principle stops being prose and starts being a loop the operator's machine actually runs. That's the move.

A loop, for an operator running an AI OS, is the smallest unit of recurring work that has been made runnable.

Three properties:

• 01A trigger. The condition under which the loop should fire. Time-based (every morning at 8:00), event-based (every time the operator closes a deal), state-based (every time the inbox crosses a threshold).
• 02A body. The actual work. Could be a script. Could be an agent run. Could be a structured prompt the operator's machine knows to assemble. The body produces an output.
• 03A threshold. The point at which the loop stops being autonomous and pings the operator. Sometimes that point is the start of the loop (everything HITL). Sometimes it's the end (the loop runs, the operator audits the output before it ships). Sometimes it's a confidence floor (the loop runs autonomously above some learned confidence; it routes to the operator below).

A principle that has been encoded as a loop is a principle that survives the operator's bad days. The operator forgets; the loop does not. The operator gets distracted; the loop runs anyway. The operator's attention is now a resource the machine economizes on, instead of the single point of failure that brings the whole principle down when the operator is tired.

That last sentence is the entire AI OS thesis compressed.

The first canon ratifying underneath this essay is Loops-as-Leverage, sitting under Canon 6 (Signal vs Noise / Parallel Execution Capacity).

Canon 6 says the operator's metric is PEC — how many fronts he can carry clean (zero lag, zero dropped balls, no key issues). The AI OS exists precisely to raise PEC. A static cap on front count fights the whole mission; the work is to keep raising the ceiling responsibly.

Loops-as-Leverage names the mechanism by which the AI OS raises PEC: loops are the primary lever. Every time the operator finds a recurring step that survives the kill-test — meaning it's worth doing, not worth deleting — that step gets encoded as a loop. The loop takes the work off the operator's attention budget and onto the machine's. The operator's PEC ceiling rises by exactly the recurring weight he just shed.

The discipline is harder than it sounds. Most operators encode the loops that should be killed (recurring meetings that produce no commitments; reports nobody reads). The kill-test goes first. Kill what shouldn't recur. Loop what should.

A practical heuristic: when the operator notices himself doing the same shape of work three times in a quarter, that's the signal. The principle behind the work has revealed itself by repetition. Encode the loop. The encoding is small the first time; it compounds the third and fourth time the loop runs unattended.

The second canon is HITL Thresholds-by-Category — sitting as a Canon 7 candidate, paired with Loops-as-Leverage.

Loops would be terrifying without it. If every loop the operator encoded ran autonomously, the machine would compound every error as fast as it compounded every right call. The conscience layer is the human-in-the-loop threshold: the point at which the loop hands control back to the operator.

The new canon says: HITL fires by per-category, recursively-learned thresholds that drift from conservative → risky as confidence accrues. Two principles inside that sentence are doing the work.

Per-category. A blanket HITL policy is too coarse; the operator wants different thresholds for different categories of work. A loop that drafts a marketing post and a loop that wires money should not share a threshold. The categories matter.

Recursively-learned, drifting conservative → risky. The threshold isn't static. As the loop demonstrates reliability inside a category, the threshold relaxes. As the loop demonstrates unreliability, the threshold tightens. The operator's machine learns where his judgment actually belongs and routes work to him in proportion to where it's needed.

The categories worth naming explicitly:

• 01Containerized software development. Tests in a sandbox; commits on a branch; reversible by git revert. Thresholds drift toward near-autonomy. The operator audits at the PR level, not the keystroke level.
• 02Communication and content drafts. Reversible until shipped. Mid-confidence drift; the loop drafts, the operator approves the send.
• 03Financial actions (wiring money, executing trades, signing contracts that bind). Permanent HITL floor. No threshold-drift toward autonomy, ever. The conscience layer treats these as if it were Day 1, every time.
• 04Irreversible actions (one-way doors, domain acquisitions, public commitments, brand changes). Permanent HITL floor. Same logic. The recovery cost dominates.
• 05Taste calls (the operator's voice, the design choices, the brand mark). Permanent HITL floor. The whole point of the autonomist stack is that the operator's taste is the asset; the machine never overrides it.

The taxonomy isn't theoretical. It's the operating posture every autonomist runs under, written down. Containerized work drifts to autonomy; the moments of taste and irreversibility stay in-loop. The operator's attention is reserved for where it actually compounds.

Dalio built the idea-meritocracy at institutional scale. The principles got written down, debated, encoded, run as algorithms. Bridgewater's 40-year compounding record runs partly on the alpha of the original investment thesis and partly on the machine that ran the thesis — the principles-as-algorithms layer that kept the firm thinking clearly across decades.

The autonomist translation is the same operating system, rebuilt for one operator. The principles file from Essays 01 and 02 is the source material. The decisions log from Essay 03 is the reality test. The loops are the algorithms; the HITL thresholds are the conscience. The operator is both the designer of the machine and a worker within it — exactly Dalio's frame, scaled down to a single P&L.

Three required behaviors carry across cleanly:

• 01Put honest thoughts on the table for the system to see. Every principle, every decision, every loop output goes to the file, even when the file shows the operator was wrong. The vault is for accurate truth, not flattering truth.
• 02Have thoughtful disagreements where thinking can evolve. When a loop's output contradicts the operator's gut, the contradiction is data, not failure. Sometimes the loop is right and the gut needs updating. Sometimes the gut is right and the loop needs re-encoding.
• 03Abide by idea-meritocratic ways of getting past disagreements. The canon hierarchy is the dispute-resolution stack. North star wins over meta-principle wins over personal principle wins over loop. When in doubt, the higher layer wins.

What's new in the translation is that one operator can now run all three behaviors with a machine that holds the record across sessions, threads the context across loops, and surfaces the patterns the operator's attention would miss. That capability didn't exist five years ago. It exists now. The operators who encode their principles as loops over the next decade build the cognitive infrastructure that wasn't available to Dalio's generation at this scale.

Three loops, no more. Canon 6's Law of 3 holds — the focus floor, not a ceiling. Pick three principles from the file. Encode three loops. Set three thresholds.

Examples (not prescriptions — the operator picks his own):

• 01Principle: one-way-door decisions get the full fear-setting pass. Loop: every entry tagged reversibility: one-way in decisions.md triggers the loop to surface the five tapes template and HITL on the operator to fill it before close. Threshold: permanent HITL.
• 02Principle: the principles file gets read on Sunday and reconciled against the week's decisions. Loop: Sunday 8pm, the machine assembles the week's decisions.md entries against principles.md and surfaces the gaps. Threshold: low — the operator reads the surfaced gaps and chooses what to update. Drifts toward operator-skim-and-confirm as the surfacing gets reliable.
• 03Principle: the daily inbox isn't where principle-leverage work lives. Loop: inbox triage runs on an OSS model, surfaces only the things that need the operator's judgment. Threshold: drifts toward autonomy on triage; permanent HITL on any item tagged financial / irreversible / partner-relationship.

Three loops. Three thresholds. Run them for one quarter. Audit the outputs weekly. Tighten the thresholds where the loops disappointed; relax them where the loops compounded. By the end of the quarter the operator has three principles that survived contact with reality as runnable machinery — and a calibration record on each. By year three the operator has thirty.

That's the leverage. That's the loop. That's the canon.

The autonomist's machine is the operator's principles, made to run.

Receipts. Ray Dalio, Principles (2017), Life Principle 5.11. Dalio Work Principles canon, especially “manage as someone operating a machine to achieve a goal” and “use tools and protocols to shape how work is done.” Steve Jobs, by way of Kevin O'Leary, “saying no to a thousand things is the superpower.” Gary Keller, The One Thing. Naval, “Earn with your mind, not your time.” The live canon: Canon 6 (Signal vs Noise / Parallel Execution Capacity) + the new Loops-as-Leverage and HITL-by-Category, ratifying as this essay ships.