progressive-discovery
Progressive disclosure pattern for MCP tools and skills. Teaches agents just-in-time discovery to minimize token usage.
Best use case
progressive-discovery is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Progressive disclosure pattern for MCP tools and skills. Teaches agents just-in-time discovery to minimize token usage.
Teams using progressive-discovery should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/progressive-discovery/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How progressive-discovery Compares
| Feature / Agent | progressive-discovery | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Progressive disclosure pattern for MCP tools and skills. Teaches agents just-in-time discovery to minimize token usage.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
## Skills & Discovery
**Skills** — context-aware prompts for common workflows.
- Browse: `list_skills()` on `gobby-skills`
- Load: `get_skill(name="skillname")` on `gobby-skills`
- Search: `search_skills(query="topic")` on `gobby-skills`
- Hubs: `search_hub(query)` on `gobby-skills`
**MCP Tools** — progressive disclosure (each step gates the next):
1. `list_mcp_servers()` — discover servers (~50 tokens)
2. `list_tools(server_name)` — discover tools (~100 tokens per server)
3. `get_tool_schema(server_name, tool_name)` — get full inputSchema (just-in-time)
4. `call_tool(server_name, tool_name, arguments)` — execute
**Core principle:** NEVER load all schemas upfront — 50+ tool schemas consume 30-40K tokens. Fetch schemas only when you're about to call a tool. This reduces token usage by ~95%.
## Common Mistakes
```python
# WRONG — Loading everything upfront (wastes 30-40K tokens)
for server in servers:
for tool in list_tools(server):
get_tool_schema(server, tool) # Unnecessary!
# WRONG — Guessing parameters without schema
call_tool("gobby-tasks", "create_task", {"name": "Fix bug"}) # Wrong param!
# RIGHT — Just-in-time discovery
get_tool_schema("gobby-tasks", "create_task") # Learn: needs "title" not "name"
call_tool("gobby-tasks", "create_task", {"title": "Fix bug", "session_id": "#123"})
```
## Available Internal Servers
| Server | Purpose |
|--------|---------|
| `gobby-tasks` | Task management |
| `gobby-sessions` | Session handoff |
| `gobby-memory` | Persistent memory |
| `gobby-workflows` | Workflow control |
| `gobby-agents` | Agent spawning |
| `gobby-worktrees` | Git worktrees |
| `gobby-clones` | Repository clones |
| `gobby-merge` | Merge resolution |
| `gobby-hub` | Hub / cross-project |
| `gobby-skills` | Skill management |
| `gobby-metrics` | Usage metrics |
| `gobby-artifacts` | Artifact storage |
| `gobby-pipelines` | Pipeline execution |
Use `list_mcp_servers()` to see all connected servers with live status.Related Skills
product-discovery
Conducts discovery sessions for features/products. Explores concept definition, business model, user journeys, competitive analysis, scoping decisions, and data modeling. Use when you need to explore "what is X", "let's understand", "discovery for", or the /discovery command.
customer-discovery
Find where potential customers discuss problems online and extract their language patterns. Provides starting points for community research, not exhaustive coverage.
code-discovery
Helpers to discover, rank, and invoke repository symbols from natural language with minimal context.
blueprint-discovery
Discovery phase for blueprint workflow - interview triggers, acceptance criteria, and feature classification
ae-sdd-discovery
Discover high-level architectural requirements for change-set specs
api-documentation-discovery
Use when APIs fail repeatedly with version-related errors (method not found, wrong arguments, unknown flag) or when about to use library APIs with uncertain knowledge - guides finding current, accurate documentation instead of guessing from training data
guid-universal-technology-discovery
Discover and identify any technology, framework, or system without prior knowledge. Analyzes files, configurations, dependencies, and usage patterns to understand project technology stack from C source files to Kubernetes manifests.
skills-discovery
Search for and install Agent Skills that give you specialized capabilities. Before starting work, ask might a skill exist that handles this better than my base knowledge? If the task involves specific technologies, frameworks, file formats, or expert domains. Search proactively, even if the user doesn't mention skills. Skills encode best practices, tools, and techniques you wouldn't otherwise have. Also use when users explicitly ask to find, install, or manage skills.
project-context-discovery
Discover project structure, package managers, test frameworks, and automation without hardcoded assumptions
discovery-interview
Deep interview process to transform vague ideas into detailed specs. Works for technical and non-technical users.
De-novo-motif-discovery
This skill identifies novel transcription factor binding motifs in the promoter regions of genes, or directly from genomic regions of interest such as ChIP-seq peaks, ATAC-seq accessible sites, or differentially acessible regions. It employs HOMER (Hypergeometric Optimization of Motif Enrichment) to detect both known and previously uncharacterized sequence motifs enriched within the supplied genomic intervals. Use the skill when you need to uncover sequence motifs enriched or want to know which TFs might regulate the target regions.
architecture-discovery
Guide users through discovering and defining system architecture through structured conversation. Triggers on "I want to build", "design a system", "architect", "planning a new project", "how should I build X".