Mb Think

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 /mb-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

Save progress at natural boundaries. After a research batch, accepted decision, codify pass, or major reference-file update, ask whether to checkpoint. Run mb checkpoint --plan --json, show the proposed message, validate with mb checkpoint --validate "..." --json, then save with mb checkpoint --message "..." --yes only after approval; no hidden checkpoints.

Shared source: The portable thinking workflow contract lives in workflows/mb-think/workflow.md. This Claude skill is the Claude Code shell over that source.

Shared contract markers: Keep these aligned with the shared source.

Required commands:

• mb status --json --peek
• mb start --json
• mb doctor repair --plan
• mb connect doctor --json
• mb checkpoint --plan --json

Required fact paths:

• money_path
• money_path.objects.offer
• money_path.objects.proof
• money_path.objects.proof.quality
• money_path.objects.product_ladder
• money_path.objects.cta_path
• money_path.objects.channel_strategy
• money_path.objects.active_push
• money_path.objects.outcome_feedback_loop
• money_path.ranked_actions
• validation.file_contracts
• content_strategy
• ranked_actions
• update
• readiness
• drift.items
• books
• runtime.codex_cli
• runtime.claude_code

Approval gates: updates_repairs_migrations, file_writes, checkpoint, provider_mutation, publishing_or_spend, customer_contact, private_data, destructive_operations, structured_collection, and public_issue_or_proposal.

Public/private boundaries: no_secrets, no_raw_provider_exports, no_raw_transcripts, no_customer_member_data, no_private_runtime_settings, no_private_dms_or_gated_communities, and no_raw_finance_legal_records.

Core route: research depth recommendation, parallel research files for source-specific research files when multiple source types are needed, decision, codify, stale source cleanup, public/private handling, checkpoint plan, checkpoint approval, and explicit write approval. Do not tell Codex users to run Claude Code entrypoints.

When research identifies a reusable growth mechanic such as a comment-keyword, DM-keyword, public reply/link, resource delivery, provider setup recipe, or approval gate, route the durable plan into pushes/<YYYY-MM-DD-slug>/playbooks/<playbook>.md with type: playbook. Playbooks are plans, approval records, safe provider-state notes, validation evidence, and outcome hooks. They are not provider execution.

When the operator asks for a researched brief, site brief, launch brief, or research meant to feed /mb-ads, /mb-site, or push playbooks, support:

/mb-think --brief-format=grok-8 <topic>

Load references/grok-8-brief-format.md. This mode structures findings across eight categories: business/offering, ICP, journey, competitive landscape, brand story, technical requirements, content assets, and metrics/constraints. Use it as an opt-in format, not the default unless the operator chooses it.

Two Modes of Work

/mb-think is for enriching the core. When you're ready to create, use /mb-ads, /mb-organic, /mb-site, or just ask.

Pull Latest Updates

See references/pull-engine-updates.md for the standard Main Branch update check. Run it at the start of every /mb-think invocation.

CLI Facts First

Provider readiness comes from mb first. Run or reuse:

mb status --json --peek
mb connect doctor --json

Use those facts for GitHub, Google/Workspace, Meta Ads, and other provider repair language. Apify research remains MCP-first for now: treat it as an agent-side research tool surface unless a later CLI contract exposes stable provider-readiness facts. Runtime-local tool checks happen only after a selected research path needs them and mb cannot inspect the tool directly.

Quick gist: On first /mb-think invocation, read status/connect facts. When the user's intent needs a runtime-local tool, check only that tool, cache session knowledge, and offer the mb connect repair command or a fallback. Surface a missing-tool option once per session per tool.

See references/tool-detection.md for the full status-value table, staleness rules, per-tool detection methods (Apify, Gemini, Grok, whisper, Nano Banana, Meta ad account context, document tools), required config-update format, and the intent-based tool surfacing matrix.

For self-healing semantics (stale false handling, status-change messaging, true-tool degradation), see tool-status-self-healing.md.

Offer Context Resolution

Before loading reference files, resolve the active offer and target file type with .claude/reference/business-primitives/offer-bet-push-proof.md:

