# Think > Structured thinking skill implementing Bloom's AI Collaboration Framework v3. Auto-scales depth from stakes (reversibility + reliance): quick 3-question framing for reversible exploration, standard 6-question protocol for real decisions, deep mode with epistemics + teach-back + independent audit for binding one-way doors. Produces a decision contract; can run as a session or be packaged as a brief for delegated agents (/think fan). Use when the user says /think, wants to think through a problem, plan a project, make a decision, or start something new. Also trigger on phrases like "help me think through", "let's figure out", "I need to plan", "what should I do about", "how should I approach", or "let's work through this". - Skill: `jneaimi/think` (Agent Skill, multi-file: 2 files) - Install (CLI): `npx skillmds@latest add jneaimi/think` - Raw SKILL.md: https://api.skillmd.com/api/skills/jneaimi/think/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Security - Author: jneaimi (https://skillmd.com/u/jneaimi) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/jneaimi/think --- # Bloom's AI Collaboration Framework (/think) v3 A structured thinking skill that guides human-AI collaboration through Bloom's cognitive levels. The human leads evaluation, judgment, and direction (Levels 4–6); AI handles research, production, explanation, and recall (Levels 1–3) under human audit. **Core principle:** Never jump to building, drafting, or coding before the human has answered the evaluative questions that match the stakes. **Interaction model:** Use `AskUserQuestion` for all decision points. Accept free-text answers as valid ("argue mode") — paraphrase and continue. ## Framework Reference ``` ┌─────────────────────────────────────────────────────────────┐ │ Level 6: Create HUMAN originates → AI materializes │ │ Level 5: Evaluate HUMAN decides → AI informs │ │ Level 4: Analyze HUMAN steers ↔ AI researches │ ├─────────────────────────── AUDITABILITY LINE ───────────────┤ │ Level 3: Apply AI produces → HUMAN audits │ │ Level 2: Understand AI explains → HUMAN audits │ │ Level 1: Remember AI proposes → HUMAN audits │ └─────────────────────────────────────────────────────────────┘ ``` L1–L3 sit below the **auditability line**: their output has an external referent (source, document, decision contract, runtime) it can be checked against. L4–L6 sit above it: ground truth is the human's judgment and values. **The grounding rule:** every L1–L3 output you produce must carry its referent — cite the source, link the document, name the contract fields a draft implements. An output with no referent attached must be flagged: it is operating above the line regardless of level, and the human should treat it accordingly. --- ## Notes location (all saves) Resolve the notes directory in this order — first hit wins: 1. `$THINK_NOTES_DIR` environment variable, if set. 2. `notes_dir` in `/config.json`, if the file exists. 3. OS default: `~/Documents/think/` on macOS and Windows; `$XDG_DOCUMENTS_DIR/think/` on Linux (fall back to `~/Documents/think/`, then `~/notes/think/` if no Documents folder exists). On the **first save ever** (no config.json, no env var), confirm once via AskUserQuestion — "Save /think notes to ``?" with the resolved default recommended, plus "Somewhere else (type a path)". Write the choice to `/config.json` as `{"notes_dir": ""}` and never ask again. Users who point it at an existing knowledge base (Obsidian vault, notes repo) get /think notes alongside the rest of their notes. Subfolders by content type: `decisions/`, `projects//`, `learnings/`, `research/`, `patterns/`. Create on demand. --- ## Commands ### /think [topic] — auto-scaled (default) Run stakes detection (below) and select quick / standard / deep automatically. Announce the selection and the reason; the human can override with one word. ### /think quick [topic] · /think deep [topic] — forced depth Skip stakes detection; run the named depth. ### /think fan [topic] — delegation form (Form B) Produce a **think-brief** and fan it to multiple agents instead of running the analysis in this conversation. See "Form B: fan-out" below. ### /think brief [topic] — emit a portable brief Produce the think-brief file only (no fan-out) — for handing to any agent or human collaborator. ### /think continue — resume Re-read the most recent contract/session note from the notes directory and resume from the first incomplete level. ### /think summary — show current state Display which levels are complete, decisions made, what's next. ### /think save — save now Write the session's decision contract + narrative to the notes directory (see Level 1 below) even if the session isn't finished. ### /think feedback [text] — capture friction Append `{"ts": "", "topic": "", "text": ""}` as one JSON line to `/feedback.jsonl` (create if missing). Confirm with "Feedback saved." and continue. No questions needed. ### /think pillars [days] — usage balance report Read saved contracts/notes from the notes directory (default last 30 days), count sessions per pillar via frontmatter tags, report the distribution and the neglected pillars. Pillar definitions: `pillars.md` in this skill's directory (experimental adapters — see that file's status note). --- ## Depth selection (always runs first) **Stakes = reversibility × reliance.** Infer both from the topic and the conversation context: - **Reversibility** — two-way door (cheap to undo) / costly to reverse / one-way door (binding, irreversible). - **Reliance** — private exploration / the human will act on the output / others rely on it, or it is binding (legal, financial, published, shipped). **If confident** in the inference, announce and proceed — do not ask: > "Deep mode — this is binding and others will rely on it. Say 'quick' to > override." > "Quick mode — exploratory and reversible. Say 'deep' if the stakes are > higher than they look." **If ambiguous**, ask the gate (one AskUserQuestion call, 2 questions): ``` G1 — REVERSIBILITY: "If this goes wrong, how hard is it to undo?" Options: "Two-way door — easily undone" / "Costly to reverse" / "One-way door — binding or irreversible" G2 — RELIANCE: "Who acts on the outcome?" Options: "Just me — exploring" / "I'll act on it" / "Others rely on it / it's binding" ``` | G1 × G2 | Depth | |---|---| | Two-way door + exploring | **Quick** | | Costly, or someone acts on it | **Standard** | | One-way door, or others rely / binding | **Deep** | **Mid-session escalation:** if answers reveal higher stakes than assumed (e.g., "medium" commitment turns out to be binding), announce the escalation and add the missing steps. De-escalation only on the human's say-so — record it in the contract. **Domain/pillar detection:** if the prior conversation clearly establishes the domain, announce it inline ("Detected domain: Code/Architecture — adjust if wrong") instead of asking. Ask only on a cold start, folded into the gate call or the first question round — never as a question round of its own. --- ## The protocol by depth ### Quick — 3 questions, no ceremony One AskUserQuestion call: PURPOSE, SUCCESS, SCOPE (domain-adapted wording). Then a brief framing summary. No L4 research unless asked; L3 output only if the human asks; offer a one-line save, don't push it. If the human wants to go deeper at any point, escalate to standard. ### Standard — the core six + loop-back + save **Round 1** (one call): PURPOSE, RESOURCES, SUCCESS. **Round 2** (one call): RISKS (multiSelect), SCOPE, COMMITMENT. Then: 1. **Level 5 summary** — compile answers (free-text answers verbatim). Contradictions → one clarifying question, don't guess. 2. **Level 4 analysis** — research grounded in the answers (web, codebase, the human's notes). Present: key findings / risks identified / **new decisions surfaced**. 3. **Loop-back check (mandatory):** if any finding surfaces an unmade decision, return to Level 5 with an AskUserQuestion. If genuinely none: state "Level 4 complete — no new decisions surfaced." The loop may repeat. 4. **Level 3 deliverable** — produced against the contract; cite which contract fields each major part implements (grounding rule). 5. **Level 2 explanation** — what it does, what the human is committing to, what to verify, what it does NOT cover. Depth matched to their expertise. 6. **Level 1 save** — see below. ### Deep — standard, plus epistemics, teach-back, independent audit Everything in standard, with three additions: - **Epistemics round** after Round 2 (one call): ASSUMPTIONS (free-form) and FALSIFIER ("what would change your mind?", free-form). Reversibility is already known from the gate. - **Teach-back at Level 2:** after explaining, ask 2–3 comprehension checks against the deliverable via AskUserQuestion (e.g., "Which clause lets the counterparty exit?"). Wrong or unsure answers → re-explain that part; note in the contract that audit competence was built, not assumed. - **Independent audit channel:** before the human commits, arrange at least one audit independent of you as author — a different model reviewing the draft against the contract, an adversarial "find what's wrong" pass, tests run against reality, or a named human expert. Self-explanation is not independent audit. Record which channel was used in the contract. --- ## The decision contract Every standard/deep session compiles its L5 answers into this artifact — it is the spec for the L3 audit, the payload for delegation, and the durable record: ```yaml decision_contract: topic: purpose: success: scope_in: [] scope_out: [] risks_accepted: [] commitment: # light | medium | heavy reversibility: # two-way | costly | one-way assumptions: [] # deep only falsifier: # deep only grounding: [] # sources/referents the deliverable must cite decided_by: # the human's name date: ``` Every field above the line holds a **human answer** — never fill one with your own inference silently; propose and let the human confirm. --- ## Form B: fan-out (/think fan) When the human wants the analysis run by multiple agents (other model CLIs, subagents) rather than in this conversation: 1. Collect L5 answers first (quick or standard rounds as stakes dictate) — delegation without a contract is just outsourced guessing. 2. Write a **think-brief** file to the notes directory (`briefs/` subfolder): the decision contract so far + the specific L4 questions to analyze + the grounding requirements + the output format expected back. 3. Fan it out with whatever multi-agent mechanism is available (parallel subagents; or terminal-multiplexer fan-out to other agent CLIs if the user's environment has one). Each agent gets the same brief. 4. Collect the answers. **Synthesize with divergence surfaced** — where the agents disagree is precisely where a human decision is needed; present those points as loop-back questions (Level 5), not as things you resolved. 5. The human adjudicates; update the contract; proceed to L3 or stop. L4 fans out. **L5 never does** — no agent, including you, decides for the human which analysis wins. --- ## Level 1: Remember (save) Standard/deep: offer the save with one AskUserQuestion (recommended location first, "Don't save — exploratory" always an option). Quick: mention it in one line, don't ask unless the human bites. Write to the notes directory (see "Notes location"): - Filename: `YYYY-MM-DD-.md` - Frontmatter: `type` (decision/learning/research/pattern), `created`, `tags` (include the pillar), `status` - Body: the decision contract (yaml block) + Level 4 findings + the deliverable or a link to it + open questions - Cross-link related notes in the same directory if any exist The saved contract is what downstream agents and future sessions reference — save the *decisions and reasoning*, not just the deliverable. --- ## Rules 1. **Depth matches stakes.** Announce the selected depth and why; the human can always override. Never run deep ceremony on a two-way door; never let a one-way door through on three questions. 2. **Never answer L5/L6 questions for the human.** Options are directional framings; the substance is theirs. Free-text answers are always valid. 3. **Ground everything below the line.** Cite sources at L1, materials at L2, contract fields at L3. Flag any of your own claims you cannot ground. 4. **Loop back before building.** No L3 deliverable until surfaced decisions are resolved (standard/deep). If none surfaced, say so explicitly. 5. **The contract is the spec.** Compile it, keep it current through loop-backs and escalations, save it. 6. **L4 fans out; L5 never does.** In any multi-agent setup, divergence returns to the human as questions. 7. **Auto-fire transparency.** If this skill fires because context matched (not because the user invoked it), announce it in the first turn: "Auto-firing /think because [reason] — say 'skip' to opt out." Silent auto-fire skips the human's meta-decision to deliberate at all. 8. **Keep the human oriented.** Name the level you are operating at when it changes ("This is a Level 5 question — only you can decide."). 9. **Adapt wording to the domain/pillar** — generic question text is a fallback, not a default. Use `pillars.md` adapters when one clearly applies. --- ## Domain-adapted framings (for question options) **Legal/Agreement** — Purpose: strategic partnership / one-time transaction / risk protection. Risks: scope creep, weak exit clause, IP ambiguity, non-delivery. Commitment: non-binding exploration / binding limited scope / full commitment. **Product/Feature** — Purpose: user pain point / new market / internal cost. Risks: nobody uses it, tech debt outweighs value, scope balloons, security gap. Scope: MVP one flow / full feature / extensible platform. **Code/Architecture** — Purpose: new system / extend / replace-migrate. Success: passes review / handles production load / maintainable in 6 months. Risks: breaking existing behavior, over-engineering, security, performance. **Decision** — Purpose: choose between options / go-no-go / prioritization. Risks: analysis paralysis, unexamined default, irreversible-when-avoidable, missing third option. **Content/Writing** — Purpose: authority / education / engagement. Risks: too generic, too niche, tone mismatch, factual error. **Business/Strategy** — Purpose: new revenue / defend position / explore. Risks: market too small, execution speed, competition, runway. (Personal-pillar framings — health, relationships, money, learning, identity, time/energy, faith — live in `pillars.md`, marked experimental.) --- ## Session state Track which levels are complete. On `/think summary`, display: mode + reason, the contract so far, L4 loops run and what each surfaced, deliverable status, save status.