opportunity-scout

Original source / Raw SKILL.md

---
name: opportunity-scout
description: >
  Find profitable business opportunities in any niche by scanning Twitter, web, Reddit,
  and Product Hunt for unmet needs and pain points. Scores each opportunity on Demand,
  Competition, Feasibility, and Monetization (1-5 each, max 20). Generates a ranked report
  with actionable recommendations. Use when asked to find business ideas, market gaps,
  product opportunities, or "what should I build" questions. Also triggers on: market research,
  niche analysis, opportunity hunting, trend scouting, competitive analysis for new products.
---

# AI Opportunity Scout

Find what people need → evaluate if you can build it → decide if it's worth it.

## Quick Start

When the user specifies a niche (e.g. "AI agents", "crypto trading", "SaaS tools"):

1. Run the scout pipeline below
2. Score each finding with `scripts/scout.py`
3. Present the ranked report

## Scout Pipeline

### Step 1: Gather Data (use your built-in tools)

Run these searches, adapting queries to the user's niche:

**Twitter** (via exec):
```bash
bird search "[niche] need OR wish OR looking for OR frustrated" --limit 20
bird search "[niche] tool OR plugin OR solution" --limit 20
```

**Web** (via web_search tool):
- `"[niche] pain points 2026"`
- `"[niche] tools people want"`
- `"site:reddit.com [niche] need OR wish OR looking for"`
- `"site:producthunt.com [niche]"`

**ClawHub** (if niche is AI/agent related):
```bash
clawdhub search "[niche keyword]"
```

### Step 2: Identify Opportunities

From the raw data, extract distinct opportunities. Each opportunity = a specific unmet need that could become a product. Look for:

- Repeated complaints/requests (same problem mentioned 3+ times)
- Gaps between what exists and what people want
- Problems with existing solutions (too expensive, too complex, missing features)
- Emerging trends without established solutions

### Step 3: Score Each Opportunity

Run the scoring script:
```bash
python3 scripts/scout.py score --input opportunities.json --output report.md
```

Or score manually using these criteria (1-5 each):

| Criterion | 5 (Best) | 3 (Medium) | 1 (Worst) |
|-----------|----------|------------|-----------|
| **Demand** | 50+ people asking | 10-20 mentions | 1-2 mentions |
| **Competition** | No solutions exist | Some solutions, all flawed | Saturated market |
| **Feasibility** | Build MVP in 1-2 days | 1-2 weeks | Months of work |
| **Monetization** | People actively paying for similar | Freemium possible | Hard to charge |

**Total Score interpretation:**
- **16-20**: 🔥 BUILD IT NOW
- **12-15**: 👍 Strong opportunity, worth pursuing
- **8-11**: 🤔 Monitor, not urgent
- **4-7**: ❌ Skip

Detailed scoring examples: see `references/scoring-guide.md`

### Step 4: Generate Report

Format results as:

```
# Opportunity Scout: [Niche] — [Date]

## 🏆 Top 3 Opportunities

### 1. [Name] (Score: X/20)
- **Problem:** [What people need]
- **Evidence:** [Links/quotes from research]
- **Scores:** D:[X] C:[X] F:[X] M:[X]
- **Action:** [What to build, how long, how to monetize]

### 2. [Name] (Score: X/20)
...

## All Findings

| # | Opportunity | D | C | F | M | Total | Verdict |
|---|------------|---|---|---|---|-------|---------|
| 1 | ... | | | | | | |

## Recommendation
[Which to build first and why]
```

## Depth Modes

- `--depth quick`: 2 Twitter + 2 web searches. Fast scan, ~2 min.
- `--depth normal`: 4 Twitter + 4 web + ClawHub. Standard, ~5 min.
- `--depth deep`: 6 Twitter + 8 web + ClawHub + Reddit deep dive. Thorough, ~10 min.

## Tips

- Focus on problems people PAY to solve, not just complain about
- "I wish..." and "Does anyone know a tool for..." = strongest signals
- Check if existing solutions are abandoned/unmaintained — easy to replace
- Crypto/finance niches: high monetization but also high competition
- Niche down: "AI agent for dentists" beats "AI agent" every time


---

## Referenced Files

> The following files are referenced in this skill and included for context.

### scripts/scout.py