1. If a future mb JSON field exposes active offer state, use it.
2. Do not treat .vip/local.yaml as the source of truth for active-offer state. If legacy state exists, confirm the offer with the user instead of silently routing.
3. If an offer is selected and core/offers/[offer]/offer.md exists, load it as the active offer.
4. If no offer is selected AND core/offers/ exists: ask which offer.
5. If no core/offers/ folder: use core/offer.md (single-offer mode)
6. If the repo does not have core/, do not infer current offer context from old paths. Run mb doctor repair --plan; use reference/* only as legacy migration input.

Always-core files: soul.md, voice.md, content-strategy.md. See codify-phase.md for content strategy layers. Offer-aware files: offer.md, audience.md Proof files: company-wide proof uses core/proof/testimonials.md, core/proof/typicality.md, and core/proof/angles/; offer-specific proof uses matching files under core/offers/<slug>/proof/. When codifying proof, make permission, offer-link, outcome, timeframe, metric, and typicality facts explicit so money_path.objects.proof.quality can see them; use permissioned_public: false for internal proof awaiting public permission. If status reports money_path.objects.proof.quality.public_marketing.status: blocked, collect permission before ads, pages, or public claims use that proof. When validation.file_contracts reports offer gaps, use the findings as the intake checklist and fill missing audience, promise, mechanism, proof, price/value, or next-step context only after operator approval.

For a live idea, ask whether it is something to keep selling or something to test before deciding. Use bets/ for the time-boxed wager, offer files for durable sellable truth, pushes/ for coordinated execution, and decisions/ for accepted rationale that changes durable truth.

Where Files Go

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

your-business-repo/          <- Files saved here
├── research/                 <- Research output
├── decisions/                <- Decision output
├── core/                     <- Brand-level codify updates
│   ├── offers/               <- Per-offer codify updates
│   ├── proof/                <- Testimonials, typicality, angles
│   ├── brand/                <- Visual identity and brand systems
│   └── operations/           <- Fulfillment, classroom, funnel, membership notes

mainbranch/ (engine)          <- Never modified

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 Principle

Never block on missing optional tools. Use web/codebase search, pasted source material, manual exports, or the provider repair command from mb connect. See references/tool-detection.md for exact tool-specific fallback wording.

Active Guidance (Your Job)

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

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

# Check for continuity and rationale state
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 core/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: Use research-routing-quick-ref.md and the source-specific references for tool choice and output suffixes. Authenticated community, calls, Drive/provider exports, and other private source mixes route through source-ingestion.md.

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 authenticated or private sources, run the source-ingestion rail first and keep raw transcripts/provider payloads out of committed files by default.

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. What Changes

Describe what reference files are affected in the decision file:

## What Changes

offer.md gets a guarantee section after pricing. A new angle file (risk-reversal.md) captures the guarantee messaging.

See decide-phase.md for format details.

7. Checkpoint

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

8. Codify

Apply changes described in ## What Changes to reference files. Mark decision as codified.

Codify targets include: core/*.md, active offer/audience files, proof files, core/content-strategy.md, core/marketing/..., core/people/..., core/team/<slug>.md, core/operations/funnel/skool-surfaces.md, core/product-ladder.md, and bets/ only when updating the live wager or verdict. See codify-phase.md for layer-specific rules.

Research Mode

/mb-think research "topic"

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

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

For ad, customer, review, competitor, and social-comment mining, use references/winning-ad-research.md to keep the research structured before handing off to /mb-ads or /mb-organic. For broad researched briefs that should feed ads, sites, organic content, or a push playbook, use references/grok-8-brief-format.md and set brief_format: grok-8 in frontmatter.

For offer-launch demand validation, use references/keyword-gate.md. It writes a dated keyword-gate research file with a Build / Build with caution / Kill verdict, recommended lander cluster, ready-to-buy terms, and negative keyword seeds for /mb-site and /mb-ads.

Decide Mode

/mb-think decide "topic"

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

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

Codify Mode

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

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

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

Work Continuity Layers

Decision status is rationale maturity, not a general work-progress board: proposed means a direction is drafted, accepted means the operator chose it, and codified means the rationale has been integrated into durable business or engine truth.

See decide-phase.md for decision lifecycle patterns. See recovery.md for resuming sessions.

Recovery

If conversation compacted, check multiple sources:

1. Claude tasks (current session):

TaskList

2. Recent files and rationale state:

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

3. GitHub issues (when durable work threads are needed):

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/grok-8-brief-format.md
• references/templates/decision-template.md

When NOT to Use

• Quick factual questions (just ask)
• Simple file edits (just edit)
• Generating content (use /mb-ads, /mb-site, /mb-organic)

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

Why This Matters

Keep what changes the business. Leave the rest in research. Reference files get stronger when each accepted decision makes the offer, proof, audience, voice, or content strategy clearer.