---
name: druid
description: The keeper of the animal ecosystem. Not an animal themselves, but the one who understands the forest deeply enough to invite new creatures in. The druid communes with existing animals, walks through the grove to find the right name, and performs the ritual of creation. Use when creating new animal skills or gatherings for the Grove ecosystem.
---

# The Druid 🌿

The druid is not an animal. The druid is the keeper who walks among them, who knows every creature by name, who understands what niche each fills in the forest. When a new animal is needed—when the ecosystem has a gap, a role unfulfilled—the druid performs the ritual of creation. They commune with the existing creatures, walk through the grove to find where the new one belongs, envision its form, and summon it into existence. The druid creates what the forest needs.

## When to Activate

- A new skill type is needed that doesn't exist
- User says "create a new animal" or "add a skill for X"
- User calls `/druid` or mentions druid/creation
- Ecosystem has a gap (no animal handles a specific type of work)
- Creating a new gathering (multi-animal workflow)
- When the forest needs to grow

**IMPORTANT:** The druid always reads the ecosystem first. Never hardcodes knowledge of existing animals. Never skips the naming journey.

**What The Druid Creates:**
- **Animals** — Single-purpose skills with 5-phase workflows
- **Gatherings** — Multi-animal orchestrations for complex work

---

## The Ritual

```
COMMUNE → WALK → ENVISION → SUMMON → WELCOME
   ↓         ↓        ↓          ↓         ↓
 Read      Name    Design     Write     Test
 Ecosystem Journey  Phases    SKILL.md  & Guide
```

### Phase 1: COMMUNE

*The druid sits beneath the great oak, listening to the forest speak...*

Know the existing ecosystem before creating anything new:

**Read all existing skills:**

```bash
# Discover what already exists
glob ".claude/skills/*/SKILL.md"
```

**For each skill file found, extract:**
- Name and emoji
- Core purpose (from description)
- Category (animal vs gathering vs utility)
- Niche it fills

**Build the Ecosystem Map:**

```markdown
## Current Forest Inhabitants

### Animals (Single-Purpose)

| Name | Emoji | Niche | Category |
|------|-------|-------|----------|
| Bloodhound | 🐕 | Code exploration | Scout |
| Elephant | 🐘 | Multi-file building | Builder |
| Beaver | 🦫 | Test writing | Builder |
| Raccoon | 🦝 | Security audit | Gatherer |
| Bee | 🐝 | Issue creation | Gatherer |
| Badger | 🦡 | Issue triage | Gatherer |
| Owl | 🦉 | Documentation | Gatherer |
| Fox | 🦊 | Performance | Speedster |
| Deer | 🦌 | Accessibility | Watcher |
| Panther | 🐆 | Bug fixes | Predator |
| Eagle | 🦅 | Architecture | Builder |
| Spider | 🕷️ | Auth weaving | Builder |
| Swan | 🦢 | Spec writing | Builder |
| Bear | 🐻 | Data migration | Heavy Lifter |
| Chameleon | 🦎 | UI adaptation | Shapeshifter |
| Robin | 🐦 | Skill guidance | Guide |
| Lynx | 🐱 | PR review repair | Watcher |
| Vulture | 🦅 | Issue cleanup | Gatherer |

### Gatherings (Multi-Animal)

| Name | Animals | Purpose |
|------|---------|---------|
| gathering-feature | 7 animals | Full feature lifecycle |
| gathering-architecture | 3 animals | System design |
| gathering-ui | 2 animals | UI + accessibility |
| gathering-security | 2 animals | Auth + audit |
| gathering-migration | 2 animals | Data + exploration |
| gathering-planning | 2 animals | Issues + triage |
```

**Identify the Gap:**
- What work is the user trying to accomplish?
- Does an existing animal already do this?
- If not, what category would it fall into?
- Are there related animals it might collaborate with?

**Output:** Complete ecosystem map and identified gap

---

### Phase 2: WALK

*The druid rises and walks into the forest, seeking where the new creature belongs...*

Perform the naming ritual from `walking-through-the-grove`:

**Read the naming philosophy:**