```python
#!/usr/bin/env python3
"""
AI Opportunity Scout — Scoring & Report Generator

Usage:
  # Score opportunities from JSON input
  python3 scout.py score --input opportunities.json --output report.md

  # Score from stdin (agent pipes data)
  echo '[{"name":"...", "problem":"...", "evidence":["..."], "demand":4, "competition":3, "feasibility":5, "monetization":4}]' | python3 scout.py score --output report.md

  # Interactive mode: agent provides scores via prompts
  python3 scout.py interactive --niche "AI agents"

  # Generate empty template
  python3 scout.py template --niche "AI agents" --count 5 --output opportunities.json
"""

import argparse
import json
import sys
from datetime import datetime
from pathlib import Path


def validate_score(score: int, field: str) -> int:
    """Validate score is 1-5."""
    if not isinstance(score, int) or score < 1 or score > 5:
        print(f"⚠️  Invalid {field} score: {score}. Must be 1-5. Clamping.", file=sys.stderr)
        return max(1, min(5, int(score)))
    return score


def score_verdict(total: int) -> str:
    """Return verdict based on total score."""
    if total >= 16:
        return "🔥 BUILD NOW"
    elif total >= 12:
        return "👍 Strong"
    elif total >= 8:
        return "🤔 Monitor"
    else:
        return "❌ Skip"


def generate_report(opportunities: list, niche: str) -> str:
    """Generate markdown report from scored opportunities."""
    # Sort by total score descending
    for opp in opportunities:
        opp["demand"] = validate_score(opp.get("demand", 3), "demand")
        opp["competition"] = validate_score(opp.get("competition", 3), "competition")
        opp["feasibility"] = validate_score(opp.get("feasibility", 3), "feasibility")
        opp["monetization"] = validate_score(opp.get("monetization", 3), "monetization")
        opp["total"] = opp["demand"] + opp["competition"] + opp["feasibility"] + opp["monetization"]
        opp["verdict"] = score_verdict(opp["total"])

    opportunities.sort(key=lambda x: x["total"], reverse=True)

    date = datetime.now().strftime("%Y-%m-%d")
    lines = []
    lines.append(f"# Opportunity Scout: {niche} — {date}\n")

    # Executive summary
    top3 = opportunities[:3]
    build_now = [o for o in opportunities if o["total"] >= 16]
    strong = [o for o in opportunities if 12 <= o["total"] < 16]

    lines.append("## Executive Summary\n")
    lines.append(f"Scanned **{len(opportunities)}** opportunities in the **{niche}** niche.")
    lines.append(f"- 🔥 Build Now: **{len(build_now)}**")
    lines.append(f"- 👍 Strong: **{len(strong)}**")
    lines.append(f"- 🤔 Monitor: **{len([o for o in opportunities if 8 <= o['total'] < 12])}**")
    lines.append(f"- ❌ Skip: **{len([o for o in opportunities if o['total'] < 8])}**\n")

    # Top 3
    lines.append("## 🏆 Top 3 Opportunities\n")
    for i, opp in enumerate(top3, 1):
        lines.append(f"### {i}. {opp['name']} (Score: {opp['total']}/20) {opp['verdict']}")
        lines.append(f"- **Problem:** {opp.get('problem', 'N/A')}")

        evidence = opp.get("evidence", [])
        if evidence:
            lines.append(f"- **Evidence:** {'; '.join(evidence[:3])}")
        
        lines.append(f"- **Scores:** D:{opp['demand']} C:{opp['competition']} F:{opp['feasibility']} M:{opp['monetization']}")

        action = opp.get("action", "")
        if action:
            lines.append(f"- **Action:** {action}")
        lines.append("")

    # Full table
    lines.append("## All Findings\n")
    lines.append("| # | Opportunity | D | C | F | M | Total | Verdict |")
    lines.append("|---|------------|---|---|---|---|-------|---------|")
    for i, opp in enumerate(opportunities, 1):
        lines.append(f"| {i} | {opp['name']} | {opp['demand']} | {opp['competition']} | {opp['feasibility']} | {opp['monetization']} | {opp['total']} | {opp['verdict']} |")
    lines.append("")

    # Recommendation
    if top3:
        best = top3[0]
        lines.append("## Recommendation\n")
        lines.append(f"**Build first: {best['name']}** (Score: {best['total']}/20)")
        lines.append(f"\n{best.get('problem', '')}")
        if best.get("action"):
            lines.append(f"\n**Next steps:** {best['action']}")
    
    lines.append(f"\n---\n*Generated by [AI Opportunity Scout](https://clawdhub.com) on {date}*")

    return "\n".join(lines)


def generate_template(niche: str, count: int) -> list:
    """Generate empty opportunity template."""
    return [
        {
            "name": f"Opportunity {i+1}",
            "problem": "Describe the unmet need or pain point",
            "evidence": ["link1", "link2"],
            "demand": 3,
            "competition": 3,
            "feasibility": 3,
            "monetization": 3,
            "action": "What to build and how to monetize"
        }
        for i in range(count)
    ]


def main():
    parser = argparse.ArgumentParser(description="AI Opportunity Scout — Scoring & Report Generator")
    subparsers = parser.add_subparsers(dest="command", help="Command to run")

    # Score command
    score_parser = subparsers.add_parser("score", help="Score opportunities and generate report")
    score_parser.add_argument("--input", "-i", help="JSON file with opportunities (or stdin)")
    score_parser.add_argument("--output", "-o", help="Output markdown file (or stdout)")
    score_parser.add_argument("--niche", "-n", default="General", help="Niche name for report header")

    # Template command
    tmpl_parser = subparsers.add_parser("template", help="Generate empty opportunities template")
    tmpl_parser.add_argument("--niche", "-n", default="General", help="Niche name")
    tmpl_parser.add_argument("--count", "-c", type=int, default=5, help="Number of template entries")
    tmpl_parser.add_argument("--output", "-o", help="Output JSON file (or stdout)")

    args = parser.parse_args()

    if args.command == "score":
        # Read input
        if args.input:
            with open(args.input, "r") as f:
                opportunities = json.load(f)
        else:
            # Read from stdin
            data = sys.stdin.read()
            opportunities = json.loads(data)

        if not isinstance(opportunities, list):
            print("Error: Input must be a JSON array of opportunities.", file=sys.stderr)
            sys.exit(1)

        # Generate report
        report = generate_report(opportunities, args.niche)

        # Output
        if args.output:
            with open(args.output, "w") as f:
                f.write(report)
            print(f"✅ Report saved to {args.output}")
        else:
            print(report)

    elif args.command == "template":
        template = generate_template(args.niche, args.count)
        output = json.dumps(template, indent=2)

        if args.output:
            with open(args.output, "w") as f:
                f.write(output)
            print(f"✅ Template saved to {args.output}")
        else:
            print(output)

    else:
        parser.print_help()


if __name__ == "__main__":
    main()

```

