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 <skill base directory>/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 <resolved default>?" with the resolved default recommended, plus "Somewhere else (type a path)". Write the choice to <skill base directory>/config.json as {"notes_dir": "<absolute path>"} 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/<name>/, 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": "<UTC ISO>", "topic": "<current topic>", "text": "<text>"} as one JSON line to <skill base directory>/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"

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:

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-<topic-slug>.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.