New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Opportunity Solution Tree

by avelikiy in avelikiy/great_cto

Builds an Opportunity Solution Tree that links one measurable outcome to customer opportunities, candidate solutions and experiments.

MITAuto-check passedProduct & Project Management

Install Opportunity Solution Tree

skills CLI
$ npx skills add avelikiy/great_cto --skill opportunity-solution-tree -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install avelikiy/great_cto opportunity-solution-tree --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/avelikiy/great_cto.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/opportunity-solution-tree .claude/skills/opportunity-solution-tree && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
opportunity-solution-tree
GitHub stars
102
Token cost
~1.8k tokens
SKILL.md length
595 words
Files
1
Skills in repo
27
Repo updated
First seen
Licence
MIT

At a glance

Builds an Opportunity Solution Tree that links one measurable outcome to customer opportunities, candidate solutions and experiments.

  • Works in 5 steps: Define the desired outcome → Map opportunities from research → Generate solutions (diverge before… → …
  • The team is unsure what to build next
  • SKILL.md covers The 4-level structure, How to build an OST, Integration with /spec prd and Anti-patterns
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Based on Teresa Torres' Continuous Discovery Habits, this skill connects a desired outcome to customer opportunities, solutions and experiments so a team does not jump to solutions before the problem space is validated. It suits moments when nobody is sure what to build next, when several opportunities compete, or before a PRD for a complex feature area.

The agent first gets one measurable outcome, rejecting vague ones such as building a better onboarding or improving the product, and asks what would make the effort a success when no metric is given. It then maps roughly 3 to 7 customer opportunities from interviews, analytics, support tickets or NPS feedback, framed from the customer's point of view, and ranks them with the Opportunity Score, importance times one minus satisfaction. Each top opportunity gets at least 3 candidate solutions before one is chosen, and experiments serve as the cheapest way to test assumptions.

When your agent uses it

  • The team is unsure what to build next
  • Several customer opportunities are competing for attention
  • Preparing discovery work before writing a PRD for a complex feature area
  • Turning interview and support-ticket findings into a prioritized opportunity map

Example prompts

  • “Build an opportunity solution tree for lifting free-to-paid conversion from 2% to 5%.”
  • “Here are our interview notes and support tickets. Map the customer opportunities and score them.”
  • “We have three competing ideas for onboarding. Structure them as an opportunity solution tree before we write the PRD.”

Requirements

  • Pre-approved tools (allowed-tools): Read, Write, WebFetch, WebSearch

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Define the desired outcome
  2. Map opportunities from research
  3. Generate solutions (diverge before converging)
  4. Design experiments
  5. Visualise and document

What it can do on your machine

Read from SKILL.md and the folder at commit 97dd037. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Write
    • WebFetch
    • WebSearch

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are markdown).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Opportunity Solution Tree loads about 1.8k tokens when it runs. Until then it costs about 94 tokens; SKILL.md has 595 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~94
When it runs · the whole SKILL.md, loaded when a task matches
~1.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from avelikiy/great_cto at commit 97dd037, republished under its MIT licence (© avelikiy). 595 words, ~1,811 tokens.

