Most productivity systems are built around one assumption:
If you wrote it down, you won’t forget it.
That assumption is only half right.
The harder problem isn’t remembering what needs to happen. It’s knowing whether something actually happened.
A task can exist in a conversation, a note, a project board, an email draft, or someone’s head—and still remain completely unfinished.
That’s where open loops become useful.
What Is an Open Loop?
An open loop is anything that has been started, discussed, promised, requested, or decided—but hasn’t been clearly closed.
Some are obvious:
A report that still needs to be delivered.
A proposal waiting for approval.
A task someone said they would handle.
Others are deceptively small:
“Can you turn this into a wiki?”
“Edit this email.”
“We should document this.”
“Let’s add that to the system.”
“I’ll send it later.”
These small requests are particularly dangerous because they often feel complete once the conversation ends.
But conversation is not completion.
We Started Tracking Closure, Not Conversation
Our solution was deliberately simple: a daily open-loop check-in.
Each morning, we look at unfinished projects, queries, and tasks and surface:
Open loop
Days pending
Status
Next step
Project/task
X days
Waiting / incomplete / unconfirmed
What needs to happen
But there was one important rule:
A task doesn’t disappear just because we talked about it.
It disappears when there is evidence of closure.
That distinction changed everything.
If we created a wiki, the question became:
Is it actually in the knowledge system?
If we edited an email:
Was it actually sent?
If we created a guide:
Was it filed where it belongs?
If something was delegated:
Did the handoff actually happen?
The system stopped measuring activity and started measuring outcomes.
The “Tiny Tasks” Matter More Than You Think
One of the most useful discoveries was that open loops aren’t limited to major projects.
Small requests accumulate.
A five-minute task that remains unresolved for ten days can create more cognitive friction than a large project that is clearly scheduled.
So the check-in intentionally includes the little things.
Not just:
“Is the project finished?”
But also:
“Did we actually finish that tiny thing we said we would do?”
That creates a much more accurate picture of operational reality.
Why This Works
There are three things happening simultaneously.
1. It externalizes unfinished work
Instead of relying on memory, the system keeps unresolved commitments visible.
2. It creates a definition of done
“Worked on it” isn’t necessarily done.
“Drafted it” isn’t necessarily done.
“Discussed it” definitely isn’t necessarily done.
Completion needs a clear signal.
3. It creates gentle accountability
The check-in doesn’t need to nag.
It simply asks:
Still open? If so, what’s next?
That is enough to prevent tasks from quietly disappearing into the background.
The Most Important Rule: Evidence Beats Intention
This became the core principle:
Intent is not completion. Evidence is completion.
You can intend to send the email.
You can intend to document the process.
You can intend to upload the guide.
You can intend to follow up.
But until the observable outcome exists, the loop remains open.
This sounds obvious.
In practice, it is surprisingly powerful.
Because modern work produces enormous amounts of activity that looks like progress.
Messages.
Meetings.
Drafts.
Notes.
AI conversations.
Brainstorms.
Tickets.
Documents.
None of those necessarily mean the underlying work is finished.
From Productivity Tool to Operational Control
At first, the open-loop check-in looked like a simple productivity feature.
It turned out to be something more useful.
It became a lightweight operational control system.
The system continuously asks:
What did we start?
What remains unresolved?
How long has it been open?
What would actually close it?
And eventually:
Why is this still open?
That last question is particularly valuable.
A task that remains open for seven days isn’t necessarily a failure.
It may be waiting on someone.
It may have been deprioritized.
It may no longer matter.
Or it may simply have been forgotten.
The important thing is that the system makes that state visible.
The Bigger Lesson
The goal isn’t to close every task as quickly as possible.
That’s just another form of over-optimization.
The goal is to make unfinished work visible and intentional.
Some things should remain open.
Some things should be delegated.
Some things should be scheduled.
Some things should be killed.
But nothing should quietly remain unfinished because everyone assumed someone—or something—had already handled it.
That is the real value of an open-loop check-in.
It doesn’t make you remember more.
It makes unfinished work harder to hide.
And that may be a much better definition of productivity:
Not doing more things. Making sure the things you start actually reach a deliberate outcome.