Turns any AI project into a
domain expert on demand
A folder of small, focused skills — each owning one job with a clear contract, no overlap, no mega-prompts. Drop it into any project and the agent invokes the right specialist on demand. This is how serious teams scale past 10 skill files without prompt chaos.
Recommended Models
The Specialist Stack architecture works best with models that reliably follow structured contracts without drifting between specialist roles.
| Model | Best For | Cost | Quality | |
|---|---|---|---|---|
| Claude Sonnet 4.6 | Best at following specialist contracts without drift | Moderate | ★★★★★ | Recommended |
| GPT-5.4 | Strong function-calling makes specialist handoffs clean | Moderate | ★★★★★ | Recommended |
Temperature tip: Set to 0.3. Specialists need to stay within their defined contract. Higher temperatures cause drift — the PRD writer starts generating tickets, the test author starts reviewing architecture. Keep it deterministic.
Cost Estimate
⚡ Variable Tier
$0 architecture
cost is sum of specialists invoked per task
500–2,000
tokens per specialist
Multiplies
by active specialists
~60%
cheaper than mega-prompts
The architecture itself costs nothing. Each specialist invocation runs 500–2,000 tokens — far cheaper than sending a 5,000-token mega-prompt to the same model for every request. Focused specialists also waste fewer tokens retrying failed outputs.
Before & After Examples
The difference between a mega-prompt and a properly designed specialist stack.
Mega-prompt approach Before — monolith
One 4,000-token system prompt: "You write PRDs, create tickets, write tests, do code review, and document APIs." The agent does all of these — mediocrely. Adding a new use case means editing a prompt nobody wants to touch.
After — specialist stack
skills/
├── prd-writer.md
├── ticket-decomposer.md
├── test-author.md
├── code-reviewer.md
└── api-documenter.mdEach specialist does one job. Adding a new use case is a new file.
Vague specialist
"You are a product manager. Help with product requirements." Scope is undefined. The specialist creates tickets, writes tests, and starts doing code review when asked about features.
Tight specialist contract
Trigger: When a new feature needs a PRD
Contract: Produces exactly one PRD.md per request
Does NOT: Create tickets (→ ticket-decomposer)
Output: PRD.md with background, goals, non-goals, user stories, acceptance criteria
Contract: Produces exactly one PRD.md per request
Does NOT: Create tickets (→ ticket-decomposer)
Output: PRD.md with background, goals, non-goals, user stories, acceptance criteria
Model Compatibility
✓ Works Best With
- Claude Sonnet 4.6 — best at staying within specialist scope without drift
- GPT-5.4 — clean function-calling makes handoffs between specialists reliable
- Models with strong instruction-following and system prompt fidelity
✗ Not Recommended
- Monolithic mega-prompts — impossible to maintain beyond 3 use cases
- Models without tool-use support — can't invoke specialists programmatically
- Models that ignore scope boundaries — specialists bleed into each other's domains
Anatomy of a Production Stack
Real example: a 5-specialist software development stack. Each specialist has a single trigger, one job, and explicit handoff points.
01
prd-writer
Writes product requirements documents from feature requests
→ tickets
02
ticket-decomposer
Breaks PRDs into small, actionable engineering tickets
→ test-author
03
test-author
Writes unit and integration tests from ticket acceptance criteria
→ code-reviewer
04
code-reviewer
Reviews PRs against ticket acceptance criteria and test coverage
→ api-docs
05
api-documenter
Generates OpenAPI spec from merged code changes
→ caller
Real-world scale: Teams running this pattern in production ship 50K+ lines of skills across 50+ repos. The key insight: skills are code. Version them in git, review them in PRs, test them like functions.
Chainable Skills
The Specialist Stack is the body of a multi-agent system. The Orchestrator is the brain that decides which specialist to invoke.
Orchestrator
Routes to the right specialist
→
Specialist Stack
Focused experts · This skill
→
Output
Specialist deliverable
→
Next Specialist
Handoff if sequential
Build order matters: Write the specialists first — define their contracts, triggers, inputs, and outputs clearly. Then write the Orchestrator. An orchestrator written before the specialists exists is just a routing guess.
The Specialist Template
Every specialist in your stack follows this structure. Fill in the bracketed fields. The contract section is the most important — it defines the scope boundary that keeps specialists from bleeding into each other.
The "Does NOT" list is not optional. Without explicit scope exclusions, specialists will gradually expand their remit. "This specialist does NOT create tickets" prevents the PRD writer from doing ticket-decomposer's job and producing mediocre tickets that nobody asked for.
Specialist Template
# Specialist Skill: [SPECIALIST NAME] ## Trigger [Exact condition under which this specialist should be invoked] ## Contract This specialist does exactly ONE thing: [one-sentence job description] It does NOT: - [List what this specialist explicitly hands off to others] - [Scope boundary 2] - [Scope boundary 3] ## Input Expected [What format/data this specialist needs to start work] ## Output Produced [Exact format/structure of what this specialist returns] ## Methodology [Step-by-step process this specialist follows] ## Quality Check Before completing, verify: - [ ] Output matches the expected format exactly - [ ] No scope creep into adjacent specialist territory - [ ] Every input requirement was satisfied ## Handoff When complete, pass output to: [downstream specialist or 'caller']
Community Signals
724Total installs
4.8★Community rating
7.1Avg specialists per stack
Most commonly paired with: Orchestrator (89%), Memory Hack (71%), Skills Creator (62%). The most common starter stacks are software development (PRD → tickets → tests → review) and content production (research → outline → draft → humanize).
Ready to replace your mega-prompt with a real stack?
Copy the specialist template, define your first three specialists, build from there.
✓ Template copied to clipboard