Algorithms
General usage (computer science; Turing, Knuth and others)
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.
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.
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.
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.
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.