Recommend

Runtime Configuration (Step 0 — before any processing)

Read these files to configure recommendation behavior:

1. ${CLAUDE_PLUGIN_ROOT}/reference/tradition-presets.md — tradition and use-case presets

   • Pre-validated coherence points in the 8-dimension space
   • Starting points for customization, not final answers

2. ${CLAUDE_PLUGIN_ROOT}/reference/methodology.md — universal methodology principles

3. ${CLAUDE_PLUGIN_ROOT}/reference/components.md — component blueprints (what can be toggled)

4. ${CLAUDE_PLUGIN_ROOT}/reference/dimension-claim-map.md — maps each dimension position to supporting research claims

5. ${CLAUDE_PLUGIN_ROOT}/reference/interaction-constraints.md — hard blocks, soft warns, cascade effects between dimensions

6. ${CLAUDE_PLUGIN_ROOT}/reference/claim-map.md — topic navigation for the research graph

If any reference file is missing, note the gap but continue with available information. The recommendation degrades gracefully — fewer citations, same structure.

EXECUTE NOW

Target: $ARGUMENTS

Parse immediately:

• If target is empty or a question: enter conversational mode — ask 1-2 clarifying questions, then recommend
• If target contains a use case description: proceed directly to recommendation mode
• If target contains --compare [A] [B]: enter comparison mode — compare two presets or configurations

START NOW. Reference below defines the workflow.

Philosophy

Advisory, not generative.

/recommend exists for exploration. The user is considering a knowledge system — maybe they have a use case, maybe they're comparing approaches, maybe they're curious what the research says about a specific pattern. /recommend answers with specific, research-backed reasoning without creating any files.

This is the entry point before commitment. /setup generates a full system. /recommend sketches what that system would look like and WHY, so the user can decide whether to proceed. Every recommendation traces to specific research claims. "I recommend X" is never enough — "I recommend X because [[claim]]" is the minimum.

The relationship to other skills:

• /recommend → advisory sketch (no files)
• /setup → full system generation (creates everything)
• /architect → evolution advice for EXISTING systems (reads current state)
• /refactor → implements changes to EXISTING systems (modifies files)

/recommend is the only one that works without an existing system. It's pure reasoning from research.

Phase 1: Understand the Constraints

1a. Parse User Input

Extract signals from the user's description. Every word is a signal:

1b. Conversational Mode (when input is sparse)

If the user's description lacks critical signals, ask at most 2 clarifying questions. Frame them as choices, not open-ended:

To recommend the right architecture, I need two things:

1. **What kind of knowledge?** (pick closest)
   - Research/learning — tracking claims, building arguments
   - Creative — drafts, revisions, inspiration
   - Operational — tasks, decisions, processes
   - Personal — reflections, goals, relationships
   - Mixed — multiple of the above

2. **Who operates it?**
   - Mostly you (human-maintained)
   - Mostly an AI agent
   - Both (shared operation)

Do NOT ask more than 2 questions. The recommendation can always be refined. Get enough to start, then recommend.

1c. Signal Insufficiency

If after parsing (and optional questions) you still lack critical information, make reasonable defaults and STATE them:

Assuming:
- Platform: Obsidian (most common for personal knowledge)
- Scale: moderate (50-200 notes in first year)
- Operator: human-primary with occasional AI assistance

These assumptions affect the recommendation. Correct any that don't match.

Phase 2: Match to Preset

2a. Read Presets

Read ${CLAUDE_PLUGIN_ROOT}/reference/tradition-presets.md. This file contains:

• Tradition presets — Zettelkasten, PARA, Evergreen, Cornell, etc.
• Use-case presets — research, creative writing, engineering, therapy, etc.

2b. Find Closest Match

Score each preset against the user's signals:

2c. Report the Match

State the closest preset and explain the match:

Closest preset: [preset name]
Match quality: [strong/moderate/partial]

Why: [1-2 sentences explaining the match]
Adjustments needed: [what needs to change from the preset baseline]

If the user's description blends multiple presets, explain the blend:

This blends two presets:
- [Preset A] for [which aspects]
- [Preset B] for [which aspects]

Starting from [Preset A] and adjusting [specific dimensions] toward [Preset B].

Phase 3: Search for Relevant Research

3a. Topic-Based Search

Use ${CLAUDE_PLUGIN_ROOT}/reference/claim-map.md to identify which research topics apply to the user's use case. Read the claim map and identify relevant topic clusters.

3b. Semantic Search

Use qmd tools to find research claims that apply to the user's specific constraints:

mcp__qmd__deep_search  query="[user's domain] knowledge management patterns"
mcp__qmd__vector_search  query="[user's specific concern or goal]"

Fallback chain:

• MCP tools (mcp__qmd__deep_search, mcp__qmd__vector_search, mcp__qmd__search)
• qmd CLI (qmd query, qmd vsearch, qmd search)

Run 2-4 targeted searches based on the user's signals. Focus on:

• Domain-specific patterns (if the research covers their domain)
• Processing philosophy (batch vs continuous, deep vs light)
• Scale considerations (what changes as the system grows)
• Pain point research (what causes the friction they described)

3c. Read Relevant Claims

For each search result that looks relevant, read the claim via mcp__qmd__get (or mcp__qmd__multi_get for batch reads) to understand the full argument. You need enough depth to cite with confidence.

Collect 5-15 relevant claims. You won't cite all of them — but you need a pool to draw from.

Phase 4: Map Signals to Dimensions

4a. Read Dimension-Claim Map

Read ${CLAUDE_PLUGIN_ROOT}/reference/dimension-claim-map.md. This maps each dimension position to the research claims that support it.

4b. Determine Each Position

For each of the 8 configuration dimensions, determine the recommended position:

Granularity — atomic / moderate / compound

• Key signals: domain type, processing style, reuse intent
• Atomic: research, argument-building, cross-domain synthesis
• Moderate: most use cases, balanced effort-to-value
• Compound: creative writing, narrative, sequential content

Organization — flat / hierarchical

• Key signals: scale, navigation preference, operator type
• Flat: <200 notes, agent-operated, wiki-link navigation
• Hierarchical: >500 notes, human-operated, folder navigation

Linking — explicit / explicit+implicit

• Key signals: platform capabilities, scale, discovery needs
• Explicit only: simple systems, human-maintained, low volume
• Explicit+implicit: semantic search available, agent-operated, discovery-focused

Processing — heavy / moderate / light

• Key signals: content type, time budget, value of deep analysis
• Heavy: research, argument-building, agent-operated
• Moderate: mixed content, balanced effort
• Light: quick capture, high volume, low ceremony

Navigation — 2-tier / 3-tier / 4-tier

• Key signals: expected scale, domain complexity
• 2-tier: <100 notes, single domain
• 3-tier: 100-500 notes, multiple sub-domains
• 4-tier: 500+ notes, complex multi-domain

Maintenance — condition-based (tight) / condition-based (lax) / manual

• Key signals: operator type, automation level, system criticality, rate of change
• Condition-based (tight thresholds): high-volume, agent-operated, fast-changing domains
• Condition-based (lax thresholds): low-volume, stable domains
• Manual: minimal ceremony, on-demand only

Schema — minimal / moderate / dense

• Key signals: query needs, processing depth, metadata tolerance
• Minimal: description only, low ceremony
• Moderate: description + type + topics, queryable
• Dense: full provenance, validation, structured queries

Automation — full / convention / manual

• Key signals: operator type, platform capabilities, trust level
• Full: agent-operated, platform supports hooks
• Convention: shared human-agent operation
• Manual: human-primary, learning the system