decide
by alirezarezvanidecide logs founder-approved board memos as durable company memory via decision-logger, separating approved decisions from raw transcripts for Knowledge Capture workflows.
Score: 68/100. This is acceptable for listing because it has a clear trigger, a specific place in a larger C-level advisor workflow, and enough process detail to help an agent log approved decisions with less guesswork than a generic prompt. Directory users should understand, however, that it is a thin wrapper around a broader ecosystem and relies on an external `decision-logger` skill and expected memo conventions that are not fully documented here.
- Strong triggerability: the frontmatter and body clearly identify `/cs:decide <memo-path>` as the command to run after `/cs:boardroom` when a founder-approved board memo should become durable memory.
- Clear workflow purpose: it defines the gate between deliberation and durable company memory, including approval verification and extraction of title, date, option chosen, criteria, dissent, and review checkpoint.
- Useful memory model: the two-layer raw-versus-approved decision storage model helps agents avoid treating unresolved debates as final decisions.
- The skill depends on a separate `decision-logger` skill and a broader `/cs:*` workflow, but this repository path provides no support files, install command, or linked reference material for that dependency.
- Operational details are mostly conceptual; there are no scripts, examples of approved memo input, or concrete output examples beyond the described record fields.
Overview of decide skill
What decide does
decide is a C-level advisor skill for turning an approved strategic memo into durable company memory. In practice, /cs:decide <memo-path> sits after boardroom-style deliberation and before execution: it verifies that a founder-approved memo is actually approved, extracts the decision record, and routes it through the related decision-logger workflow.
The core job is not “help me choose.” It is “record the choice we already approved so future AI sessions can treat it as company context.”
Best fit for Knowledge Capture workflows
The decide skill is best for Knowledge Capture when your team uses Claude or an agent workflow to run recurring executive discussions, strategy reviews, or founder decision sessions. It is especially useful if you want a clean separation between:
- raw debate, dissent, and meeting transcripts
- approved decisions that should influence future planning
That separation matters because unresolved discussion should not become memory by accident.
Key differentiator: two-layer memory
The upstream skill describes a two-layer model managed by decision-logger:
- raw transcripts under
~/.claude/decisions/raw/ - approved decisions under
~/.claude/decisions/approved/
Only approved decisions are intended to feed future /cs:office-hours and /cs:founder-mode calls. This makes decide more conservative than a generic “summarize this meeting” prompt: it creates a gate between deliberation and institutional memory.
When decide is not the right skill
Do not install decide expecting a broad decision-making assistant, brainstorming tool, or project management system. It assumes you already have a board memo, an approval status, and a surrounding C-level advisor pipeline. If your workflow is just ad hoc notes, use a lighter note-taking or summarization prompt until you have a stable approval process.
How to Use decide skill
decide install context
Install from the GitHub skill repository with:
npx skills add alirezarezvani/claude-skills --skill decide
Then inspect the source at:
c-level-advisor/c-level-agents/skills/decide/SKILL.md
The skill has a narrow file footprint: the main evidence is SKILL.md. There are no visible helper scripts, references, README files, or resource folders in the provided tree, so adoption depends on whether your environment already supports the surrounding C-level commands and the decision-logger skill.
Required input for decide usage
The command form is:
/cs:decide <memo-path>
The input should be a board memo file, normally produced by /cs:boardroom. Strong input should include:
- decision title
- date decided
- option chosen
status: APPROVEDor equivalent founder approval marker- success criteria
- kill criteria
- preserved dissent
- review checkpoint date
A weak input such as “we decided to expand sales” is not enough. A stronger prompt would be: “Use /cs:decide ./memos/2026-02-enterprise-sales.md. Confirm founder approval, extract the chosen option, preserve dissent, and log success criteria, kill criteria, and the Q2 review checkpoint.”
Practical decide guide workflow
A reliable decide workflow looks like this:
- Finish deliberation in
/cs:boardroom. - Save the approved memo to a stable path.
- Make sure the memo states that the founder approved it.
- Run
/cs:decide <memo-path>. - Confirm that approved memory was written separately from raw transcript material.
- Use the logged decision as context for
/cs:executeor future planning sessions.
This sequence reduces accidental memory pollution. The skill is most valuable when used consistently at the same point in your decision pipeline.
Files to read before adoption
Read SKILL.md first and focus on these sections:
Pipeline PositionTwo-Layer Memory ModelInputWorkflow
Because there are no extra support files in the preview, the main adoption question is not repository complexity. It is fit: do you have approved memos and a durable memory convention that matches the paths and expectations described by the skill?
decide skill FAQ
Is decide a decision-making skill?
No. decide records an approved decision; it does not run the debate. It belongs after a decision has been made, typically after /cs:boardroom. If you need option generation, risk analysis, or advisor debate, use those earlier workflow steps first.
What makes decide better than an ordinary prompt?
An ordinary prompt can summarize a memo, but decide encodes a governance boundary: raw transcripts are reference material, while approved decisions become durable memory. That distinction is the main reason to use the decide skill instead of asking Claude to “remember this.”
Can beginners use decide?
Yes, if they already understand file-based prompts and have a memo ready. Beginners may struggle if they do not use the wider c-level-advisor command structure, because decide assumes a pipeline and references decision-logger. Start by testing one approved memo before relying on it for operational memory.
What blocks a successful decide install?
The biggest blockers are missing surrounding skills, unclear approval status, and unstructured memos. If your environment cannot call /cs:decide, cannot access the memo path, or does not have a compatible decision-logger setup, the skill may not complete the intended memory write.
How to Improve decide skill
Improve decide inputs before running it
The fastest way to improve decide output is to make the memo explicit. Add a short decision header before calling the skill:
Status: APPROVEDDecision: Choose Option BOwner: Founder / CEOSuccess criteria: ...Kill criteria: ...Review checkpoint: ...Dissent to preserve: ...
This gives the agent less room to infer approval or invent missing structure.
Common failure modes to avoid
The most common failure is logging discussion as a decision. Avoid sending transcripts, unresolved notes, or competing options unless the memo clearly says which option won. Another failure is omitting kill criteria; without them, future reviews cannot distinguish “continue” from “stop.”
Also avoid using decide as a catch-all memory command. Its value comes from being selective.
Iterate after the first output
After the first run, check whether the logged decision is concise, auditable, and future-useful. If the record is vague, revise the memo and rerun with clearer fields. Good durable memory should let a future agent answer: what did we decide, why did we choose it, what would prove it wrong, and when should we review it?
Extend decide for your operating system
Teams can improve the decide skill by standardizing memo templates, adding required approval language, and aligning memory paths with internal conventions. If you maintain the repository, useful enhancements would include a README, example approved memo, validation checklist, and clearer dependency notes for decision-logger. These additions would make decide install decisions easier and reduce setup ambiguity.