The VVFL
What kind of loop are you running?
This is not a brand graphic. It is the logo expanded — every P&ID element opened to show what lives inside it. The question mark becomes a complete operating system for making better decisions faster.
Three Loops
Most people confuse these. The confusion costs them agency.
| Loop | Setpoint | Measurement | What Happens |
|---|---|---|---|
| Positive (reinforcing) | None | None | Runaway — doom scrolling, panic selling, addiction |
| Negative (corrective) | Defined | Yes | Control — but toward what? |
| VVFL | Values-aligned AND reality-tested | Validated against outcomes | Progress that compounds AND serves |
"Positive feedback" sounds like praise. In engineering it means amplification without correction — a microphone pointed at a speaker. No setpoint, no gauge, no control. Without a clear picture of what good looks like, you're a passenger.
The VVFL is the third kind. Not just corrective — validated (tested against reality, not just believed) and virtuous (the setpoint serves beyond self).
The Setpoint
The most important element in any control loop is the one most people skip: declaring what good looks like before the loop runs.
Karpathy's autoresearch is the proof. Three files, one metric, "NEVER STOP." The agent runs 100+ experiments overnight. Not because it's intelligent — because the constraint is clear. Constraints enable autonomy. A loop without a setpoint is a microphone pointed at a speaker. A loop with a declared northstar runs itself.
| Loop Element | Without Setpoint | With Setpoint |
|---|---|---|
| Gauge | Reads numbers that mean nothing | Reads distance from target |
| Controller | Reacts to noise | Corrects toward declared intent |
| Agent | Busy but drifting | Autonomous and converging |
The pain primitives are the gap made visible. Pain is the distance between where you are and where you declared you'd be. No declaration, no gap. No gap, no loop. The five voyage pains — no direction, no map, no ship, no mates, no compass — are five missing setpoints.
DECLARE SETPOINT → RUN LOOP → MEASURE GAP → CORRECT → REPEAT
↑ |
└──── evolve the setpoint when reality teaches ──────┘
The setpoint is not fixed forever. The outer loop evolves it. But at any moment, the inner loop needs ONE clear target to measure against. That's what turns a reinforcing loop into a corrective one, and a corrective one into a virtuous one.
Assumptions Are Micro-Setpoints
Every assumption in a plan is an undeclared setpoint. "Users will pay $50/month" is a setpoint. "The API responds in under 200ms" is a setpoint. "The generator output passes pre-commit hooks" is a setpoint.
Undeclared assumptions are unmeasured loops. They run without a gauge, without a controller, without correction. When the assumption breaks, you discover it at production time — not at planning time.
| Assumption type | Declared | Undeclared |
|---|---|---|
| Price point | Tracked against conversion data | Discovered when nobody buys |
| Performance threshold | Tested in CI | Discovered when users complain |
| Template completeness | Validated at creation | Discovered when plan produces nothing |
| Dependency existence | Checked before execution | Discovered when chain stalls |
The fix: tag every assumption with a conviction level (HIGH/MEDIUM/LOW/NONE) and a measurement method. An assumption without a measurement method is a reinforcing loop waiting to run away.
The Stations
Reading the diagram clockwise from top-left:
Capture
The hopper — where raw material enters. Inspiration, problems, ideas, signals from success and failure. Trends and capabilities flowing in.
Without capture, you run on old inputs. The system starves.
Priorities
The filter between capture and action. Disagree with integrity. Record decision logic. Commit your capital. Not everything that enters the hopper deserves the pump.
Attention
The pump — what drives flow through the system. Focused. Collaborative. Coordinated. This is where agency meets action. The pump doesn't care about quality — that's the filter's job. The pump cares about movement.
Value
Where first principles transform state. Raw attention becomes directed effort. The pump creates motion; value gives it direction.
Systems
The feedback mechanism at the base. Automate to reduce decision fatigue. Trigger processes to adjust tactics. Adapt and adjust — this is where the loop becomes self-correcting rather than one-shot.
Standards
The gauge — raise the platform. Without measurement, you can't know if the loop is working. Standards are what make improvement systematic rather than accidental. The gauge reads reality.
Distribute
Maximize benefit, minimize waste. Goodwill compounds here — what you distribute returns. This is what makes the loop virtuous rather than merely corrective. Extraction breaks loops. Distribution strengthens them.
Reflect
The controller — practice asking deeper questions. The controller reads the gauge, compares measurement to setpoint, and asks: is this where we should be? Perspective is the controller's output.
The Record: The Controller's output is not just a decision — it is a decision trace. That trace is the node in your context graph. See The Mycelium for how Systems of Decisions capture this.
Evolve
Change the game. Not just improve within the current frame — question whether the frame itself is right. This is where the loop compounds rather than merely repeats.
The Center
Flow. Make connections.
When all stations are running clean — capture feeding priorities, attention driving value, systems enabling standards, reflection driving evolution — the center holds. That's flow state. Not luck. Architecture.
Why Not Politics?
Nobody in power wants to make decisions. They want enough votes to stay relevant. Consultancies exist because "no one ever got fired for hiring McKinsey" — outsourced accountability dressed as expertise. This is not a control system. It's a reinforcing loop of self-preservation.
Politics is what happens when systems fail.
When feedback loops break — when the gauge is ignored, the filter is corrupt, the controller is absent — you get committees, votes, and lobbying instead of measurement, correction, and progress. The idea that governments will decide how to control AI is a fantasy. The people making those decisions have spent careers distancing themselves from decisions.
| Political Loop | VVFL |
|---|---|
| Optimize for staying in power | Optimize for goodwill |
| Outsource accountability | Own the measurement |
| Enough votes to remain relevant | Enough trust to remain useful |
| Top-down control | Bottom-up coordination |
The answer is not waiting for someone to save you. The answer is talking to your neighbours. Using tokenomics and tokenisation to share ownership in important assets and distribute the value that comes from them fairly. Futarchy — backing decisions with bets rather than votes — replaces opinion with skin in the game. Building culture at the community level where feedback loops are short enough to actually work.
Intelligence is no longer a competitive advantage. AI leveled that field. Culture is. And the strongest cultures are judged by how they look after their weakest. See Governance for what happens when we try to build systems that don't fail.
The Gauge
A loop without a gauge is motion. This section is the gauge — the outcome map filled in, the picture we measure against.
Three Signals
| Level | Signal | Proxy | Proves |
|---|---|---|---|
| Self | Decisions improve | Choices that reference the model | The system works for its builder |
| Transfer | Better questions out than in | Link depth from entry point | The architecture creates value |
| Compound | Connections create emergent value | Cross-referral from /meta/ into /docs/ | Links are edges, not decoration |
Level 1 before Level 2. Level 2 before Level 3.
Success Measures
Binary. Did we or didn't we.
- Someone traverses Journey → Science → Standards → Systems → Scoreboard → Journey
- Someone fills a template and shares the output
- A meta article generates conversation that references
/docs/ - Three decisions improved by externalizing the mental model
Evidence Loop
| Cycle | Hypothesis | Outcome | Better Question |
|---|---|---|---|
| 1 | Cross-linking nav sections creates traversal |
Fill this table. The empty cells are the gauge reading.
OODA Is VVFL
Boyd's OODA loop (Observe → Orient → Decide → Act) is the VVFL compressed to four stations. Same loop. Different vocabulary. Same center.
| OODA | VVFL Station | Control Function | The job |
|---|---|---|---|
| Observe | Capture | Hopper | What signals are entering the system? |
| Orient | Priorities + Standards | Filter + Gauge | What do the signals mean against what we measure? |
| Decide | Reflect | Controller | What's the one correction that matters most? |
| Act | Attention + Value | Pump + Transform | Execute. Change state. Ship. |
| (loop) | Systems + Distribute + Evolve | Feedback | Did it work? Distribute the gain. Evolve the setpoint. |
Boyd's insight: the side that cycles faster wins. Not the side with more information. Not the side with better plans. The side whose loop runs tighter — shorter time from observation to action, faster feedback from action to next observation.
The VVFL adds what Boyd left implicit: the setpoint (what "winning" looks like) and the gauge (validated measurement, not just observation). OODA without a setpoint is fast reaction to noise. VVFL with OODA speed is fast convergence toward declared intent.
Tool Adoption
The fastest-moving affordance in any knowledge worker's stack is their AI coding environment. Features ship weekly. Practitioners innovate daily. A configuration that was optimal last month leaves potential on the table today.
Apply the VVFL:
| Station | Applied to tool adoption | Cadence |
|---|---|---|
| Capture | Scan changelog, practitioner feeds, community innovations | Daily |
| Priorities | Map each new feature against current configuration. Score each affordance 0-5. Which gap is largest? | Daily |
| Attention | Pick ONE feature. Not a batch. One. | Per cycle |
| Value | Test it now. In this session. Not "investigate later." Load the tool, run the command, try the config. | Per cycle |
| Systems | Did it work? Update the baseline. If it failed, note the blocker. | Per cycle |
| Standards | Track affordance utilization over time. The gauge reads: what percentage of your tool's potential are you extracting? | Weekly |
| Distribute | Share what worked. Document the pattern for the next person. | Weekly |
| Reflect | Did the adoption process itself work? What did you have to improvise that should be baked in? | Monthly |
| Evolve | Improve the adoption procedure. The loop that adopts tools should itself be adopted by the loop. | Monthly |
The inner loop (daily) cycles in minutes: observe one feature → test it → adopt or reject. The outer loop (monthly) evolves the adoption process itself. That's recursion — the loop improving the loop.
The failure mode this prevents: Listing 17 new features, creating a deployment plan with four phases, and executing none of them. Batching kills loops. Cycling one feature at a time through the full VVFL keeps the loop alive.
The origin lesson: Writing "I don't know what the mechanism is" while the mechanism was listed in your own tools. The gauge was there. The capture was there. The filter never ran. If you don't cycle the loop, the loop doesn't exist — no matter how well you've drawn the diagram.
The Bottom Line
Make better decisions faster.
Each cycle through the loop:
- Sharpens the questions (better inputs)
- Strengthens the filter (clearer principles)
- Focuses the pump (more directed action)
- Raises the gauge (higher standards)
- Deepens the controller (wiser reflection)
The loop doesn't guarantee good outcomes. It guarantees that each failure makes the next attempt better. That's what separates the VVFL from hope.
Context
- Outcome Map — The blank version of the gauge section above
- The Logo — The compressed version: four P&ID shapes forming a question mark
- Control System — PID mechanics: setpoint, sensor, controller, actuator
- VVFL Loop — Standards as the compounding force
- Pain Primitives — Five voyage pains: five missing setpoints
- Agency — The capacity the loop builds
- Flow State — What happens when all stations run clean
Questions
What is your setpoint — and who declared it?
- If your loop has been running for months without converging, is the loop broken or is the setpoint missing?
- What changes when you name ONE metric instead of five?
- Which of the five voyage pains is the setpoint you haven't declared yet?
- When the outer loop evolves the setpoint, how do you know the new target is wiser than the old one?