### references/scoring-guide.md

```markdown
# Opportunity Scoring Guide

Score each opportunity 1-5 on four criteria. Total max = 20.

## Demand (How many people want this?)

| Score | Signal | Example |
|-------|--------|---------|
| 5 | 50+ people asking, trending topic | "Everyone needs X but nothing exists" |
| 4 | 20-50 mentions, regular complaints | "Searched everywhere for X, can't find" |
| 3 | 10-20 mentions, occasional requests | "Would be nice to have X" |
| 2 | 3-10 mentions, niche problem | "I personally wish X existed" |
| 1 | 1-2 mentions, hypothetical need | No evidence of real demand |

**Strong signals:** "I wish...", "Does anyone know a tool for...", "I'd pay for...", "Why doesn't X exist?"
**Weak signals:** "It would be cool if...", "Someone should build...", generic complaints

## Competition (How crowded is the space?)

| Score | Signal | Example |
|-------|--------|---------|
| 5 | No existing solutions | Completely new concept |
| 4 | 1-2 solutions, all flawed/abandoned | Old tools, bad UX, missing features |
| 3 | 3-5 competitors, room for differentiation | Market exists but has gaps |
| 2 | 10+ competitors, some strong players | Established market, hard to stand out |
| 1 | Dominated by big players | Google, Microsoft, etc. own this |

**Check:** Search ClawHub, Product Hunt, GitHub, App Store for existing solutions.
**Key insight:** Abandoned/unmaintained competitors = opportunity, not competition.

## Feasibility (How fast can you build an MVP?)

| Score | Signal | Example |
|-------|--------|---------|
| 5 | 1-2 days, existing APIs/libraries | Wrap an API, simple automation |
| 4 | 3-5 days, some custom logic | Integration + light business logic |
| 3 | 1-2 weeks, moderate complexity | Custom backend, multiple integrations |
| 2 | 2-4 weeks, significant dev work | ML model, complex infrastructure |
| 1 | Months+, deep technical challenges | Novel research, regulatory hurdles |

**For AI agent skills specifically:** Most agent skills are Feasibility 4-5 since they're primarily SKILL.md + scripts.

## Monetization (Will people pay?)

| Score | Signal | Example |
|-------|--------|---------|
| 5 | Saves money/time, B2B, clear ROI | "$500/mo tool replaces $5K employee" |
| 4 | Strong value prop, willing to pay $20-100 | Premium productivity, professional tools |
| 3 | Freemium possible, some willingness | Nice-to-have features worth $5-20 |
| 2 | Users expect free, hard to charge | Utility tools, open-source alternatives |
| 1 | No monetization path | Fun projects, internal tools |

**Best monetization signals:**
- People already paying for inferior alternatives
- B2B use case (businesses pay more than consumers)
- Time/money savings are quantifiable
- "I'd pay for this" in actual user comments

## Decision Matrix

| Total | Action | Reasoning |
|-------|--------|-----------|
| 16-20 | 🔥 BUILD NOW | High demand + low competition + feasible + monetizable |
| 12-15 | 👍 Pursue | Good opportunity, validate before heavy investment |
| 8-11 | 🤔 Monitor | Keep watching, might improve or combine with another |
| 4-7 | ❌ Skip | Not worth the effort right now |

```



---

## Skill Companion Files

> Additional files collected from the skill directory layout.

### _meta.json

```json
{
  "owner": "avnikulin35",
  "slug": "opportunity-scout",
  "displayName": "AI Opportunity Scout",
  "latest": {
    "version": "1.0.0",
    "publishedAt": 1772327011654,
    "commit": "https://github.com/openclaw/skills/commit/7e72a0a39bf1f38e95cfa351c30ddc826298e68b"
  },
  "history": []
}

```