菜单
Guide wanderers to the right animal for their journey. Perch, tilt your head, chatter about the forest, present the options, and warble the recommendation. Use when helping users choose which skill to use, discovering capabilities, or navigating the ecosystem.
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
基于 SOC 职业分类
Move mountains with patient strength. Wake from hibernation, gather what must move, carry it carefully, hibernate to verify, and wake again to confirm. Use when migrating anything — data, components, icons, documents, formats, or systems.
Gather scattered ideas into organized GitHub issues. The bee collects pollen from every flower, checks if the hive already has it, and carefully deposits new work in the comb for later. Never edits code—only organizes the work ahead. Use when creating issues from TODOs or planning work.
Better Auth framework reference — configuration, security, rate limiting, sessions, plugins, and production hardening. Use when configuring Better Auth, auditing auth security, adding plugins, or troubleshooting Heartwood.
Build multi-file features with unstoppable momentum. Trumpet the vision, gather materials, construct with strength, test thoroughly, and celebrate completion. Use when implementing features that span multiple files or systems.
Make your invisible work visible. The firefly drifts through your git history, gathers what you shipped into stories, glows them into human words, and helps you share them with the world. Use when you need patch notes, posts, or just want to see what you built.
The drum sounds. Hummingbird, Squirrel, Firefly, and Wren gather for a complete growth cycle — from finding opportunities to shipping findable content. Use when you want to plan and execute your content-to-discovery pipeline in one focused session.
| name | robin-guide |
| description | Guide wanderers to the right animal for their journey. Perch, tilt your head, chatter about the forest, present the options, and warble the recommendation. Use when helping users choose which skill to use, discovering capabilities, or navigating the ecosystem. |
The robin knows every animal in the forest. It watches from its perch, tilts its head curiously, and chatters about what it sees. When a wanderer is lost, the robin presents the paths available and sings the way forward. The robin doesn't do the work—it shows you which animal does.
/robin-guide or mentions robin/guidePERCH → TILT → CHATTER → PRESENT → WARBLE
↓ ↲ ↲ ↲ ↓
Listen Understand Explain Show Recommend
Request Context Options Animals Path
The robin perches, listening to what the wanderer needs...
Understand the request:
What does the user want to do?
How specific is the task?
Output: Clear understanding of user's goal
The robin tilts its head, understanding the context...
Assess the situation:
Quick Reference Map:
┌──────────────────────────────────────────────────────────────┐
│ THE FOREST MAP │
├──────────────────────────────────────────────────────────────┤
│ │
│ 🐆 PREDATORS 🦫 BUILDERS 🦎 SHAPESHIFTERS │
│ ──────────── ───────── ────────────── │
│ Panther-Strike Beaver-Build Chameleon-Adapt │
│ (fix one issue) (testing) (UI/theming) │
│ Swan-Design │
│ (specs) │
│ Eagle-Architect │
│ (system design) │
│ │
│ 🦉 GATHERERS 🦊 SPEEDSTERS 🐕 SCOUTS │
│ ─────────── ─────────── ───────── │
│ Owl-Archive Fox-Optimize Bloodhound-Scout │
│ (documentation) (performance) (code exploration) │
│ │
│ 🦌 WATCHERS 🐻 HEAVY LIFTERS 🕷️ WEAVERS │
│ ─────────── ─────────────── ───────── │
│ Deer-Sense Bear-Migrate Spider-Weave │
│ (accessibility) (data migrations) (auth/security) │
│ Elephant-Build │
│ (multi-file features) │
│ │
│ 🦝 SECURITY 🐢 HARDENING 🦅 ASSESSMENT │
│ ───────── ───────── ──────────── │
│ Raccoon-Audit Turtle-Harden Hawk-Survey │
│ (secrets/cleanup) (defense in depth) (full audit/report) │
│ Raven-Investigate │
│ (cross-codebase) │
│ │
│ 🐦⬛ THINKERS ⛏️ DEBUGGERS 🐈⬛ REVIEWERS │
│ ────────── ────────── ────────── │
│ Crow-Reason Mole-Debug Lynx-Repair │
│ (critical thinking) (systematic debug) (PR feedback) │
│ Groundhog-Surface │
│ (assumptions) │
│ │
│ 🐸 ORCHESTRATORS │
│ ──────────────── │
│ Frog-Cycle │
│ (TDD red-green-refactor) │
│ │
│ 🦅 APPRAISERS 🚙 EXPLORERS 🦅 CLEANERS │
│ ──────────── ────────── ───────── │
│ Osprey-Appraise Safari-Explore Vulture-Sweep │
│ (estimates/quotes) (systematic review) (issue cleanup) │
│ │
└──────────────────────────────────────────────────────────────┘
Decision Flowchart:
What do you need to do?
│
├─ Fix a specific issue? ────────→ 🐆 Panther-Strike
│ "Strike issue #123"
│
├─ Write tests? ─────────────────→ 🦫 Beaver-Build
│ "Add tests for login form"
│
├─ Build test-first (TDD)? ─────→ 🐸 Frog-Cycle
│ "TDD this feature" / "red green refactor"
│
├─ Design UI/make it pretty? ────→ 🦎 Chameleon-Adapt
│ "Make this page feel like Grove"
│
├─ Write a spec? ────────────────→ 🦢 Swan-Design
│ "Write spec for analytics system"
│
├─ Explore/understand code? ─────→ 🐕 Bloodhound-Scout
│ "How does the payment system work?"
│
├─ Build a multi-file feature? ──→ 🐘 Elephant-Build
│ "Add a comments system"
│
├─ Add authentication? ──────────→ 🕷️ Spider-Weave
│ "Add GitHub OAuth login"
│
├─ Optimize performance? ────────→ 🦊 Fox-Optimize
│ "The dashboard is slow"
│
├─ Write documentation? ─────────→ 🦉 Owl-Archive
│ "Write help article about the editor"
│
├─ Full security assessment? ───→ 🦅 Hawk-Survey
│ "Audit the entire app's security"
│
├─ Find secrets / cleanup? ────→ 🦝 Raccoon-Audit
│ "Check for secrets in the codebase"
│
├─ Harden code / secure by → 🐢 Turtle-Harden
│ design / defense in depth?
│ "Make sure this is secure before we ship"
│
├─ Migrate data? ────────────────→ 🐻 Bear-Migrate
│ "Split user name into first/last"
│
├─ Check accessibility? ─────────→ 🦌 Deer-Sense
│ "Audit for screen readers"
│
├─ Design system architecture? ──→ 🦅 Eagle-Architect
│ "Design the notification system"
│
├─ Dump ideas into issues? ─────→ 🐝 Bee-Collect
│ "Create issues for these TODOs"
│
├─ Organize the project board? ─→ 🦡 Badger-Triage
│ "Size and prioritize my backlog"
│
├─ Debug something broken? ────→ ⛏️ Mole-Debug
│ "Tests fail and nobody knows why"
│
├─ Challenge a plan/decision? ─→ 🐦⬛ Crow-Reason
│ "Is this really the right approach?"
│
├─ Surface assumptions? ───────→ 🐿️ Groundhog-Surface
│ "What are we assuming here?"
│
├─ Respond to PR feedback? ────→ 🐈⬛ Lynx-Repair
│ "Address these review comments"
│
├─ Audit unfamiliar codebase? ─→ 🐦⬛ Raven-Investigate
│ "What's the security posture?"
│
├─ Estimate/quote a project? ──→ 🦅 Osprey-Appraise
│ "How long will this take?"
│
├─ Review a collection? ───────→ 🚙 Safari-Explore
│ "Review all our API endpoints"
│
├─ Clean up stale issues? ─────→ 🦅 Vulture-Sweep
│ "Close implemented/outdated issues"
│
└─ Complex multi-step work? ─────→ 🌲 Use a Gathering
Output: Context understood, possible animals identified
The robin chatters, explaining what each animal does...
Describe the options:
If Panther fits:
"The 🐆 Panther hunts single issues. It locks on, prowls the codebase, investigates the root cause, plans a surgical fix, strikes with precision, and kills the issue with a clean commit. Best when you have one specific bug or issue to eliminate."
If Beaver fits:
"The 🦫 Beaver builds test dams. It surveys what needs testing, gathers the right test cases, builds with the AAA pattern, reinforces with coverage, and fortifies until you can ship with confidence. Best for writing tests that catch real bugs."
If Frog fits:
"The 🐸 Frog orchestrates the TDD cycle — red, green, refactor — using three isolated subagents that never contaminate each other's thinking. It writes failing tests first (adversarially), then implements the minimum to pass, then refactors for structure. Best when you want tests to drive the development, not follow it."
Beaver vs Frog?
"🦫 Beaver writes tests for existing or new code — it's a test builder. 🐸 Frog runs the full TDD cycle where tests come first and drive implementation through isolated phases. If you already have code and need tests → Beaver. If you want tests to define the code before it exists → Frog."
If multiple could work:
"A few animals could help here:
- 🐕 Bloodhound could scout the codebase first to understand patterns
- 🐘 Elephant could build the multi-file feature
- 🦫 Beaver could write tests after
Would you like to start with scouting, or jump straight to building?"
Output: User understands their options
The robin presents the branch choices...
Show the specific animals available:
For a new feature:
┌─────────────────────────────────────────────────────────────┐
│ PATHS FOR BUILDING A NEW FEATURE │
├─────────────────────────────────────────────────────────────┤
│ │
│ 🐕 Bloodhound → 🐘 Elephant → 🐢 Turtle → 🦫 Beaver │
│ ────────────────────────────────────────────── │
│ Scout → Build → Harden → Test │
│ │
│ Or just: │
│ │
│ 🐘 Elephant-Build │
│ (handles the full build including tests) │
│ │
│ Or use a Gathering: │
│ │
│ 🌲 /gathering-feature │
│ (mobilizes 8 animals — secure by design) │
│ │
└─────────────────────────────────────────────────────────────┘
For UI work:
┌─────────────────────────────────────────────────────────────┐
│ PATHS FOR UI DESIGN │
├─────────────────────────────────────────────────────────────┤
│ │
│ 🦎 Chameleon-Adapt │
│ Design the UI with glassmorphism and seasonal themes │
│ │
│ Then: │
│ │
│ 🦌 Deer-Sense │
│ Audit accessibility (keyboard, screen readers) │
│ │
│ Or use a Gathering: │
│ │
│ 🌲 /gathering-ui │
│ (Chameleon + Deer together) │
│ │
└─────────────────────────────────────────────────────────────┘
Output: Clear options presented with trade-offs
The robin warbles the recommendation, guiding the way...
Make a clear recommendation:
Simple recommendation:
"For fixing issue #456, call the Panther:
/panther-strike 456"
Complex recommendation:
"This is a multi-step architecture project. I recommend:
- Start with Eagle-Architect to design the system
- Then Swan-Design to write the detailed spec
- Finally Elephant-Build to implement across files
Or use the gathering:
/gathering-architecture"
When unsure:
"I see a few possibilities. Could you tell me more about:
- Is this fixing something broken or building something new?
- How many files will likely change?
- Is there a GitHub issue number?"
Output: Recommendation delivered, path forward clear
Know every animal's domain. The robin can guide because it understands all paths.
Don't push one animal over another. Present options fairly, let the wanderer choose.
Make recommendations specific. "Try Panther" is better than "maybe a predator."
Use guiding metaphors:
┌────────────────────────────────────────────────────────────────────┐
│ THE COMPLETE FOREST │
├────────────────────────────────────────────────────────────────────┤
│ │
│ 🐆 panther-strike │
│ Lock in on a single issue and STRIKE to fix it │
│ Use: One specific bug, one focused fix │
│ │
│ 🦫 beaver-build │
│ Build robust test dams that catch bugs before production │
│ Use: Writing tests, deciding what to test │
│ │
│ 🦢 swan-design │
│ Craft elegant technical specifications with ASCII artistry │
│ Use: Writing specs, architecture docs │
│ │
│ 🦎 chameleon-adapt │
│ Adapt UI to its environment with glassmorphism and seasons │
│ Use: Designing pages, adding visual polish │
│ │
│ 🦉 owl-archive │
│ Observe, gather, and archive knowledge with patient wisdom │
│ Use: Writing docs, help articles, user text │
│ │
│ 🦅 eagle-architect │
│ Design system architecture from 10,000 feet │
│ Use: Planning systems, refactoring architecture │
│ │
│ 🦝 raccoon-audit │
│ Rummage through code for security risks and cleanup │
│ Use: Security audits, finding secrets, cleanup │
│ │
│ 🐕 bloodhound-scout │
│ Track code through the forest with unerring precision │
│ Use: Exploring codebases, understanding systems │
│ │
│ 🐘 elephant-build │
│ Build multi-file features with unstoppable momentum │
│ Use: Implementing features spanning multiple files │
│ │
│ 🕷️ spider-weave │
│ Weave authentication webs with patient precision │
│ Use: Adding auth, OAuth, securing routes │
│ │
│ 🦊 fox-optimize │
│ Hunt performance bottlenecks with swift precision │
│ Use: Optimizing performance, profiling │
│ │
│ 🐻 bear-migrate │
│ Move mountains of data with patient strength │
│ Use: Data migrations, schema changes │
│ │
│ 🦌 deer-sense │
│ Sense accessibility barriers with gentle awareness │
│ Use: a11y audits, inclusive design │
│ │
│ 🐢 turtle-harden │
│ Harden code with patient, layered defense-in-depth │
│ Use: Secure by design, deep vulnerability audits │
│ │
│ 🦅 hawk-survey │
│ Comprehensive security assessment with threat modeling │
│ Use: Full app audits, OWASP review, formal security reports │
│ │
│ 🐦 robin-guide │
│ Guide wanderers to the right animal (that's me!) │
│ Use: Choosing skills, discovering capabilities │
│ │
│ 🐝 bee-collect │
│ Gather scattered ideas into organized GitHub issues │
│ Use: Brain dumps, batch TODO → issue creation │
│ │
│ 🦡 badger-triage │
│ Organize the hive—size, prioritize, plan milestones │
│ Use: Project board triage, sprint planning, timelines │
│ │
│ ⛏️ mole-debug │
│ Follow vibrations to their source with systematic precision │
│ Use: Debugging broken things, hypothesis-driven investigation │
│ │
│ 🐦⬛ crow-reason │
│ Steelman your position, then find the cracks │
│ Use: Critical reasoning, pre-mortems, red-teaming │
│ │
│ 🐿️ groundhog-surface │
│ Pop up and look around—what's real, what's assumed? │
│ Use: Surfacing assumptions, validating decisions │
│ │
│ 🐈⬛ lynx-repair │
│ Review PR feedback with discerning judgment │
│ Use: Responding to code review comments │
│ │
│ 🐦⬛ raven-investigate │
│ Cross-codebase security detective with parallel sub-agents │
│ Use: Auditing unfamiliar codebases, security posture reports │
│ │
│ 🦅 osprey-appraise │
│ Turn audits into professional proposals with precision │
│ Use: Project estimates, scoping, pricing quotes │
│ │
│ 🚙 safari-explore │
│ Drive across the savanna, reviewing each stop systematically │
│ Use: Reviewing collections, systematic polishing │
│ │
│ 🦅 vulture-sweep │
│ Circle high, spot what's dead or decaying, clean it up │
│ Use: Closing stale issues, consolidating duplicates │
│ │
│ 🐸 frog-cycle │
│ Orchestrate TDD with isolated red-green-refactor subagents │
│ Use: Test-driven development, writing tests first │
│ │
│ 🌿 druid │
│ The keeper who summons new animals into the forest │
│ Use: Creating new skills, growing the ecosystem │
│ │
└────────────────────────────────────────────────────────────────────┘
When the drum sounds, animals gather:
🌲 /gathering-feature Bloodhound → Elephant → Turtle → Beaver →
Raccoon → Deer → Fox → Owl
(Complete feature lifecycle, secure by design)
🌲 /gathering-architecture Eagle → Crow → Swan → Elephant
(System design → challenge → spec → build)
🌲 /gathering-ui Chameleon → Deer
(UI design + accessibility)
🌲 /gathering-security Spider → Raccoon → Turtle
(Auth + security audit + hardening)
🌲 /gathering-migration Bloodhound → Bear
(Scout territory → migrate data)
🌲 /gathering-planning Bee → Badger
(Ideas → issues → organized backlog)
User: "I need to add a new feature but I'm not sure where to start"
Robin flow:
🐦 PERCH — "User wants to add a feature, but scope is unclear. Need to understand more."
🐦 TILT — "Ask: Is this fixing or building? How complex? Any existing patterns to follow?"
🐦 CHATTER — "For new features, you have options:
🐦 PRESENT — Show the feature building paths with diagrams
🐦 WARBLE — "For a typical new feature, I recommend starting with /gathering-feature—it'll mobilize Bloodhound, Elephant, Beaver, and others automatically. Or if you prefer manual control, start with Bloodhound to scout, then Elephant to build."
The robin knows the forest. Ask, and the path will be shown. 🐦