What goes on a decision map: facts, claims, unknowns, kill tests, options, triggers and gates

A decision map holds each part of a decision as its own labeled, checkable piece (the facts and where they came from, the claims and how sure you are, the unknowns, the result that would prove you wrong, the options, what would reopen the question, and who must sign off), and the answer you read is written from those pieces afterward.

That last part is the point. In the Of One method, the map comes first and the answer is a rendering of it. The repo compares it to a photograph of a building, except that here the blueprint and the inspection report stay attached. If the answer says something the map does not hold, the answer is wrong, not the map.

This guide lists the parts of a map in plain words, then walks through one real example from the open-source repo, part by part.

The parts of a map

Each part answers a question a careful decision-maker would ask anyway.

Part	The question it answers
Fact (the repo calls it evidence)	Where did this come from, how fresh is it, and how reliable?
Claim	What exactly are we saying, and how sure are we?
Unknown	What do we not know, and does it block the decision?
Kill test	What result would prove us wrong?
Link and loop	What causes, supports, contradicts or feeds back on what?
Option (a move)	What could we do, and can we undo it?
Tradeoff	Which option wins on which standard, and what would reverse that?
Trigger	What new fact reopens the map, and how much of it?
Human gate	Where must a named person sign off before anything irreversible?
Rendering	The answer a reader sees, written from everything above.

A few rules hold the parts together:

Confidence is a word, not a fake number. Low, medium or high, plus the reason (how good the source is, whether sources are independent, how recent, whether the mechanism fits). The repo’s rule is “never fake decimal precision.”
Unknowns are objects, not vibes. A gap gets a name, a note on what it blocks, and a plan to close it.
Every strong claim carries a kill test.
Every sentence has to do a job. The repo lists ten jobs (bound, ground, claim, link, test, move, evaluate, warn, trigger, gate). A sentence that does none of them is deleted.

A real map, part by part

The repo ships five worked example maps. The smallest is examples/strategy-micro.json, a Micro-size map (the quick size, for low to medium stakes). It is a teaching example built from a prompt, not a client case. It is written in JSON, which is hard to read, so here it is in plain words.

The question and its bounds

The map starts with a charter: what is being decided, and inside what box.

Decision: whether to enter a regulated wastewater treatment market.
Scope: the market-entry decision, early diligence, and an assumption that the rules are U.S. rules.
Horizon: 60 days.
Stakes: money at risk, exposure to regulators, and reputation.
Risk tier: medium.

Nothing else on the map may wander outside this box. If the box changes (say, the company decides to look at Europe instead), that is not a small edit. It calls for a scoped rerun or a rewrite of the map’s trunk.

Which dialect

Of One maps every field onto the same skeleton, then uses a dialect to speak each field’s language: strategy, science, formal, or values. This decision mixes three, so the map says which dialect governs which part:

Strategy: market entry, customer incentives, partner options.
Science: whether the treatment works, how it is measured, how it fails.
Values: environmental exposure and public consequence.

Declaring the mix matters. A strategy lens alone would miss that “does the treatment actually work?” is a science question with its own standard of proof.

What is known, and what is hidden

The map names what the decision turns on: the target market, the permit pathway (a hard limit), treatment performance, and the rules in whichever place they choose. It then splits the variables into what can be seen and what cannot. Hidden: how strictly local regulators enforce, what the incoming wastewater actually contains, and how competent the operators are.

That list of hidden things is worth copying into any decision. It is where surprises come from.

The facts

There are two facts, and the map is honest about how thin they are.

E1: the prompt says the evidence is limited. Reliability: medium. Risk: incomplete context.
E2: the prompt describes the market as regulated wastewater treatment. Reliability: medium. Risk: jurisdiction not specified.

Each fact records where it came from, when, and a fingerprint (a content hash) so anyone can check it later. Both came from the same prompt, and the map’s overall confidence notes that source independence is low. Two facts from one source are not two confirmations.

The claims

C1: “Current evidence is insufficient for full operational market entry.” Confidence: high. Why: where the evidence came from, the risk of hidden variables, and how well the dialect fits. How it could fail: missing segment data, unknown jurisdiction. This claim needs a human review.
C2: “A gated diligence move is more reversible than launch.” Confidence: medium. It depends on C1. How it could fail: an opportunity cost, and partners who may not be available.

Notice that the claims are small. Each one says one thing, so each one can be checked and, if needed, killed on its own.

The links and the loop

Two links connect the pieces. X1: C1 supports C2. X2: the permit pathway constrains C1, a causal link.

One loop is flagged: L1, a review loop. Its failure mode is a warning worth keeping in any organization: “review treated as paperwork instead of a decision gate.” The loop’s strength and delay are marked unknown, which is honest; the map does not pretend to know.

The unknown

U1: the target segment, the jurisdiction and pilot-performance evidence are not specified yet. It blocks both the option and the final answer. The map also scores it: high impact on the decision, low cost to resolve, days to two weeks to resolve, high risk reduction. That combination (big effect, cheap to learn) is exactly what makes it the best next question.

The kill test

KT1 targets C2. It fails the claim if a contradicting source or a regime shift shows that diligence is not, in fact, more reversible than launching. Without this, “diligence is the safe choice” would be a comfortable assumption instead of a claim that can lose. For more on writing these, see Kill tests.

The option and the tradeoff

There is one option, O1, a test move: a gated diligence sprint. Its tradeoffs are written out (slower entry, lower compliance risk, more reversible spending). It is blocked by U1 and sits behind gate G1.

The tradeoff surface checks O1 against three standards: do not release or launch while the required gate is open; prefer moves that resolve blocking unknowns before anything irreversible; and do not hide material exposure from the people affected. O1 wins on the first two. It names what would reverse that: resolving U1, or trigger T1 firing.

The trigger

T1: new evidence arrives. The response is a patch: only the parts that depend on the changed fact get redone, not the whole map. Of One has five sizes of response to a new fact (no change, patch, scoped rerun, rewrite of the trunk, or human review), and the map says in advance which one applies.

The gate

G1: a human regulatory and business owner must approve, block or narrow the diligence move before any customer commitment, permit filing, compliance exposure, reputation exposure, or operational launch. Status: open.

The answer

Only now does the answer appear, and it is short. Its summary opens with “Do not launch operationally.” and then calls for a gated diligence sprint instead.

Recommendation: approve a reversible diligence move, not full entry. Confidence: medium. The answer lists what it depends on (the claims, the option, the unknown, the tradeoff and the review of each dialect), so if any of them changes, you know the answer must change too. The file also records a validator result showing the schema checks and the graph checks passed, and the repo’s own validator runs over it; in Of One, no answer goes out until that check passes.

What this example teaches

Look at how little the map knows, and how much it still says. Two thin facts from one prompt. Yet the map can tell you what not to do, what to do instead, what one question to answer next, what would prove the plan wrong, and who has to sign.

That is the difference between a map and an essay. An essay on the same prompt might have been long and confident. The map is short and shows exactly where it is weak.

Start your own map today

Copy these headings onto one page and fill them in for a decision you face:

Decision, scope, horizon, stakes.
Facts: each with its source, date and how reliable. Note when two facts share one source.
Claims: one sentence each, with low, medium or high and the reason.
Unknowns: what each one blocks, and what it would cost to find out.
Kill test for your strongest claim.
Options: mark each one reversible or not.
Trigger: the new fact that would make you look again.
Gate: who must sign before anything you cannot undo.
The answer, written last, from the page above.

The /ask/ tool builds a version of this page for you from the eight bones in Twenty questions for any decision. The method page covers every part in more depth.