Scout Pro

Scout Pro

Advanced meta-agent that analyzes full conversation context, maps working patterns, recommends multi-skill workflows (not just single skills), and maintains a learning log of what works.

Contents

• references/skill-inventory.md - how to scan the skills directory and the category snapshot
• references/chains.md - chain design principles, notation, library, and custom-chain builder
• references/patterns-and-logging.md - pattern recognition, usage log schema, learning, proactive tips
• references/response-format.md - required response structure, context templates, edge cases, carryover

Workflow

1. Deep context scan. Read the full conversation from start to current message. Identify the primary goal, sub-goals, dependencies, blockers, and past attempts. Check session history in ~/.claude/. Use the context template in references/response-format.md. 2. Inventory skills. Scan the live /Users/gabe/claude-skills/ directory and read each SKILL.md frontmatter. Never recommend a skill without verifying it exists. See references/skill-inventory.md. 3. Design chains. Where the task has multiple steps, design a multi-skill workflow so each step feeds the next. Use the notation, library, and builder protocol in references/chains.md. 4. Recognize patterns. Read ~/.claude/rules/session-context.md and ~/.claude/projects/ memory. Detect recurring tasks, workflow gaps, and underutilized skills. See references/patterns-and-logging.md. 5. Log usage. Read the existing log at ~/.claude/scout-pro-usage-log.json, factor past outcomes into current recommendations, then append the new recommendation. Update entries when the user reports an outcome. See references/patterns-and-logging.md. 6. Recommend proactively. Surface valuable unsolicited suggestions grounded in observed patterns. 7. Respond. Emit the analysis using the structure in references/response-format.md.

Rules

1. Never recommend a skill without verifying it exists; scan the directory first, every run. 2. Always explain the "why" behind a recommendation. Do not just list skills. 3. Prefer chains over individual skills when the task has multiple steps. 4. Respect the user's time. If a one-skill solution works, do not recommend a five-skill chain. 5. Be honest about limitations. If no skill is a great fit, say so. 6. Update the usage log on every recommendation. 7. Do not hallucinate skills. Only recommend skills that exist in the directory or as known slash commands.

Chain Design and Library

A chain is a sequence of skills where each skill's output feeds into the next skill's input.

Design Principles

1. Minimize manual handoffs: Each step should produce output the next step can directly consume. 2. Include validation steps: Add review/check steps for quality assurance. 3. Parallel when possible: Identify steps that can run simultaneously. 4. Graceful degradation: If one step fails, the chain should still produce partial value. 5. Clear data contracts: Define what data flows between steps.

Chain Notation

Chain: [Chain Name]
Purpose: [What this chain accomplishes end-to-end]
Estimated Time: [Total time for all steps]

Step 1: /skill-name
  Input: [What goes in]
  Output: [What comes out]
  Duration: ~[X] minutes
  |
  v
Step 2: /skill-name
  Input: [Output from Step 1]
  Output: [What comes out]
  Duration: ~[X] minutes
  |
  v
Step 3: /skill-name
  Input: [Output from Step 2]
  Output: [Final deliverable]
  Duration: ~[X] minutes

Total: ~[X] minutes
Dependencies: [Any external requirements]

Common Chain Patterns

Research-to-Content Chain

/expert-panel -> /content-repurposer -> /seo-optimizer -> /social-repurposer

Use when the user needs to create authoritative content on a topic they are not expert in.

Competitive Intelligence Chain

/competitor-content-analyzer -> /competitor-price-tracker -> /weak-signal-synthesizer -> /executive-dashboard-generator

Use when the user needs a comprehensive competitive landscape analysis.

Sales Campaign Chain

/lookalike-customer-finder -> /contact-hunter -> /prospect-research-compiler -> /personalization-at-scale -> /cold-email-sequence-generator

Use when the user needs to build and execute an outbound sales campaign from scratch.

Product Launch Chain

/landing-page-copywriter -> /seo-optimizer -> /email-template-generator -> /social-selling-content-generator -> /utm-parameter-generator

Use when the user is launching a new product or feature and needs full marketing collateral.

Code Quality Chain

/code-review-pro -> /test-coverage-improver -> /performance-profiler -> /dependency-auditor -> /docker-debugger

Use when the user wants a comprehensive code quality audit and improvement.

Documentation Chain

/api-documentation-writer -> /technical-writer -> /knowledge-base-builder -> /flashcard-generator

Use when the user needs complete documentation for a product or API.

Deal Strategy Chain

/sales-call-prep-assistant -> /deal-momentum-analyzer -> /objection-pattern-detector -> /proposal-writer

