Decision Logging.
Most decisions evaporate. You make the call, you move on, and three weeks later nobody (including you) remembers what you decided or why. Decision logging captures the reasoning atomically: one slash command writes five files in a single transaction. The full record, the raw context, the dense card, the index row, and the running log. Your second brain remembers, and future sessions inherit the call.
- A durable record of every call with the reasoning, what you rejected, what would reverse it, and when to revisit. Searchable, linkable, agent-readable.
- Cairns coverage for decisions the same three-tier architecture you use for knowledge sources, now applied to live calls. L1 waypoint, L2 Chain of Density Card Catalog Layer (Card Catalog Layer for short) dense card, L3 raw context.
- An audit trail you didn't have to maintain the agent does the atomic write. You describe the decision in plain English. Five files land in the right places or none do.
Log your first decision.
Hand the slash command spec off to Claude and capture a real decision you've made in the last week. The agent does the atomic five-file write. You just describe what you decided.
How this fits in the OS.
A second brain vault on your computer (default ~/Documents/second-brain), the /log-decision slash command installed locally, and a working understanding of the Cairns three tiers.
One slash command, plain markdown files, your existing vault folder structure. No external services, no credentials, no API keys.
Auditable reasoning on every call you make, automatic Cairns L1 / L2 Chain of Density Card Catalog Layer (Card Catalog Layer for short) / L3 coverage for decisions, and a review queue the agent can surface when revisit dates come due.
Why an atomic five-file write.
You could log a decision as one markdown file. Many people do. The problem shows up six months later when you're asking your agent "why did I pick that vendor?" and the answer is buried in a single file your agent doesn't know about, doesn't surface, and can't retrieve without an expensive search.
Decision logging in the agent-native OS writes the decision into the same three-tier memory architecture you use for every other knowledge source. The L1 waypoint is loaded into context automatically. The L2 Chain of Density Card Catalog Layer card is reachable by name. The L3 raw context is preserved in case you ever need to audit the reasoning verbatim. One command, five files, one transaction.
Atomic means all or nothing. Either every file lands in the right place, or no file does. The command stages files in a temp folder first, validates each one, then copies into the vault. If any write fails, it rolls back every file copied during the run. This is the same epistemic posture the workshop uses for immutable source extractions, applied to live decisions instead of after-the-fact summaries.
The full procedure is in your local workshop repo at configs/commands/log-decision.md. That file is the source of truth. This card is the orientation pass. The starter prompt above hands the spec to Claude and walks you through your first decision.
What gets written.
One invocation of /log-decision produces five files. Here's the exact structure, straight from the slash command spec:
The slash command resolves the vault root on first run (default ~/Documents/second-brain, with a Windows-aware fallback to your Documents folder). It asks once if the path is unclear, then remembers.
What changes for you.
The five-file write is the easy part. The bigger thing is the shift in how you treat your own reasoning. Three internal shifts you'll feel:
- Decisions become artifacts, not vapor. You stop saying "I think we already decided that" and start saying "yes, on this date, with this reasoning, here's what would reverse it." Memory pressure drops because the file holds the load.
- Reversibility becomes a habit, not a footnote. The spec asks you to mark every decision as reversible within a day, a week, a month, or never. You start noticing which calls were actually low-stakes and which deserved more time. That signal compounds over months.
- Your agent inherits your judgement. Future sessions read the L1 waypoint, see the decision, and don't re-litigate calls you already made. The agent stops asking "what should we do about X?" and starts asking "do we still believe the decision from May 12?"
Before you start.
Two prerequisites:
- Cairns is set up. You've worked through The Cairns Three Tiers and you have at least the L1, L2 Chain of Density Card Catalog Layer, and L3 folder skeleton in your vault. Decision logging writes into folders that have to exist.
- You've run
/personalizeat least once. The slash command needs your vault root resolved. If you haven't done your personalize pass yet, do that first; it's a five minute job.
That's the whole list. No credentials, no API keys, no external services. This is all local markdown.
Walk through the build.
Verify the slash command is installed
~5 minThe /log-decision command should already be on your computer if you cloned the workshop repo during your Cairns setup. Confirm it by checking the file exists:
Open configs/commands/log-decision.md in our local workshop repo. Read it end to end and tell me back: (1) what the command does in one sentence, (2) the exact five files it writes, (3) the rollback behavior if any write fails. I want to confirm the spec is current before we run it.
The agent does this for you. You're not parsing the spec by hand. Claude reads the file, summarizes it, and confirms the behavior you should expect. If anything looks different from what's described on this card, the local spec wins. It's the source of truth.
configs/commands/log-decision.md in the repo; once it's there, Claude Code picks it up automatically as a /log-decision slash command.
Pick a real decision from the last week
~5 minDon't use a test decision. Pick a real call you've made recently. A tool you chose, a project you scoped, a meeting you said no to, a vendor you picked, a hire you passed on. The point of the first run is to feel the value of capturing real reasoning, not to validate the command works.
Hold the decision in one sentence: what you decided and why. That sentence is what the agent will ask for in Step 1 of the spec. If you can't say it in one sentence, the decision isn't crisp enough to log yet.
Examples that work well as a first log:
- "I'm using Infisical for credentials instead of 1Password because the team is already on it."
- "I'm shipping the workshop with four cards instead of seven because we can ship four cleanly by Friday."
- "I'm passing on the consulting engagement because the IP terms aren't worth a six week commitment."
Run /log-decision and answer the prompts
~10 min
In your terminal, with Claude Code open in your workshop repo:
/log-decision
The command walks you through six steps. You answer the questions; the agent does the writing.
- Get the decision. You give the one sentence from Step 02.
- Get the structure. Deciders (default: you), date (default: today), reasoning depth (short or full), related people, related projects, reversibility (under a day, under a week, under a month, or never), review date (default: 90 days out), tags (default:
decision). - Resolve the vault path. The default is
~/Documents/second-brain. On Windows it uses your Documents folder. If it's ambiguous, the command asks once. - Build the files in a temp stage. Everything is rendered into a
.log-decision-stage-<timestamp>folder outside the vault. Nothing touches your real vault yet. - Commit the atomic write. Every staged file is copied into the vault. If any copy fails, every file copied during this run is removed and the previous
INDEX.mdandmy-decisions.mdare restored. - Read back. The agent shows you all five paths and asks if anything is wrong, missing, or worded oddly. You can fix it in place before walking away.
The agent does this for you. You're describing a decision in plain English; the agent is composing the dense card, formatting the frontmatter, building the INDEX row, and committing the transaction. The whole point of /log-decision is that you should never have to remember the five file paths or the YAML structure. That lives in the spec.
When it works.
You'll see five things land in your vault:
- A new file in
decisions/with today's date and your slug. Open it. The frontmatter should have your deciders, your reversibility marker, your review date. The body should have your reasoning in your voice. - A new file in
cairns/L3/decisions/with the raw context. Verbatim. No summarization. This is your evidence layer. - A new file in
cairns/L2/decisions/with the dense 120 to 180 word summary, the retrieval hooks, and the L1 promotion candidate sentence. - One new row appended to
cairns/L1/INDEX.md. Open it. The row should point at your new L2 Chain of Density Card Catalog Layer card. - One new pointer line in
cairns/L1/personal/my-decisions.md(or the file itself if this is your first decision). Open it. The dated line should match the decision you just logged.
The diagnostic question: open a fresh Claude Code session in your vault folder and ask "what did I decide this week?" If the agent surfaces your decision by reading the L1 waypoint, the architecture is wired. If it has to grep the filesystem, something didn't land where it should have.
If you get stuck.
Common failure modes, ranked by how often they bite people:
- Vault path was ambiguous and the command guessed wrong. Most common on the first run. The fix: open
configs/commands/log-decision.mdand confirm the default vault path matches where you actually want decisions to land. If not, tell the agent explicitly: "the vault root is<path>, use that for every/log-decisionfrom now on." - The Cairns L1, L2 Chain of Density Card Catalog Layer, or L3 folders didn't exist yet. The atomic write needs targets. If the folders are missing, the command can create them, but it's cleaner to set up your Cairns skeleton first (the Cairns Three Tiers card).
- The L2 Chain of Density Card Catalog Layer card got your reasoning slightly wrong. The chain-of-density summary is the agent's best shot at compressing your words. Sometimes it loses nuance. The read-back step in Step 6 is your moment to fix it. Edit only after the read-back; never edit the L3 raw (that's the immutable evidence).
- You logged a decision that wasn't actually a decision. If you wrote "I'm thinking about switching tools," that's a thought, not a decision. The command will dutifully log it anyway, but the file is noise. The fix: be honest about whether you've actually decided. If you haven't, save the thought somewhere else (a journal entry, a Decisions in Flight note) and come back to
/log-decisionwhen you've made the call. - A write failed and you're not sure if rollback ran. The spec says rollback is automatic; if rollback itself fails, the command stops and tells you the exact paths needing manual review. If you ever see a partial write (some files there, others missing), do not re-run the command; clean up manually first using the paths the agent reported.
Still stuck? Post the prompt, the agent's response, and what you expected, in the workshop Slack. Someone in the cohort is solving the same thing.
Where to go next.
You captured a decision atomically. Two natural next moves on the shelf: