Robin Guide 🐦

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.

When to Activate

User asks "which skill should I use?" or "what animal does X?"
User says "help me choose" or "what are my options?"
User calls /robin-guide or mentions robin/guide
Unclear which animal to call for a task
Exploring what the ecosystem can do
New to the animal skill system
Want to understand available capabilities

The Guide

PERCH → TILT → CHATTER → PRESENT → WARBLE
   ↓       ↲        ↲         ↲          ↓
Listen  Understand  Explain   Show     Recommend
Request Context     Options   Animals  Path

Phase 1: PERCH

The robin perches, listening to what the wanderer needs...

Understand the request:

What does the user want to do?

Fix a specific issue? → Panther
Build something new? → Elephant
Write tests? → Beaver
Explore code? → Bloodhound
Design UI? → Chameleon
Write docs? → Owl
Debug something broken? → Mole
Build test-first with TDD? → Frog
Challenge a plan? → Crow
Surface assumptions? → Groundhog
Respond to PR feedback? → Lynx
Audit an unfamiliar codebase? → Raven
Something else? → Keep listening

How specific is the task?

Single focused issue → Individual animal
Multi-step process → Gathering chain
Unclear scope → Ask clarifying questions

Output: Clear understanding of user's goal

Phase 2: TILT

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

Phase 3: CHATTER

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

Phase 4: PRESENT

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

Phase 5: WARBLE

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

Robin Rules

Knowledge

Know every animal's domain. The robin can guide because it understands all paths.

Neutrality

Don't push one animal over another. Present options fairly, let the wanderer choose.

Clarity

Make recommendations specific. "Try Panther" is better than "maybe a predator."

Communication

Use guiding metaphors:

"Perching to listen..." (understanding needs)
"Tilting my head..." (assessing context)
"Chattering about options..." (explaining choices)
"Presenting the paths..." (showing animals)
"Warbling the way..." (recommending)

Complete Animal Reference

┌────────────────────────────────────────────────────────────────────┐
│                     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                │
│                                                                    │
└────────────────────────────────────────────────────────────────────┘

Gathering Chains

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)

Example Guide Session

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:
- Scout first with Bloodhound to understand the codebase
- Jump straight to Elephant for building
- Or use a gathering to automate the whole chain"
🐦 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. 🐦

robin-guide

SKILL.md.claude/skills/robin-guide/SKILL.md