We Did This Last Time
Why organizations can't reuse judgment
Someone says, “We did this last time,” and the room treats it like a shortcut.
Then the scavenger hunt begins.
Someone opens Slack search. Someone says, “Check the Jira ticket.” A link dump appears, and then the room stalls.
Artifacts are plentiful. Closure is missing. Everyone can find what happened. Nobody can state what question was actually closed.
So the room faces a fork: re-litigate from scratch, or replay the outcome and hope the context hasn’t changed. Neither is reuse. Both burn judgment you already paid for.
Repeating an outcome isn’t reuse.
That failure isn’t about missing information. It’s about missing the unit of work.
The Category Error
Enterprises got very good at recording what is true, and orchestrating what happens next.
But the thing that actually moves an organization forward is neither state nor steps. It’s judgment.
State lives in systems of record: the customer exists, the contract is signed, the balance is current. Steps live in workflows and tickets: review the application, approve the request, close the case. Both are necessary.
But neither captures what made the outcome valid.
The compression happens in tasks. Tasks collapse judgment into vague verbs: “approved,” “reviewed,” “handled.” Work completes, but the bar stays implicit. You know something got done. You don’t know what question it answered, what counted as evidence, or what conditions would change the result.
Over time, this adds up.
Organizations don’t accumulate judgment; they accumulate exhaust.
And when judgment isn’t legible, organizations compensate the only way they know how: integrate more data.
Why Data Integration Never Finishes
Integration promises that if we unify facts, decisions will become obvious.
But integration fails because the hard part isn’t facts. It’s meaning.
Take three words that appear in almost every enterprise: approved, eligible, active. Each seems simple. None is stable. What “approved” means depends on delegation, purpose, and time. “Eligible” shifts with policy. “Active” drifts as systems and incentives evolve.
Meaning shifts with policy, delegation, incentives, and time. The same field in the same system can mean something different this quarter than it did last quarter, because the rules changed, or the interpretation did, or the context around the decision shifted.
And there’s a sharper problem hiding inside “approved.”
A system of record can tell you who clicked the button. It cannot prove they had the mandate to bind the organization at that millisecond. Identity is not authority. Login is not standing. And when that distinction isn’t machine-legible, “approved” becomes a story we tell after the fact.
“Unify everything first” becomes a permanent project because you’re trying to precompute coherence for unknown future questions. You can’t. You’re not solving a data problem. You’re chasing meaning that was never pinned down.
It’s not a data drift problem. It’s an as-of meaning problem.
So flip the order. Don’t integrate for every future question. Integrate for this question.
The Inversion: Question-First Integration
A decision flips the order: name the question, bind what counts, then close it.
A closed question creates local coherence across systems for this purpose, without pretending the whole enterprise shares one stable meaning. You don’t need a global ontology. You need enough shared understanding to answer this question, right now, under the rules currently in force.
If you can’t state what the key terms meant, what counted, and which rules were in force, you didn’t close a decision, you recorded an outcome.
A CRM field that says “Approved discount” isn’t precedent. It only becomes reusable when “approved” is tied to the delegation limit and margin model as-of the policy in force, not whatever those words mean today.
Which brings us back to the primitive: a decision is a closed question.
Decision vs Story
A decision is a closed question you can point to later without reconstructing a narrative.
Not just the answer: the conditions that made the answer valid.
If you have to reconstruct the “why” from a trail of emails and tickets, you don’t have a decision. You have a story. Stories onboard people. They don’t reuse safely, because interpretation drifts.
You can tell you have a decision (not a story) when three questions have answers you can point to:
What question was closed?
What would have changed the answer?
What must still be true for the answer to be safe to reuse?
Once you see decisions this way, work stops looking like a pile of tasks.
The Click: Real Work Is a Chain of Named Questions
Most “steps” hide multiple questions inside a single verb.
“Review the application” hides questions like: does it qualify under today’s definition? Is it within the current approval limits? The rest are variations of the same mistake: we compress multiple closures into one verb.
Progress becomes legible when you can name the question you’re closing. Not “what did we do,” but “what did we decide.”
Meetings change. Instead of status updates that report motion, the question becomes: which question are we closing? Artifacts become inputs to closure, not substitutes for it. A document isn’t the decision; it’s evidence for the decision. Alignment becomes agreement on the bar and the answer-changing facts, not agreement on vibes.
If you can’t name the question, you can’t reuse the answer.
And reuse is the point, because reuse is how organizations compound.
How Decisions Compound
Memory helps you reconstruct what happened.
Decisions let you reuse judgment safely.
The difference matters. When someone says “we did this last time,” memory sends you on a scavenger hunt. You find artifacts, reconstruct context, and try to infer what applied. That’s expensive, error-prone, and gets worse as the organization scales.
Closed questions work differently. Next time a similar case arises, you don’t restart. You verify the conditions still hold, and you revisit only what changed. If the answer-changing facts haven’t changed, you reuse the judgment. If they have, you know exactly where to focus.
That’s the difference between story recall and condition check. Stories require re-interpretation every time. Conditions can be verified.
Precedent only compounds when it carries its conditions.
When decisions aren’t first-class, organizations don’t stop working. They substitute something else.
What You Get Instead
When closed questions are missing, organizations compensate with motion.
They build rituals around diligence because they can’t point to reusable judgment. They re-litigate decisions that were already made, calling it rigor. They add steps without bars, more approvals, more reviews, more sign-offs, none of which clarify what question is being closed.
Meaning drifts silently. The same words keep getting used while their referents shift. “Approved” meant one thing when the policy was written; it means something else now that delegation changed. Nobody updates the field. Everyone updates their interpretation.
Turnover resets judgment. When experienced people leave, the organization loses the human middleware that was compensating for missing primitives. The next person starts over.
Integration never converges. Data teams keep trying to unify meanings across systems, but they’re chasing a moving target, because the meanings were never pinned at decision time.
That’s the exhaust problem again. Nothing compounds because nothing carries conditions forward.
This ceiling isn’t technological. It’s organizational.
Why This Scales Intelligence
Organizations can generate options endlessly.
What they can’t do is reuse judgment unless closure is explicit.
This has always been true, but it becomes urgent as automated systems enter the picture. Without closure, you get inconsistency at speed: different answers to the same question, replayed debates that were already settled, re-litigation that compounds rather than resolves.
Worse, you get answers nobody can defend later. When a decision is implicit, buried in a task that completed, inferred from patterns in prior behavior, there’s no record of what made it valid. If conditions change, no one knows. If someone challenges the outcome, no one can point to the bar it met.
The moment output turns into a real-world move, closure has to be explicit.
This isn’t about slowing things down. It’s about making speed sustainable. Closed questions are how judgment becomes reusable.
And it doesn’t require an enterprise-wide program. It starts with a handful of recurring questions.
The Practical Shift
You don’t need to model the whole business.
Start by standardizing how you close the few questions you answer over and over.
Every organization has recurring decisions that consume disproportionate coordination effort: pricing exceptions, approval escalations, vendor assessments, contract deviations. These decisions get made repeatedly, but each instance is treated as novel because no one captured what made the prior answer valid.
Pick five. For each, get clear on the question you’re actually closing, the facts that would flip the outcome, and what must remain true for the answer to be reusable. That’s not documentation: it’s leverage. Each closed question becomes precedent that saves the coordination cost you would have spent on re-litigation.
Then “we did this last time” stops being a scavenger hunt.
The Goal
The goal isn’t perfect documentation.
The goal is that “done” means a question was closed in a way the organization can stand behind and reuse.
Next time someone says “we did this last time,” you can point to the closed question and its conditions, not a link dump. You can verify whether the prior answer applies, or identify exactly where circumstances have changed. Either way, you’re not starting over.
And once a question is well-formed (conditions, authority, evidence pinned) it can do more than compound. It can warrant action.
If you can’t name the question, you can’t reuse the answer.
When judgment can be reused, coordination stops burning the same calories on the same debates.
Precedent only compounds when it carries its conditions.
Stop trying to integrate everything. Start closing questions in a way that makes integration finishable.