THE MACHINERY OF THE CLOSED LOOP
THE PRACTICAL
You told someone to do something. You believed they would. Three days later, you discover they did not. You are frustrated. But ask yourself: how were you supposed to know? Nobody told you it did not happen. You only found out because you checked. If you had not checked, you still would not know.
That is not a team problem. That is a system without eyes.
This document is the practical companion to THE MACHINERY OF THE CLOSED LOOP. The pointing piece explained the mechanism: closed loops self-maintain through visible feedback, open loops require constant management. This piece gives you the daily, weekly, and monthly practice for closing the loops in any system you run.
The format is universal. Kitchen manager to shift leader. District manager to location manager. Parent to household. Teacher to classroom. The specific loops change. The architecture does not.
THE DAILY PRACTICE
01. finding your open loops
THE SCENE
You arrive at the beginning of your day. There are twenty things that should be happening. You do not know which ones actually are. To find out, you would have to check each one. You do not have time to check each one. So you check the ones you are worried about. The rest you assume. The things you assume are where drift is happening right now.
THE LENS
The things you have to check are your open loops. The things that run without checking are your closed loops. Your day is shaped by the ratio. If most loops are open, your day is maintenance. If most loops are closed, your day is leadership.
THE MOVE
Write down every recurring task or standard in your area of responsibility. Not one-time projects. The things that should happen every day or every shift.
For each one, ask: “How would I know if this did not happen, without checking?”
If the answer is “I would not know,” that is an open loop. Circle it.
You now have a map of where your maintenance time goes. You do not need to close all of them today. You need to see them.
THE TRAP
The trap is listing only the things you already check. The most dangerous open loops are the ones you forgot to check. They have been drifting silently. Ask: “What have I not checked in the last two weeks?” That is where the worst drift lives.
THE READ
You write down: prep checklist, opening tasks, inventory count, training hours, daily deposits, closing procedures. You ask the question for each one. Prep checklist: you have to walk the kitchen to verify. Open loop. Inventory count: it is in the system with a timestamp. Closed loop. Daily deposits: you get an automated notification. Closed loop. Closing procedures: you rely on the closer to tell you. Open loop. Two closed, two open. The two you spend your mornings checking are the two that are open. That is not a coincidence.
02. closing one loop today
THE SCENE
You have identified your open loops. The list feels overwhelming. There are seven. Closing all seven would take weeks of system design.
THE LENS
You do not close seven loops. You close one. One closed loop returns one unit of maintenance time. That time is reinvested in closing the next one. The compounding handles the rest.
The question is which one to close first. The answer: the one that costs you the most time to maintain. Not the most important loop. The one that eats the most of your day through checking, following up, and verifying.
THE MOVE
Pick your most time-consuming open loop. Close it using this three-step architecture:
Step 1: Define the done state. Binary. Observable. Not “prep is done” but “all items on the prep checklist photographed and timestamped by 10 AM.”
Step 2: Make the result visible without checking. The photo goes to a shared channel. The timestamp appears on a board. The data enters a system that everyone can see. The signal must be ambient. Not requiring a login, a pull-up, or a question.
Step 3: Make non-completion visible. If the photo is not in the channel by 10:05 AM, a red flag appears. If the timestamp is missing, the board shows an empty row. Absence must generate a signal.
When all three steps are in place, you never have to check prep again. The system checks itself. Tomorrow, your morning is shorter by one follow-up.
THE TRAP
The trap is over-designing the loop. You do not need an app. You do not need a dashboard. You need a photo in a group chat with a timestamp. You need a whiteboard with names and check marks where everyone walks past. The lowest-tech solution that creates visibility is the best one. Because the constraint is not technology. The constraint is visibility.
THE READ
Your biggest maintenance drain is verifying that closing procedures were done. You check every morning by walking the store. Thirty minutes.
Close it: the closer takes five photos (kitchen, line, walk-in, dining, register). Photos go to a shared album with a timestamp. If no photos by closing time + 30 minutes, you get a notification.
Tomorrow morning: you look at photos in 2 minutes instead of walking for 30. Twenty-eight minutes returned. Invest those 28 minutes in closing the next loop.
03. the daily visibility check
THE SCENE
You closed a loop last week. The system is running. But you notice something: the quality of the signal is degrading. The photos are getting lazier. The timestamps are slipping. The loop is technically closed but practically loosening.
THE LENS
A closed loop needs calibration. Not maintenance. Calibration. The difference: maintenance means you are the signal. Calibration means you are adjusting the quality of the signal the system generates on its own.
THE MOVE
Once per day, spend 60 seconds on each closed loop. Ask one question:
“Is the signal still clear?”
Clear means: I can see, without asking anyone, whether the standard was met today. If you can see it, the loop is holding. If you had to interpret, guess, or ask, the loop is loosening.
If loosening, adjust one thing. Sharpen the definition. Increase the signal salience. Shorten the feedback window. One adjustment. Not a rebuild.
THE TRAP
The trap is responding to a loosening loop by adding maintenance. “I need to start checking again.” No. You need to sharpen the signal. The loop loosened because the signal degraded, not because the system needs a human backup.
THE READ
Your prep photo loop is three weeks old. Photos are coming in, but they are blurry and you cannot tell if prep is actually complete. The loop is closed (photos arrive) but the signal is degraded (you cannot verify quality). Sharpen: “Each photo must show the checklist with every item marked. If items are not visible, the photo does not count.” One rule change. Signal restored. No additional maintenance.
THE WEEKLY PRACTICE
04. the loop audit
THE SCENE
A week has passed. You have been closing loops. Some are running well. Others you are not sure about. You have a general sense but no clear picture.
THE LENS
The weekly practice is the audit that tells you which loops are holding, which are loosening, and which are still open. Without this audit, you are guessing. And guessing is what managers in open-loop systems do.
THE MOVE
Once per week, pull up your loop list. For each loop, assign a status:
CLOSED: the signal is clear. You can see compliance without asking. LOOSENING: the signal exists but has degraded. You need to squint or interpret. OPEN: you have to ask or check to know. No automatic signal.
Count your ratios. If 80% or more of your loops are closed, you are in leadership mode. If less than 50% are closed, you are in maintenance mode. The number tells you where you are.
For each loosening loop, identify which of the five causes is active (undefined completion, invisible result, silent failure, delayed feedback, or manager-dependent signal). Fix one cause per loosening loop.
THE TRAP
The trap is only auditing the loops you closed. The ones that were already closed when you started do not need your attention. The ones that are still open do. The audit must include every loop, not just the ones you built.
THE READ
Your weekly audit shows: 4 closed, 2 loosening, 3 open. The loosening loops are both suffering from silent failure. Completions show up. Non-completions do not. You add a non-completion signal to both. The open loops are all in areas where you have not defined the done state. You define one. Next week: 5 closed, 1 loosening, 3 open. Progress.
05. the pattern question
THE SCENE
You look at your week’s data. Some loops showed consistent completion. Others showed variance. One loop was completed Monday through Wednesday, then missed Thursday and Friday.
THE LENS
Patterns in closed-loop data are free intelligence. You could not see these patterns when the loops were open because you did not have data. Now you do. The pattern tells you something the individual data points do not.
A loop that fails on the same days reveals a scheduling or staffing constraint. A loop that fails with the same person reveals a skill or motivation constraint. A loop that fails during the same conditions (high volume, short staff, new menu) reveals an environmental constraint.
The pattern is the diagnostic. The closed loop made it visible. The weekly review makes it actionable.
THE MOVE
For any loop that showed variance this week, ask:
“When did it fail, and what was different about those times?”
The answer is almost always one of three things:
- Same person. (Skill or commitment constraint.)
- Same time. (Scheduling or resource constraint.)
- Same condition. (Process or design constraint.)
Match the failure to the constraint. Address the constraint, not the symptom.
THE TRAP
The trap is treating every failure as the same type. “People aren’t following the process.” Maybe. But which people, and under what conditions? If it is one person in all conditions, that is a personnel constraint. If it is all people in one condition, that is a design constraint. The loop data tells you which. Use it.
THE READ
Your closing photo loop missed Thursday and Friday. Thursday was a new closer. Friday was the same closer as Monday through Wednesday. Thursday failure: new closer did not know the protocol. Skill constraint. Solution: install the protocol during onboarding. Friday failure: the regular closer had a double shift and forgot. Fatigue constraint. Solution: add a reminder trigger at 30 minutes before close. Two different failures. Two different constraints. Two different fixes. The data made both visible.
06. the chain inspection
THE SCENE
Your individual loops are mostly closed. But you notice that even when each loop hits its target, the overall outcome sometimes misses. Prep was done on time. Line setup was done. Quality check passed. But service was slow anyway.
THE LENS
Individual loops closing does not mean the chain is closed. The chain has its own loops, the handoffs between stages. When prep is done but line setup does not start until 30 minutes later because nobody signaled that prep was complete, the chain has an open handoff loop. The delay lives in the gap between stages, not within them.
THE MOVE
Map your critical process as a chain. Mark each stage and each handoff. For each handoff, ask: “Does the completion of stage N automatically trigger the start of stage N+1, or does someone have to notice and initiate?”
If someone has to notice, that handoff is an open loop. Close it the same way: define the trigger, make it visible, make non-trigger visible.
THE TRAP
The trap is optimizing stages when the constraint is the handoff. You can make each stage 10% faster and still lose 30 minutes in the gaps. The chain’s speed is determined by its slowest handoff, not its slowest stage.
THE READ
Prep finishes at 9:45. Line setup should start immediately. But the line cook does not know prep is done until they happen to check. They check at 10:15. Thirty minutes lost. Close the handoff: when the last prep item is checked off, the line cook gets a visible signal (a bell, a board flip, a text). Prep to line setup is now a closed handoff. Thirty minutes recovered.
THE MONTHLY PRACTICE
07. the system-level view
THE SCENE
You have been closing loops and auditing them weekly for a month. Your maintenance burden has dropped. You have more time. But you are not sure what to do with that time.
THE LENS
The time you recovered from closing loops is not free time. It is leadership time. The monthly practice is where you use it. Not to close more loops (that continues on its own). To look at the system as a whole and ask: what is this system becoming?
THE MOVE
Once per month, step back from the loops and ask three questions:
-
“Which constraint, if removed, would improve the system most?” This is the strategic question. Not which loop to close next (that is tactical). Which constraint in the entire system is binding the outcome you want.
-
“Which loop gave me the most useful information this month?” This tells you where to invest in better visibility. The most informative loop is the one that revealed patterns you could not have seen otherwise. Build more loops like it.
-
“Which loop turned out to be unnecessary?” Not every loop you close is worth maintaining. Some actions turned out to not matter as much as you thought. Or the variance was so low that the loop’s signal was always green. Unnecessary loops are clutter. Remove them. Every loop is a signal. Too many signals is noise.
THE TRAP
The trap is keeping every loop you ever closed. A system with fifty closed loops is not better than a system with twenty. It is noisier. Prune. The goal is not maximum visibility. It is visibility of the things that matter.
THE READ
You closed twelve loops over four weeks. Three of them never showed a failure. The standard is being met with zero variance. Those three loops are noise. Remove the visibility mechanism (not the standard). Redirect your attention to the loops that still show variance. They are where the learning is.
08. the propagation check
THE SCENE
You have closed your loops. Your area runs with minimal maintenance. But you notice that the people you manage are still in maintenance mode in their own areas. They spend their days checking, following up, verifying. They have not built closed loops in their own domains.
THE LENS
A closed loop in your area does not propagate unless the people who run it understand the principle. If they see the loop as “the boss’s system,” they comply with it but do not build their own. The loop is closed for your area. Their area is still open.
Propagation requires that the person inside the loop understands why it works and builds their own.
THE MOVE
In your monthly one-on-one with each direct report, ask:
“What is the one thing you check on most in your area? What would it take to make that visible without you checking?”
Do not give them the answer. This is an inquiry question, not an instruction. They need to generate the loop design themselves. You are installing the loop-closing pattern the same way you installed the inquiry pattern: by asking, not telling.
If they design a loop, let them build it. If their design has a gap (undefined completion, invisible result, silent failure), ask the question that exposes the gap. Do not fix it for them.
THE TRAP
The trap is building their loops for them. This is faster. It is also dependency-creating. If you design their closed loops, they will need you to design the next one. If they design their own, they will design the next one themselves. The one-month delay in implementation is worth the permanent capability.
THE READ
Your manager says she spends every morning checking if the inventory count was done. You ask: “What would it take for you to know without checking?” She thinks. “If the count had a timestamp and showed up on the morning board before I arrive.” She builds it. Next month, her morning is 15 minutes shorter. She asks her shift leader the same question about a different loop. Propagation confirmed.
09. the architecture review
THE SCENE
Three months in. Your loops are running. Your team is starting to build their own. The system is visibly better. But you sense there is another level. The loops are handling execution. But the bigger question, whether you are executing the right things, remains unaddressed.
THE LENS
Closed loops guarantee that what you decided to do gets done. They do not guarantee that you decided to do the right thing. Execution fidelity is not the same as strategic correctness. A perfectly closed loop running the wrong process is perfectly useless.
This is where the closed loop and inquiry machineries converge. The closed loop handles execution. Inquiry handles direction. Together, they form a complete operating system: inquiry asks “what is the constraint and what should we do?” The closed loop ensures “what we decided to do actually happens and is visible.”
THE MOVE
In your quarterly review (or whenever the monthly feels like it needs elevation), ask:
“Are we closing loops on the right things?”
Run the inquiry chain on your loop architecture:
- What outcomes are these loops supposed to produce?
- Are those outcomes actually improving?
- If not, is the constraint in execution (loop problem) or direction (strategy problem)?
If execution is tight but outcomes are not improving, the constraint is not in the loops. It is upstream. You are executing the wrong strategy perfectly. That requires inquiry, not more loops.
THE TRAP
The trap is infinite loop-building. At some point, more loops do not help. The system is already visible. The execution is already reliable. The constraint has moved from execution to strategy. If you keep building loops, you are optimizing the wrong layer. The loop architecture should feel stable. If it needs constant modification, something upstream is unstable.
THE READ
Your loops show perfect execution for three months. Every standard met. Every process running. But the outcome you care about, profitability, has not moved. The loops are not the constraint. You run the inquiry chain: “What is the constraint on profitability?” The answer comes back: “Revenue per order is flat.” None of your loops measure or drive revenue per order. You have been closing execution loops while the strategic constraint was elsewhere. This is not failure. This is the system telling you to look up from the loops and ask a bigger question.
THE COMPLETE ARCHITECTURE
DAILY:
┌──────────────────────────────────────────────┐
│ Find open loops. │
│ Close one per day. │
│ Calibrate existing loops (60 sec each). │
│ Builds: self-maintaining execution. │
└──────────────────────────────────────────────┘
│
▼
WEEKLY:
┌──────────────────────────────────────────────┐
│ Audit all loops (closed/loosening/open). │
│ Read patterns in loop data. │
│ Inspect chain handoffs. │
│ Builds: system intelligence. │
└──────────────────────────────────────────────┘
│
▼
MONTHLY:
┌──────────────────────────────────────────────┐
│ System-level constraint question. │
│ Propagation check (are others building?). │
│ Architecture review (right loops?). │
│ Builds: self-improving system. │
└──────────────────────────────────────────────┘
Daily makes execution visible.
Weekly makes patterns visible.
Monthly makes direction visible.
Together, the system sees itself at every scale.