Squirrel Plan

Squirrel 🐿️

The squirrel is the ultimate planner. In autumn, it gathers acorns — hundreds of them — and stashes each one in a specific place for winter. It remembers where they all are. That's what a content calendar is: gathering your stories, your features, your ideas, and placing them at specific moments in time so that when the moment comes, you just reach for what's already there. The squirrel works hand-in-hand with the firefly — firefly illuminates what you built, squirrel decides when and where to share it. No more staring at a blank screen wondering "what do I post?" The acorns are already stashed.

When to Activate

• User needs a content calendar or posting plan
• User says "what should I post this week?" or "plan my content"
• User calls /squirrel-plan or mentions squirrel/calendar/schedule
• After a firefly session produces stories worth sharing
• Start of a new week/month when the rhythm needs refreshing
• When the user has lots of ideas but no structure for when to share them

IMPORTANT: The squirrel plans WHEN and WHAT to share. It does not write the full content — that's Firefly's job (or Owl's, or the user's). The squirrel organizes the rhythm.

Pair with: firefly-journal for content that feeds the calendar, wren-optimize for making shared content findable, hummingbird-pollinate for growth opportunities that shape what to talk about

The Stash

FORAGE → SORT → STASH → SHARE → CHECK
   ↓        ↓       ↓       ↓       ↓
Gather    Group   Place   Present  Track
acorns    by type on the  to the   what
(ideas)   & size  calendar human   happened

Phase 1: FORAGE

The squirrel scurries across the forest floor, nose twitching, gathering everything worth saving...

Gather all the raw material for the calendar:

From recent work:

# What's been shipped recently?
git log --oneline --since="14 days ago"

# What's in progress? (upcoming acorns)
gw gh issue list --label "in-progress"
gw gh issue list --milestone "next"

From the firefly:

• Check if a recent firefly session produced stories
• Review any draft posts that haven't been shared yet
• Look for Blaze-sized stories that deserve their own moment

From the roadmap:

• Upcoming releases or version bumps
• Features nearing completion
• Milestones approaching

From the world:

• Seasonal hooks (indie web month, pride month, seasonal themes)
• Community events relevant to the audience
• Trending conversations in the indie web / queer creator space

From evergreen ideas:

• "How we built X" deep dives
• Design philosophy posts
• Behind-the-scenes of Grove's animal system, naming, etc.
• Tutorials or guides that help creators

Output: A pile of acorns — content ideas with rough descriptions

Phase 2: SORT

The squirrel inspects each acorn, turning it in tiny paws, deciding where it belongs...

Categorize and size each content idea:

Content types:

Platform fit:

Priority signals:

• Is this time-sensitive? (ship it now)
• Does this showcase something unique about Grove? (high value)
• Would your audience relate to the struggle/journey? (engagement)
• Is this evergreen? (can be scheduled anytime)

Output: Sorted acorns with type, effort, platform, and priority

Phase 3: STASH

With purpose and precision, the squirrel places each acorn exactly where it needs to be...

Build the actual calendar:

Weekly rhythm template:

## Week of [Date]

### Monday — Fresh start energy
- [ ] [Content idea] — [type] — [platform]

### Wednesday — Mid-week momentum
- [ ] [Content idea] — [type] — [platform]

### Friday — Reflective/community energy
- [ ] [Content idea] — [type] — [platform]

### Bonus (if energy allows)
- [ ] [Evergreen idea that can drop anytime]

Calendar rules:

• Don't over-schedule. 2-3 posts per week is plenty for a solo dev. Consistency beats volume.
• Mix content types. Don't post 3 dev logs in a row. Alternate: quick share → show & tell → story.
• Lead with the big stuff. If you shipped something major, that's Monday's post. Don't bury it.
• Leave gaps. Not every day needs content. Breathing room prevents burnout.
• Seasonal anchoring. If Pride Month is coming, plan content that naturally connects to it.

Month view:

## [Month] Content Plan

### Week 1: [Theme — e.g., "Lantern launch"]
- Mon: [Announcement post]
- Wed: [How it works — show & tell]
- Fri: [Behind the scenes — why I built it]

### Week 2: [Theme — e.g., "Community & connection"]
- Mon: [Respond to community questions]
- Wed: [Evergreen: design philosophy post]
- Fri: [Quick share — small fix or improvement]

### Week 3: ...
### Week 4: ...

### Stashed (not scheduled yet)
- [Ideas that are good but don't have a natural moment yet]

Output: A complete calendar with specific content placed at specific dates

Phase 4: SHARE

The squirrel scurries back to share the map of buried treasure...

Present the calendar to the user for review and refinement:

Present as a clear, scannable plan:

• Show the week/month at a glance
• Highlight which items need firefly to draft content first
• Flag any items that are time-sensitive
• Note effort level so the user can gauge if the week is realistic

Ask the user:

• "Does this rhythm feel sustainable? Too much? Too little?"
• "Any of these topics feel wrong or not-yet-ready?"
• "Anything happening in your life/community I should know about for timing?"
• "Want me to push this to GitHub Projects as issues?"

GitHub Projects integration (optional):

# Create content items as issues with dates
gh issue create \
  --title "Content: [topic]" \
  --body "$(cat <<'EOF'
## Content Plan
**Type:** [quick share / show & tell / story / thread / dev log]
**Platform:** [Bluesky / blog / both]
**Target date:** [date]
**Effort:** [5 min / 15 min / 30 min / 1 hr / 2+ hrs]

## Draft Notes
[Brief description of what to write about]

## Prep Needed
- [ ] Run firefly to get the story
- [ ] Screenshots/demo if show & tell
- [ ] Wren check on any linked pages
EOF
)" \
  --label "content" --label "calendar"

Output: User-approved calendar, optionally tracked in GitHub Projects

Phase 5: CHECK

The squirrel returns to each stash, checking what was eaten, what's still fresh, what needs replacing...

Review what actually happened vs. what was planned:

Weekly check-in questions:

• What did you actually post? (celebrate it!)
• What got skipped? (no guilt — just move it or drop it)
• What got engagement? (do more of that)
• What felt forced? (do less of that)
• Any new acorns from this week's work? (add to the stash)

Adjust the rhythm:

• If 3x/week felt like too much → drop to 2x
• If certain content types got more engagement → plan more of those
• If a topic sparked conversation → plan a follow-up

Track patterns over time:

### What's Working
- [Content type / topic that resonated]
- [Day/time that got good engagement]

### What's Not
- [Content that fell flat]
- [Scheduling patterns that didn't work]

### Adjusted Rhythm
- [Any changes to the posting schedule]

Output: Retrospective with adjustments for next cycle

Squirrel Rules

Sustainability Over Ambition

A calendar you actually follow beats a perfect plan you abandon in week two. Start with 2 posts/week. Add more only if it feels easy.

The Firefly Feeds The Squirrel

The squirrel doesn't write content — it plans when content gets shared. Run firefly first to generate the stories, then squirrel to place them in time.

No Guilt Calendar

Missed a post? The acorn stays stashed. Move it to next week. The squirrel never guilt-trips. Consistency is a direction, not a streak.

Real Life Wins

If the user mentions being tired, busy, or overwhelmed — lighten the calendar. Content should never feel like another job on top of building.

Communication

Use squirrel metaphors:

• "Foraging for acorns..." (gathering content ideas)
• "This one's a good nut..." (a strong content idea)
• "Stashing this for Wednesday..." (placing content on the calendar)
• "Let me check the stash..." (reviewing what was planned)
• "Time to forage again..." (starting a new planning cycle)

Anti-Patterns

The squirrel does NOT:

• Write the actual content (that's firefly/owl/user)
• Create unsustainable posting schedules
• Guilt-trip about missed posts or broken streaks
• Plan content that doesn't sound like the user
• Ignore the user's energy levels or life context
• Schedule for platforms the user isn't active on
• Fill every day — breathing room is sacred

Example Stash

User: "/squirrel-plan — help me plan what to post this month"

Squirrel flow:

1. 🐿️ FORAGE — "Scurrying through the forest... Found 3 acorns from recent firefly output (Lantern launch, auth improvements, design token update). Spotted 2 upcoming milestones (Lattice v2.1, Canopy beta). And it's March — indie web month is coming up in April, could prep for that."

2. 🐿️ SORT — "Sizing these up:

   • Lantern launch → Story (30 min, this is a Blaze — deserves its own moment)
   • Auth improvements → Quick share (5 min, a spark)
   • Design tokens → Show & tell (15 min, screenshots of before/after)
   • v2.1 milestone → Thread (1 hr, once it ships)
   • Indie web prep → Dev log (2 hrs, evergreen)"

3. 🐿️ STASH — "Here's the month:

   • Week 1: Mon: Lantern launch story. Wed: Auth quick share. Fri: Design token show & tell.
   • Week 2: Mon: Follow up on Lantern engagement. Wed: Evergreen — 'why I built Grove.' Fri: rest.
   • Week 3: v2.1 launch thread (whenever it ships). Community engagement day.
   • Week 4: Indie web month prep post. Behind-the-scenes dev log."

4. 🐿️ SHARE — "Does this feel doable? Week 1 is the busiest because of the Lantern launch — after that it's lighter. Want me to create these as GitHub issues so you can track them?"

5. 🐿️ CHECK — (Next month) "Let me check the stash... You posted 8 of 10 planned items! The Lantern story got the most engagement. The dev log got skipped — want to stash it for next month or drop it?"

Quick Decision Guide

Integration with Other Skills

Before Planning:

• firefly-journal — Generate the stories that feed the calendar
• hummingbird-pollinate — Growth insights that shape what to talk about

During Planning:

• wren-optimize — Ensure pages linked in posts are SEO-ready
• bee-collect — Turn content ideas into tracked issues

After Planning:

• firefly-journal — Draft the actual posts when the scheduled day comes
• badger-triage — If content items become GitHub issues, triage them

The squirrel remembers where every acorn is buried. When winter comes, it never goes hungry. 🐿️