Think

Research, decide, and codify knowledge into reference files.

Don't Overthink Think

This skill is for: "I don't know what happens next. I just need to start."

Something came your way -- a video, a voice memo, a vague feeling, a problem to solve. You don't need a plan. Just start. The skill finds the overlap between your interest and your offer.

Re-invoke often. Saying /think again is normal. It reloads context. Do it after:

• •Reading a large transcript (burns tokens)
• •Compaction (context window reset)
• •Switching focus
• •Anytime you feel lost

Two Modes of Work

Before diving in, know which mode you're in:

/think is for enriching the core. When you're ready to create output from your reference files, output generation skills (ads, organic content, video scripts, landing pages) are available with Main Branch Premium.

Both are work. Enriching the core levels up everything downstream.

Tool Detection (YAML-Backed)

Tool status is persisted in .mainbranch/config.yaml under the tools: key. This avoids re-checking env vars and installs every session.

How It Works

1. Read .mainbranch/config.yaml -> tools section
2. For each tool:
   - status: true  -> Trust it, skip detection
   - status: false -> Skip it, don't nag
   - status: null  -> Run detection, update config
   - missing entry -> Run detection, add entry to config
3. Report results once per session

Detection Script

Run once per session to probe unknown tools:

bash .claude/skills/think/scripts/detect-tools.sh

See scripts/detect-tools.sh for the full implementation.

After Detection

If any tool was probed and found, update .mainbranch/config.yaml with the result so future sessions skip detection. Use Edit to set status: true or status: false as appropriate.

Report Format

All tools known (fast path -- no detection needed):

"Tools: Apify, Gemini, Grok, whisper -- all verified in config."

Mix of known and missing:

"Tools: Apify, Gemini ready. Grok not configured (optional). whisper not installed."

If Apify missing (important -- affects mining):

"Apify MCP not detected. YouTube transcripts and Instagram mining won't work. Set up now? (5 min, one-time)"

Why This Matters

• •Apify missing = limited mining (YouTube, Instagram)
• •Grok missing = web fallback for X research (still works, less real-time)
• •Gemini missing = Claude Code handles synthesis (still works, more token use)
• •whisper missing = can't transcribe local files (offer CLI setup)
• •YAML-backed = no wasted time re-probing every session

Where Files Go

All files save to YOUR business repo, not the engine.

your-business-repo/          <- Files saved here
├── research/                 <- Research output
├── decisions/                <- Decision output
└── reference/                <- Codify updates this

Route by Intent

Detect mode from user's natural language:

If unclear, ask: "Are you exploring a question, documenting a decision, or updating reference files?"

Research Routing by Intent

When routing to research mode, detect research TYPE from user intent:

Multiple types needed at once? Spawn them as parallel Task agents in a single message. Example: user says "research what [creator] says on YouTube and what people think on X" -- spawn one agent for YouTube transcript mining and another for X/Twitter sentiment simultaneously. Each saves its own research file; main conversation synthesizes when both return.

Routing Logic

1. Parse user message for intent triggers
2. Check if preferred tool is available (from session cache)
3. If multiple sources needed -> spawn parallel Task agents (one per source)
4. If single source -> use preferred tool directly
5. If not available -> offer setup ONCE, then use fallback
6. Never block on missing optional tools

Fallback Examples

YouTube without Apify:

"YouTube transcript mining needs Apify MCP. Options:

1. •Set up Apify now (5 min)
2. •Paste transcript manually
3. •Skip this video"

X/Twitter without Grok:

"X sentiment research is best with Grok, but I can use web search instead. Results will be less real-time. Proceed with web search?"

Deep research without Gemini:

"Running comprehensive research using Claude Code web search. This may take longer than Gemini deep research."

Local file without whisper:

"Local transcription needs whisper-mcp or CLI tools. Check: which whisper-cli. Or upload to a transcription service and paste the result."

Key Principle

Never block on missing tools. WebSearch + codebase search are ALWAYS available. External tools enhance but don't gate research.

Active Guidance (Your Job)

Don't just provide templates. Actively move people through the cycle.

On every /think invocation, detect state and guide the next step:

# Check for work in progress
ls -lt research/*.md 2>/dev/null | head -3
grep -l "status: proposed\|status: accepted" decisions/*.md 2>/dev/null
# Also check content strategy state
ls reference/domain/content-strategy.md 2>/dev/null

The goal is reference files. Research and decisions are waypoints. Keep asking: "What needs to happen to get this into reference?"

Full Flow (Default)

Research -> Checkpoint -> Decide -> Checkpoint -> Codify

1. Define Question

"What specifically are you trying to figure out?"

2. Research

Gather from codebase, web, user input, local recordings.

When research involves 2+ sources (e.g., YouTube + web, X/Twitter + codebase, competitor mining + deep research), spawn parallel Task agents in a single message -- one agent per source. Use subagent_type: "general-purpose" (has Write, Edit, Bash, MCP access). Each agent:

• •Gets a focused prompt: one source, one research question
• •Writes its own dated file (e.g., research/YYYY-MM-DD-topic-yt-mining.md)
• •Verifies the write: checks the file exists after writing (use Read or ls)
• •Returns: file path + write status + 5-bullet summary
• •If write failed: returns the full research content so main conversation can write it
• •Does NOT need the full business context -- just the research question and source instructions

After all agents return: Check that files landed on disk. If any agent reported a write failure or the file doesn't exist, write it from the returned content. Then synthesize across summaries. This keeps heavy content out of your main context window while recovering gracefully from the known Claude Code subagent write persistence bug.

Do NOT run research agents in background (run_in_background: true) -- background agents cannot access MCP tools (Apify, etc.) and cannot prompt for permissions.

Mining sources:

3. Synthesize (Required)

Every research output needs:

• •One-sentence summary (20 words max)
• •Key findings (5-10 bullets)
• •Implications for reference files
• •Open questions

Synthesis works best when the main conversation is clean -- which is exactly what subagents provide. Heavy raw content (transcripts, mined posts) lives in the subagent context windows, and only distilled summaries return to main.

For content mining specifically: AI shows WHAT worked. You must judge WHY.

Extract three dimensions from mined content:

• •Visual -- Format, production style, patterns
• •Audible -- Energy, pacing, delivery
• •Emotional -- Primary emotion, identity play

Framework extraction is human judgment work. AI surfaces the data; you interpret the frameworks. This methodology comes from Koston Williams (6M view video) -- the skill isn't copying, it's framework transfer. A competitor's content worked for THEM. Your job is to:

1. •See the framework beneath the content
2. •Judge whether it transfers to YOUR context
3. •Adapt it to YOUR voice and audience
4. •Codify what you learned into reference files

Don't skip to content generation. Mining -> Human Synthesis -> Reference Update -> THEN Create.

4. Checkpoint

"Ready to make a decision, or need more research?"

5. Decide

Present options with pros/cons. Document choice and rationale.

6. Action Items

List action items in the decision file:

## Action Items
- [ ] Update reference/core/offer.md - Add guarantee section
- [ ] Create reference/proof/angles/risk-reversal.md

Optionally create Claude tasks for execution tracking. See decide-phase.md.

7. Checkpoint

"Ready to update reference files now, or save for later?"

8. Codify

Apply action items to reference files. Mark decision as codified.

Codify targets include: reference/core/*.md, reference/proof/angles/*.md, reference/proof/testimonials.md, reference/domain/content-strategy.md (pillars, hooks library, framework library, metrics).

Research Mode

/think research "topic"

Output: research/YYYY-MM-DD-topic-claude-code.md

See references/research-phase.md for full workflow.

Decide Mode

/think decide "topic"

Output: decisions/YYYY-MM-DD-topic.md

See references/decide-phase.md for full workflow.

Codify Mode

/think codify decisions/YYYY-MM-DD-topic.md

Or: "/think add new testimonials to my files"

See references/codify-phase.md for full workflow.

Task Tracking Layers

Decision files are the anchor -- create early with status: proposed, update to accepted, then codified.

See decide-phase.md for task creation patterns. See recovery.md for resuming sessions.

Recovery

If conversation compacted, check multiple sources:

1. Claude tasks (current session):

TaskList

2. Recent files:

ls -lt research/*.md 2>/dev/null | head -5
grep -l "status: proposed\|status: accepted" decisions/*.md 2>/dev/null

3. GitHub issues (if using):

gh issue list --assignee @me --state open

Then confirm: "I see you were working on [topic]. Continue from here?"

See references/recovery.md for details.

Templates

• •references/templates/research-template.md
• •references/templates/decision-template.md

When NOT to Use

• •Quick factual questions (just ask)
• •Simple file edits (just edit)
• •Generating output content (output generation skills like ads, organic content, video scripts, and landing pages are available with Main Branch Premium)

Use /think when the answer requires investigation and the choice needs documentation.

Why This Matters

The repo is a precision instrument. The think cycle exists to filter -- not to cram everything in. Research gets synthesized, decisions get distilled, and only the sharpest insights survive into reference. Curation over collection.

Reference files aren't just documentation. They're how you stay connected to why you do this.

The act of researching, deciding, and codifying forces you to articulate:

• •Why you do this -- Not the marketing reason. The real reason.
• •Who actually benefits -- Not demographics. Real people whose lives change.
• •What transformation you enable -- Not features. The before/after.

Research and decisions go stale. Reference files compound. Every update makes all downstream content better.

If the overlaps between your interests and your offer don't make sense, maybe you have the wrong offer. The think cycle should feel like pull, not push.