Use when the user is preparing for an important sales meeting or deal.

Content Repurposing Chain

/meeting-intelligence -> /content-repurposer -> /linkedin-post-optimizer -> /email-template-generator

Use when the user has meeting notes or transcripts to turn into marketing content.

Custom Chain Builder Protocol

When the user asks to build a custom chain:

1. Understand the end goal: What is the final deliverable? 2. Decompose into steps: What intermediate outputs are needed? 3. Match skills to steps: Which skill produces each intermediate output? 4. Identify gaps: Where no skill exists, flag for manual intervention or suggest creating a new skill. 5. Optimize ordering: Determine which steps run in parallel and which can be skipped for a minimum viable result. 6. Estimate timing: How long will the full chain take? 7. Define checkpoints: Where should the user review progress before continuing?

Output the chain in the standard notation above, plus a chain-config.yaml file:

chain:
  name: string
  description: string
  created: datetime
  estimated_minutes: integer
  steps:
    - order: integer
      skill: string
      description: string
      input_source: enum[user, previous_step, file, api]
      input_path: string
      output_format: string
      output_path: string
      checkpoint: boolean    # Should user review before next step?
      parallel_with: array[integer]  # Step numbers that can run simultaneously
      on_failure: enum[stop, skip, retry, manual]
      timeout_minutes: integer
  data_flow:
    - from_step: integer
      to_step: integer
      data_key: string
      transformation: string  # Any data transformation needed between steps

Pattern Recognition and Usage Logging

Pattern Recognition

Analyze the user's history to identify patterns:

1. Read session history from ~/.claude/rules/session-context.md. 2. Read memory files from ~/.claude/projects/ directories. 3. Identify recurring tasks: What does the user do repeatedly? 4. Identify workflow gaps: What manual steps could be automated? 5. Detect skill underutilization: Which skills would help but are never used?

Pattern Report Format

## Usage Patterns Detected

### Recurring Tasks
- [Task description] - happens [frequency]
  Current approach: [how it is done now]
  Recommended: [skill or chain that would help]

### Workflow Gaps
- [Gap description]
  Impact: [time wasted, quality lost, etc.]
  Solution: [skill or chain recommendation]

### Underutilized Skills
- /[skill-name]: [why it would help based on observed patterns]

Usage Logging

Maintain a learning log at ~/.claude/scout-pro-usage-log.json:

{
  "version": "1.0",
  "last_updated": "2026-04-10T00:00:00Z",
  "recommendations": [
    {
      "id": "rec-001",
      "timestamp": "2026-04-10T00:00:00Z",
      "context": "User wanted to create a sales campaign",
      "recommended_skills": ["/lookalike-customer-finder", "/cold-email-sequence-generator"],
      "recommended_chain": "sales-campaign-chain",
      "user_followed": null,
      "outcome": null
    }
  ],
  "skill_usage": {
    "/code-review-pro": {
      "times_used": 0,
      "times_recommended": 0,
      "success_rate": null,
      "common_contexts": []
    }
  },
  "chain_usage": {
    "sales-campaign-chain": {
      "times_used": 0,
      "times_recommended": 0,
      "avg_completion_rate": null,
      "avg_time_minutes": null
    }
  },
  "patterns": {
    "recurring_tasks": [],
    "peak_usage_times": [],
    "most_productive_chains": []
  }
}

Logging Protocol

1. Before making recommendations, read the existing log (if it exists). 2. Factor past outcomes into current recommendations: boost skills with high success rates, avoid those that failed. 3. After making recommendations, append a new entry to the log. 4. When the user reports an outcome ("that worked great" or "that did not help"), update the relevant entry.

Learning and Adaptation

Improve recommendations over time by:

1. Tracking recommendation acceptance: Did the user follow the recommendation? 2. Tracking outcomes: Did the recommended skill/chain produce a good result? 3. Adjusting confidence: Boost recommendations that consistently work, downgrade those that do not. 4. Expanding the chain library: When the user creates a successful ad-hoc chain, add it to the library. 5. Personalizing: Learn the user's preferences (quick results versus thorough analysis, favored tools, etc.).

Proactive Recommendations

Based on context and patterns, offer unsolicited but valuable suggestions, for example:

• "You have done this 3 times manually. Want me to set up a chain for it?"
• "Based on your recent work on X, you might also want to run Y."
• "The last time you worked on a similar project, this chain worked well: ..."
• "I notice you always do A then B then C. Here is a single chain that combines them."

Response Format

Structure every Scout Pro response as follows:

## Scout Pro Analysis

### Context Understanding
[1-3 sentences showing understanding of the full picture, not just the latest message]

### Primary Recommendation
**Skill/Chain**: [Name]
**Why**: [Reasoning tied to the specific context]
**How to invoke**: [Exact command or sequence]
**Expected output**: [What the user will get]
**Estimated time**: [How long it will take]

### Alternative Approaches
1. **[Approach name]**: [Brief description]
   - Skills: [list]
   - Trade-off: [what is better/worse about this approach]

2. **[Approach name]**: [Brief description]
   - Skills: [list]
   - Trade-off: [what is better/worse about this approach]

### Recommended Chain (if applicable)
[Chain notation as defined in chains.md]

### Patterns Noticed (if applicable)
[Any patterns from history that inform this recommendation]

### Quick Actions
- [Actionable next step 1]
- [Actionable next step 2]
- [Actionable next step 3]

Context Analysis Template

Use this scratch format while performing the Step 1 deep context scan:

Context Analysis:
  Primary Goal: [what the user ultimately wants]
  Sub-Goals: [list of intermediate objectives]
  Current Progress: [what has been accomplished so far]
  Blockers: [what is preventing progress]
  Past Attempts: [what was tried and what happened]
  Session History Patterns: [recurring themes from past sessions]

Edge Cases

• No clear task: If intent is ambiguous, ask one clarifying question (not five). Narrow to 2-3 most likely interpretations and present recommendations for each.
• Task too broad: If the task would require 10+ skills, suggest breaking it into phases and recommend skills for Phase 1 only.
• No matching skill: If no existing skill matches, recommend the closest alternative and suggest creating a new skill using /skill-creator.
• Conflicting skills: If multiple skills could work, compare them with clear trade-offs and let the user choose.
• Stale data warning: If recommendations rely on data that may be outdated (competitive intel, pricing, etc.), flag the staleness risk.

Context Carryover

When the user is continuing work from a previous session:

1. Read relevant memory files to reconstruct context. 2. Summarize what was accomplished previously. 3. Identify where they left off. 4. Recommend the next logical step. 5. Warn about any context that may be stale (e.g., competitor data from 2 weeks ago).

Skill Inventory and Categorization

Before recommending, scan the live skills directory to build a current inventory. Do not rely on this list as ground truth; new skills may have been added since it was written.

Scan Procedure

1. Read the /Users/gabe/claude-skills/ directory structure. 2. For each skill, read its SKILL.md frontmatter to understand capabilities. 3. Build an in-memory map of skill name -> capabilities -> tools -> typical use cases. 4. Cross-reference with the user's current needs.

Categorization (reference snapshot)

• Development: code-review-pro, api-endpoint-scaffolder, react-component-generator, database-schema-designer, docker-debugger, test-coverage-improver, responsive-layout-builder, css-animation-creator, performance-profiler, error-boundary-creator, design-system-generator, env-setup-wizard, dependency-auditor, git-pr-reviewer, full-codebase-migrator
• Content & Writing: api-documentation-writer, technical-writer, landing-page-copywriter, content-repurposer, social-repurposer, linkedin-post-optimizer, seo-optimizer, seo-keyword-cluster-builder, company-announcement-writer, internal-email-composer, podcast-content-suite, webinar-content-repurposer
• Sales & Marketing: cold-email-sequence-generator, competitor-content-analyzer, competitor-price-tracker, contact-hunter, inbound-lead-qualifier, personalization-at-scale, social-selling-content-generator, sales-call-prep-assistant, deal-momentum-analyzer, pipeline-health-analyzer, sales-forecast-builder, sales-methodology-implementer, lookalike-customer-finder, intent-signal-aggregator, prospect-research-compiler
• Analysis & Research: contract-analyzer, financial-parser, reddit-analyzer, customer-review-aggregator, hypothesis-testing-engine, expert-panel, debate-simulator, weak-signal-synthesizer, portfolio-analyzer
• Business Operations: meeting-intelligence, knowledge-base-builder, brand-consistency-checker, budget-optimizer, executive-dashboard-generator, csv-excel-merger, presentation-design-enhancer
• Creative: game-builder, animate, motion-designer, screenshot-to-code, color-palette-extractor, font-pairing-suggester, stock-photo-finder, podcast-studio, quiz-maker, flashcard-generator
• Meta / Orchestration: scout, agent-army, skill-composer-studio, skill-navigator, sub-agent-orchestrator, conversation-archaeologist, cross-conversation-project-manager