Algorithms
Move work from mystery to heuristic to algorithm – start with a hunch, then simplify until the decision is repeatable and automatable.
Author
General usage (computer science; Turing, Knuth and others)
Model type
About
New or messy problems live in mystery. We probe them, form heuristics – rules of thumb that work often enough – then we simplify and formalise them into algorithms – clear, step by step procedures that anyone or any system can run. This is how teams scale judgement into process and software without losing learning at the edges.
How it works
Mystery – high novelty, weak signal, many unknowns. Work is exploratory. Output is insights and hypotheses.
Hunch – experienced operators spot patterns first. Capture them in a decision journal.
Heuristic – short, testable rules with guardrails. Examples: “triage P1 if X and Y”, “price at competitor median unless stockout risk > Z”.
Simplify – name inputs, remove ambiguity, define exceptions. Convert heuristics into checklists, decision trees or rules.
Algorithm – precise inputs and outputs, single interpretation. Implement as SOP, rule engine, workflow or code. Log decisions and measure error rates.
Two tracks – keep some capacity in Mystery so you continue discovering new heuristics while the rest of the work runs as algorithms.
Use-cases
Scaling operations – support triage, underwriting, KYC, QA checks, incident response.
Product and growth – onboarding flows, ranking, lead scoring, lifecycle messaging.
Finance and risk – approval matrices, credit rules, fraud checks, reconciliations.
Clinical and safety – checklists and escalation trees that standardise best practice.
Training – turn tacit expert steps into playbooks and then into automation.
Step-by-step
Map the workflow and label each step as Mystery, Heuristic or Algorithm.
For Mystery steps – run small probes, write hypotheses, capture examples and counter-examples.
For Heuristics – specify inputs, thresholds and exceptions. Write a one page checklist or decision tree. Set a target error rate.
Simplify into an Algorithm – define exact fields, pass or fail logic, and hand-offs. Implement as SOP, form, rule engine or code.
Instrument – log decisions, false positives and overrides. Review weekly at first, then monthly.
Evolve – retire brittle rules, promote robust heuristics, and keep a small exploration lane so new mysteries become tomorrow’s algorithms.
Pitfalls & Cautions
Premature codification – locking a poor heuristic into policy or code creates brittle failure.
Goodhart/metric gaming – algorithms optimise the proxy. Keep mission metrics alongside rule metrics.
Drift – rules decay as markets, data and incentives change. Set review cadences.
Edge cases and bias – tails need escalation to human judgement and periodic bias checks.
Over-engineering – complex rules that beat clarity and speed. Prefer the simplest algorithm that works.
Recent Mental Models
Click below to learn other mental models
The Idea Maze
Before building, map the space: the key forks, dead ends and dependencies—so you can choose a promising path and run smarter tests.
Thucydides Trap
When a rising power threatens to displace a ruling power, fear and miscalculation can tip competition into conflict unless incentives and guardrails are redesigned.
Zero to One
Aim for vertical progress—create something truly new (0 → 1), not just more of the same (1 → n). Win by building a monopoly on a focused niche and compounding from there.