Download SKILL.mdSave it as .claude/skills/opportunity-solution-tree/SKILL.md (or your agent's skills folder).
name
opportunity-solution-tree
description
Build an Opportunity Solution Tree (OST) to structure product discovery — map a desired outcome to customer opportunities, possible solutions, and experiments. Based on Teresa Torres' Continuous Discovery Habits. Use when the team is unclear what to build next, when multiple opportunities compete, or before writing a PRD for a complex feature space.
allowed-tools
Read, Write, WebFetch, WebSearch
when_to_use
Apply when: - The team knows the outcome to improve but not which opportunity to chase - Multiple feature ideas exist and the team isn't sure which solves the…
effort
medium
paths
docs/discovery/**

Opportunity Solution Tree (OST)

Structures product discovery by connecting a desired outcome → customer opportunities → solutions → experiments. Prevents jumping to solutions before validating the problem space.

Based on Teresa Torres, Continuous Discovery Habits (2021).

The 4-level structure

                    ┌─────────────────────┐
                    │   DESIRED OUTCOME   │  ← single measurable metric
                    └──────────┬──────────┘
               ┌───────────────┼────────────────┐
        ┌──────┴─────┐  ┌──────┴─────┐  ┌──────┴─────┐
        │Opportunity │  │Opportunity │  │Opportunity │  ← customer pain/need
        │     A      │  │     B      │  │     C      │
        └──────┬─────┘  └──────┬─────┘  └────────────┘
        ┌──────┴───┐    ┌──────┴───┐
    ┌───┴──┐ ┌───┴──┐ ┌───┴──┐ ┌───┴──┐
    │Sol 1 │ │Sol 2 │ │Sol 3 │ │Sol 4 │  ← possible solutions
    └───┬──┘ └──────┘ └───┬──┘ └──────┘
  ┌────┴────┐         ┌───┴────┐
  │ Exp 1   │         │ Exp 2  │          ← fast experiments
  └─────────┘         └────────┘

Key principles:

  • One desired outcome at a time — don't try to solve everything
  • Opportunities are customer problems/needs, never solutions
  • Generate ≥3 solutions per opportunity before choosing one
  • Experiments are the cheapest way to validate an assumption
  • The tree is a living document — update weekly as you learn

How to build an OST

Step 1 — Define the desired outcome

Confirm or help the user articulate one measurable outcome at the top of the tree.

Good outcomes:

  • "Increase 7-day retention from 20% to 35%"
  • "Reduce time-to-first-value from 3 days to 1 day"
  • "Increase conversion from free to paid from 2% to 5%"

Bad outcomes (reject these):

  • "Build a better onboarding" — that's a solution
  • "Improve the product" — unmeasurable
  • "Launch feature X" — that's an output

If the user can't state a metric: ask "What would need to be true for you to consider this effort a success?"

Step 2 — Map opportunities from research

From customer interviews, analytics, support tickets, or NPS feedback, identify 3–7 customer opportunities (pain points, unmet needs, desires).

Frame each from the customer's perspective:

  • ✅ "I struggle to understand which plan is right for me"
  • ✅ "I can't find past purchases quickly"
  • ✅ "I feel anxious about whether my data is safe"
  • ❌ "Users need a better search" — that's a solution

Prioritise using Opportunity Score (Dan Olsen, The Lean Product Playbook):

Opportunity Score = Importance × (1 − Satisfaction)

Survey customers: rate each need on Importance (0–1) and current Satisfaction (0–1).

  • High Importance + Low Satisfaction = highest score = best opportunity
  • Plot on Importance vs Satisfaction chart — upper-left quadrant is the sweet spot
Step 3 — Generate solutions (diverge before converging)

For each top-priority opportunity, brainstorm ≥3 solutions from three angles:

  • PM perspective: What UX/product change addresses this?
  • Designer perspective: What interaction or visual change?
  • Engineer perspective: What technical approach? (often the most creative)

Rules:

  • Don't commit to the first idea — compare and contrast
  • "Best ideas often come from engineers" — include technical solutions
  • Solutions should be independent (different solutions for the same opportunity)
Show full SKILL.md (242 more words)Show less
Step 4 — Design experiments

For the most promising solutions, design 1–2 fast experiments:

ExperimentAssumption testedMethodSuccess metricEffort
<experiment name><what belief this validates><A/B test / fake door / prototype / interview><metric + threshold><1d / 3d / 1w>

Assumption categories (prioritise in this order):

  1. Value: Will users want this? (most important to test first)
  2. Usability: Can users figure it out?
  3. Feasibility: Can we build it?
  4. Viability: Does the business case work?

Cheap experiment types:

  • Existing product: A/B test, fake door, prototype, user interview, data analysis
  • New product: XYZ hypothesis ("At least X% of Y will do Z"), landing page, concierge MVP
Step 5 — Visualise and document

Write docs/discovery/OST-<outcome-slug>.md:

markdown
# Opportunity Solution Tree: <Outcome>

**Desired outcome**: <metric> from <current> to <target> by <date>
**Last updated**: <date>

## Opportunity map

| # | Opportunity | Importance | Satisfaction | Opportunity Score | Priority |
|---|------------|-----------|-------------|-------------------|---------|
| A | <customer need> | 0.8 | 0.3 | 0.56 | 1st |
| B | <customer need> | 0.7 | 0.6 | 0.28 | 3rd |
| C | <customer need> | 0.6 | 0.2 | 0.48 | 2nd |

## Solutions for top opportunities

### Opportunity A: <name>
| Solution | Description | Experiment |
|---------|-------------|-----------|
| Sol A1 | <description> | <experiment> |
| Sol A2 | <description> | <experiment> |
| Sol A3 | <description> | <experiment> |

## Active experiments

| Experiment | Assumption | Status | Result |
|-----------|-----------|--------|--------|
| <name> | <assumption> | Running / Done | <result or pending> |

## Learning log

- <date>: Discovered <insight> from <source>. Killed <solution> / promoted <opportunity>.

Integration with /spec prd

Once an opportunity is validated and a solution is chosen: → Run /spec prd with the validated opportunity as the problem statement → The OST's Opportunity Score data feeds directly into PRD §3 (Success Metrics) and §4 (Target Users)

Anti-patterns

❌ Opportunity = solution in disguise: "Users need a search bar" is a solution. "Users can't find past purchases" is an opportunity.

❌ Skipping divergence: Picking the first solution for each opportunity. Always generate ≥3 before choosing.

❌ Experiments that take >1 week: If it takes longer than a week to learn, it's not an experiment — it's a feature.

❌ Updating the tree once: OST is a continuous practice. Update weekly as you learn.

❌ Too many outcomes: One outcome per tree. If you have multiple outcomes, run multiple trees or pick the highest priority.

© avelikiy, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/opportunity-solution-tree of avelikiy/great_cto.

Open the folder on GitHubat commit 97dd037

Compare with similar skills

Opportunity Solution Tree next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Opportunity Solution Tree compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Opportunity Solution Tree this skillavelikiy/great_cto102—~1.8kAutomated safety check: PassMIT
Product Discoverymajiayu000/spellbook287—~3.3kAutomated safety check: PassMIT
Product Manager Toolkitborghei/Claude-Skills891—~5.8kAutomated safety check: PassMIT
Competitor Gapsacogood/diffmode_free163—~2.9kAutomated safety check: PassApache-2.0
Product Manager Toolkitdavila7/claude-code-templates33k7 repos~2.2kAutomated safety check: PassMIT
Product Discovery Processdeanpeters/Product-Manager-Skills7.2k1 repos~4.9kAutomated safety check: PassCustom licence

Similar skills

  • Product Discovery

    majiayu000/spellbook

    Product discovery and market research expert. An agent skill from majiayu000/spellbook.

    287 GitHub stars~3.3k tokensUpdated 2 days ago
    Product & Project ManagementAuto-check passed

  • Product Manager Toolkit

    borghei/Claude-Skills

    Product manager toolkit covering RICE prioritization, customer interview analysis, PRDs, and discovery frameworks.

    891 GitHub stars~5.8k tokensUpdated 3 days ago
    Product & Project ManagementAuto-check passed

  • Competitor Gaps

    acogood/diffmode_free

    Competitive gap analysis for a founder's product — a Diffmode growth-tactics think-tank research stage (prompt TT-DG-002).

    163 GitHub stars~2.9k tokensUpdated 2 mo ago
    Product & Project ManagementAuto-check passed

  • Product Manager Toolkit

    davila7/claude-code-templates

    Scores feature requests with RICE, mines customer interview transcripts for pain points, and offers PRD templates, with two Python scripts behind it.

    33k GitHub starsUsed in 7 repos~2.2k tokens
    Product & Project ManagementAuto-check passed

  • Product Discovery Process

    deanpeters/Product-Manager-Skills

    Guides a product manager through a full discovery cycle from problem hypothesis to validated solution: framing, interviews, synthesis, solution options and experiments.

    7.2k GitHub starsUsed in 1 repo~4.9k tokens
    Product & Project ManagementAuto-check passed

  • Gingiris User Interview

    Gingiris-1031/Competitor-analysis-tool

    🇺🇸 User Interview & Cold-Start Operations Playbook — Battle-tested framework from HeyGen's 937 interviews to PMF.

    110 GitHub stars~1.2k tokensUpdated 2 days ago
    Product & Project ManagementAuto-check passed

More from avelikiy/great_cto

All 27 skills in this repo

  • AnyDesign Design Analyzer

    avelikiy/great_cto

    Analyzes a screenshot, website or Figma file and writes a `design.md` with its token system, component inventory and reconstruction notes, or an `element.md` for one element.

    102 GitHub starsUsed in 1 repo~3.2k tokens
    Auto-check passed

  • Outcome-Focused Roadmap Rewriter

    avelikiy/great_cto

    Rewrites a feature-list roadmap into outcome statements that name the customer segment, the result they get and the business impact, grouped into themes.

    102 GitHub stars~1.3k tokensUpdated yesterday
    Auto-check passed

  • Exposed Secret Rotation

    avelikiy/great_cto

    Turns a leaked key, token or password into one tracked rotation task the moment it's spotted, instead of a reminder repeated every session.

    102 GitHub stars~884 tokensUpdated yesterday
    Auto-check: notes

  • Skeptical Triage

    avelikiy/great_cto

    Runs a three-round self-challenge plus an arbiter over high-stakes findings, so false positives from reviews, audits and flaky-test verdicts do not become blockers.

    102 GitHub stars~2.1k tokensUpdated yesterday
    Auto-check: notes

  • Aesthetic Instrument

    avelikiy/great_cto

    greatcto's own committed aesthetic — the instrument panel. An agent skill from avelikiy/great_cto.

    102 GitHub stars~1.9k tokensUpdated yesterday
    Auto-check passed

  • Anti Patterns

    avelikiy/great_cto

    Catalogue of known SDLC anti-patterns that greatcto agents must actively reject when reviewing architecture, plans, code, or post-mortems.

    102 GitHub stars~1.7k tokensUpdated yesterday
    Auto-check passed

Categories

Questions about Opportunity Solution Tree

What does Opportunity Solution Tree do?

Builds an Opportunity Solution Tree that links one measurable outcome to customer opportunities, candidate solutions and experiments. Based on Teresa Torres' Continuous Discovery Habits, this skill connects a desired outcome to customer opportunities, solutions and experiments so a team does not jump to solutions before the problem space is validated. It suits moments when nobody is sure what to build next, when several opportunities compete, or before a PRD for a complex feature area.

When should I use Opportunity Solution Tree?

Opportunity Solution Tree fits situations like: the team is unsure what to build next; several customer opportunities are competing for attention; preparing discovery work before writing a PRD for a complex feature area; turning interview and support-ticket findings into a prioritized opportunity map.

How do I install Opportunity Solution Tree in Claude Code?

Run `npx skills add avelikiy/great_cto --skill opportunity-solution-tree -a claude-code`. Or copy the skill folder (skills/opportunity-solution-tree in avelikiy/great_cto) into .claude/skills/opportunity-solution-tree in your project. Claude Code loads it when a task matches its description.

How do I install Opportunity Solution Tree in Codex?

Run `npx skills add avelikiy/great_cto --skill opportunity-solution-tree -a codex`. Or copy the skill folder (skills/opportunity-solution-tree in avelikiy/great_cto) into .agents/skills/opportunity-solution-tree in your project. Codex loads it when a task matches its description.

Can I use Opportunity Solution Tree in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add avelikiy/great_cto --skill opportunity-solution-tree -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/opportunity-solution-tree, .gemini/skills/opportunity-solution-tree, .github/skills/opportunity-solution-tree and .opencode/skills/opportunity-solution-tree in your project.

What does Opportunity Solution Tree need to run?

SKILL.md names no scripts, command-line tools or credentials: Opportunity Solution Tree is instructions for the agent only. Its frontmatter pre-approves these tools: Read, Write, WebFetch, WebSearch.

Does Opportunity Solution Tree access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Opportunity Solution Tree safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Opportunity Solution Tree use?

Opportunity Solution Tree is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Opportunity Solution Tree use?

About 1.8k tokens (SKILL.md is roughly 7.2k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Opportunity Solution Tree?

Skills that share tags, products or a category with Opportunity Solution Tree: Product Discovery (majiayu000/spellbook, 287 stars), Product Manager Toolkit (borghei/Claude-Skills, 891 stars), Competitor Gaps (acogood/diffmode_free, 163 stars) and Product Manager Toolkit (davila7/claude-code-templates, 33k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Opportunity Solution Tree?

avelikiy (a GitHub user) maintains it in avelikiy/great_cto, which has 102 GitHub stars. The repository holds 27 skills in this directory. The repository was last updated on October 9, 2026.

Source: avelikiy/great_cto on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.