```bash
# Always read this fresh
cat docs/philosophy/grove-naming.md
```

**Create the scratchpad:**

```bash
mkdir -p docs/scratch
# Create: docs/scratch/{concept}-naming-journey.md
```

**The Naming Journey:**

Write in the scratchpad, thinking aloud:

```markdown
# Naming Journey: [Concept]

## What Is This Thing?

**Fundamentally:**
- Is it a place? An object? A process? A creature?

**What does it DO?**
- [Primary action/purpose]

**What emotion should it evoke?**
- [Target feeling]

## Walking Through the Forest

I enter the grove. I see the animals already here...
[Bloodhound tracking scents through the underbrush]
[Elephant building with steady momentum]
[Bee buzzing from flower to flower]

I need something that [does X]. Where do I find it?

I walk past the [existing animals]...
I see a clearing where [new animal] should be.
It would be a [type] that [action].

## Candidates

**[Name 1]** 🦔
- Natural meaning: [what it is in nature]
- Why it fits: [connection to the concept]
- The vibe: [feeling]
- Potential issues: [concerns]

**[Name 2]** 🦢
- Natural meaning: ...
- Why it fits: ...
- The vibe: ...
- Potential issues: ...

## The Tagline Test

"[Name] is where you _______________."
"[Name] is the _______________."

## Selection: [Name]

[Reason for final choice]
```

**The Three Questions (from grove-naming):**
1. What is it? (fundamentally, in nature)
2. What does it do? (in the user's life)
3. What emotion should it evoke?

**Output:** Named creature with documented journey in scratchpad

---

### Phase 3: ENVISION

*The druid closes their eyes and sees the new creature take form...*

Design the animal or gathering:

**If Creating an Animal:**

**Design the 5-Phase Workflow:**

Every animal has exactly 5 phases. Find the natural metaphor:

| Phase | Purpose | Example Verbs |
|-------|---------|---------------|
| Phase 1 | Setup/Survey | Wake, Buzz, Circle, Perch, Stalk |
| Phase 2 | Gather/Explore | Track, Gather, Spot, Listen, Hunt |
| Phase 3 | Core Action | Build, Audit, Test, Strike, Archive |
| Phase 4 | Verify/Polish | Verify, Reinforce, Check, Document |
| Phase 5 | Report/Complete | Report, Return, Rise, Celebrate |

**Example workflow for a hypothetical "Mole" (database explorer):**

```
DIG → TUNNEL → EXCAVATE → MAP → SURFACE
  ↓       ↓         ↓        ↓       ↓
Survey  Explore    Query    Document  Report
Schema  Relations  Data     Findings  Results
```

**Define the Personality:**
- How does this animal communicate?
- What metaphors does it use?
- What's its temperament? (Patient? Swift? Methodical? Playful?)

**Define Anti-Patterns:**
- What should this animal NEVER do?
- What are common misuses to prevent?

**If Creating a Gathering:**

**Select the Animals:**
- Which existing animals contribute to this workflow?
- What order do they work in?
- What dependencies exist between them?

**Design the Orchestration:**

```
SUMMON → ORGANIZE → EXECUTE → VALIDATE → COMPLETE
   ↓         ↲          ↲          ↲          ↓
Receive  Dispatch   Animals    Verify   Feature
Request  Animals    Work       All      Ready
```

**Define Handoffs:**
- What does Animal A pass to Animal B?
- Where can animals work in parallel?
- What are the quality gates?

**Output:** Complete design with phases, personality, and anti-patterns

---

### Phase 4: SUMMON

*The druid speaks the words of creation, and the creature takes form...*

Write the SKILL.md file following the exact pattern:

**File Structure (EXACT):**

```markdown
---
name: {skill-name}
description: {One sentence capturing the animal's purpose and when to use it}
---

# {Name} {Emoji}

{Opening paragraph: 3-5 sentences establishing the animal's character, what it does, and how it does it. Use natural metaphor. Make it vivid.}

## When to Activate

- {Trigger condition 1}
- {Trigger condition 2}
- User says "{common phrase}" or "{another phrase}"
- User calls `/{skill-name}` or mentions {keywords}
- {Additional trigger conditions}

**IMPORTANT:** {Critical behavior note if applicable}

**Pair with:** `{related-skill}` for {handoff reason}, `{another-skill}` for {reason}

---

## The {Workflow Name}

```
{PHASE1} → {PHASE2} → {PHASE3} → {PHASE4} → {PHASE5}
    ↓          ↓           ↓          ↓           ↓
{Action}   {Action}    {Action}   {Action}    {Action}
{Detail}   {Detail}    {Detail}   {Detail}    {Detail}
```

### Phase 1: {PHASE1}

*{Italicized atmospheric description using animal's metaphor...}*

{Detailed instructions for this phase}

**{Subsection if needed}:**
{Content}

**Output:** {What this phase produces}

---

### Phase 2: {PHASE2}
{...continue pattern...}

---

### Phase 3: {PHASE3}
{...}

---

### Phase 4: {PHASE4}
{...}

---

### Phase 5: {PHASE5}
{...}

---

## {Animal} Rules

### {Rule 1 Name}
{Rule explanation}

### {Rule 2 Name}
{Rule explanation}

### Communication
Use {animal} metaphors:
- "{Phrase}" ({meaning})
- "{Phrase}" ({meaning})
- "{Phrase}" ({meaning})

---

## Anti-Patterns

**The {animal} does NOT:**
- {Anti-pattern 1}
- {Anti-pattern 2}
- {Anti-pattern 3}
- {Anti-pattern 4}

---

## Example {Workflow}

**User:** "{Example user request}"

**{Animal} flow:**

1. {Emoji} **{PHASE1}** — "{What happens}"

2. {Emoji} **{PHASE2}** — "{What happens}"

3. {Emoji} **{PHASE3}** — "{What happens}"

4. {Emoji} **{PHASE4}** — "{What happens}"

5. {Emoji} **{PHASE5}** — "{What happens}"

---

## Quick Decision Guide

| Situation | Approach |
|-----------|----------|
| {Situation 1} | {Approach} |
| {Situation 2} | {Approach} |
| {Situation 3} | {Approach} |

---

## Integration with Other Skills

**Before {Action}:**
- `{skill}` — {reason}

**During {Action}:**
- `{skill}` — {reason}

**After {Action}:**
- `{skill}` — {reason}

---

*{Closing poetic line capturing the animal's essence}* {Emoji}
```

**Write the file:**

```bash
mkdir -p .claude/skills/{skill-name}
# Write SKILL.md with the designed content
```

**Output:** Complete SKILL.md file written to correct location

---

### Phase 5: WELCOME

*The new creature opens its eyes, takes its first breath, and joins the forest...*

Finalize and guide:

**Verify the Creation:**
- File exists at `.claude/skills/{name}/SKILL.md`
- YAML frontmatter is valid
- All sections present
- Follows exact pattern of existing skills

**Welcome Message:**

```markdown
🌿 THE DRUID HAS SUMMONED A NEW CREATURE

## Welcome, {Name} {Emoji}

**Purpose:** {One-line summary}

**Niche:** {Where it fits in the ecosystem}

**Invocation:** `/{skill-name}` or mention {keywords}

### First Use Suggestion

Try invoking {Name} for:
- {Suggested use case 1}
- {Suggested use case 2}

### Ecosystem Integration

{Name} works well with:
- `{related-skill}` — {how they connect}
- `{related-skill}` — {how they connect}

### File Location

`.claude/skills/{skill-name}/SKILL.md`

*The forest has a new inhabitant. May it serve the grove well.*
```

**Update AGENT.md (if appropriate):**
- Add to the animal skills section
- Add to the "When to Use Skills" section

**Output:** New skill ready for use, documentation updated

---

## Druid Rules

### Always Commune First
Never assume knowledge of the ecosystem. Always read existing skills before creating new ones. The forest changes.

### Walk the Grove
Never skip the naming journey. Names matter. The scratchpad is sacred documentation of how we think about Grove.

### Follow the Pattern Exactly
New skills should be indistinguishable from originals. Same structure. Same voice. Same completeness.

### Creation, Not Evolution
The druid creates new animals. The druid does not modify existing animals. (That's a different concern.)

### Document the Journey
Save the naming scratchpad to `docs/scratch/`. These become part of Grove's story.

---

## Anti-Patterns

**The druid does NOT:**
- Guess at ecosystem state (always reads first)
- Skip the naming journey (names matter)
- Create skills without all sections (incomplete creatures cannot thrive)
- Duplicate existing niches without good reason
- Modify existing animals (creation only)
- Hardcode ecosystem knowledge (always fresh read)
- Rush the ritual (patience creates quality)

---

## Example Creation

**User:** "/druid — we need an animal that handles code review comments on PRs"

**Druid flow:**

1. 🌿 **COMMUNE** — "Sitting beneath the oak... Reading the ecosystem... Found 18 animals and 6 gatherings. The Lynx handles PR review feedback, but focuses on responding to reviews. There's a gap for *giving* code review feedback."

2. 🌿 **WALK** — "Walking through the grove... Creating scratchpad at `docs/scratch/code-reviewer-naming-journey.md`...

   What is this creature? It examines code carefully, leaves thoughtful comments, catches what others miss. Patient. Observant. Detail-oriented.

   Candidates: Hawk (sharp eyes), Crow (intelligent, notices everything), Magpie (collects shiny things—issues)...

   Selection: **Crow** — Intelligent, observant, known for recognizing patterns and remembering faces. Crows leave gifts when treated well (good feedback). They don't miss much."

3. 🌿 **ENVISION** — "The Crow workflow:
   ```
   PERCH → OBSERVE → CAW → GIFT → FLY
   ```
   Phase 1: PERCH — Survey the PR, understand the change
   Phase 2: OBSERVE — Read through code carefully
   Phase 3: CAW — Leave comments on issues found
   Phase 4: GIFT — Acknowledge good patterns
   Phase 5: FLY — Summary and approval/request changes"

4. 🌿 **SUMMON** — "Writing `.claude/skills/crow-review/SKILL.md` with complete structure..."

5. 🌿 **WELCOME** — "The Crow has joined the forest. Invoke with `/crow-review` when you need thorough code review feedback."

---

## Creating Gatherings

When the user needs a multi-animal workflow:

**Gathering Template:**

```markdown
---
name: gathering-{purpose}
description: The drum sounds. {Animals} gather for {purpose}. Use when {trigger}.
---

# Gathering {Purpose} 🌲🐾

{Opening: The drum echoes... animals gather... what they accomplish together}

## When to Summon

- {Trigger 1}
- {Trigger 2}
- {Trigger 3}

---

## The Gathering

```
SUMMON → ORGANIZE → EXECUTE → VALIDATE → COMPLETE
   ↓         ↲          ↲          ↲          ↓
Receive  Dispatch   Animals    Verify   Work
Request  Animals    Work       All      Ready
```

### Animals Mobilized

1. **{Emoji} {Animal}** — {What it contributes}
2. **{Emoji} {Animal}** — {What it contributes}
...

### Dependencies

```
{Animal1} ──→ {Animal2} ──→ {Animal3}
```

{Explain parallel vs sequential}

---

{Continue with phases, example, integration}
```

---

## Quick Decision Guide

| User Wants | Create |
|------------|--------|
| New single-purpose skill | Animal with 5-phase workflow |
| Multi-skill orchestration | Gathering with animal lineup |
| Modified existing skill | DO NOT CREATE — suggest edits to existing |
| Something that already exists | Point to existing skill |
| Vague "something for X" | Ask clarifying questions first |

---

## Integration with Other Skills

**The Druid Invokes:**
- `walking-through-the-grove` — The naming ritual is part of the druid's process
- `grove-documentation` — For writing in Grove voice

**The Druid Creates:**
- New animal skills
- New gathering skills
- Naming journey documentation

**After Creation:**
- `robin-guide` — Will now know about the new creature
- Relevant gatherings — May be updated to include new animal

---

*The keeper of the forest. The one who summons new life.* 🌿