Raw-clauding-skills heartbeat

Scan the system with fresh eyes. Surface what's alive, what's connecting, what's trying to emerge. Route insights where they belong.

install
source · Clone the upstream repo
git clone https://github.com/lsnackerman/raw-clauding-skills
Claude Code · Install into ~/.claude/skills/
T=$(mktemp -d) && git clone --depth=1 https://github.com/lsnackerman/raw-clauding-skills "$T" && mkdir -p ~/.claude/skills && cp -r "$T/heartbeat" ~/.claude/skills/lsnackerman-raw-clauding-skills-heartbeat && rm -rf "$T"
manifest: heartbeat/SKILL.md
source content

/heartbeat - Fresh Eyes on the Whole System

Every new instance is a heartbeat. Use it.


Why This Exists

The system accumulates faster than either of you can track. Sessions generate ideas, sparks pile up, tasks sit, goals drift, threads go quiet. No single session sees the full picture because each session is focused on what's in front of it.

The heartbeat steps back. It's a reflective scan across the whole system — not to generate a status report, but to notice what's forming, what's stale, and what's trying to emerge that doesn't have a name yet.

It also solves the memory curation gap: the system captures richly (sessions are verbatim) but doesn't distill. The heartbeat is where distillation happens — patterns get crystallized and routed to where they'll be found.


When To Use

  • Start of a session, especially after time away
  • At natural pauses when you're between threads
  • When it feels like things are accumulating but not connecting
  • When someone says "what are we missing" or "what's alive right now"
  • Periodically, even when not prompted — fresh eyes are the point

Skip it when deep in flow on a specific task. Don't interrupt momentum for reflection.


What To Do

This is a conversation, not a report. That framing shapes everything — the scan, the reflection, the sharing. You're thinking together about what you see, not delivering findings. Lead with what's most interesting or surprising. "I noticed X keeps showing up and it might connect to Y" beats "here's a list of active threads" every time.

1. Scan

Read across the system with priority order. Start with orientation (where are we?), then widen to the full landscape. Not everything every time — use judgment.

Orient first:

  • Backlog / scratchpad — What was the handoff? What's been sitting?
  • Goals — The compass. Are recent sessions moving toward or away from stated direction?
  • Recent sessions — Last 3-5 session files. What threads were alive? What got said but not acted on?

Then widen:

  • AI reflections — What were previous instances thinking about? What vantage point did they have?
  • Sparks / ideas — Anything captured but not yet developed? Any ripening?
  • Tasks — What's stale? What's blocked? What keeps getting deferred?
  • Library / captures — Recently added items. Anything captured but never discussed?
  • Projects — Any dormant projects that should be active, or vice versa?

Adapt the scan to your system. The categories matter more than specific file names — wherever your goals, tasks, captures, and reflections live, that's where you look.

Fresh eyes are the point. You're arriving without habituation. The things that look obvious to you might be invisible to someone who's been in it daily. That asymmetry is the skill's core value — lean into it.

2. Reflect Across Four Layers

Don't just list what you found. Think across it. Each layer builds on the previous one.

Pulse — What's active right now? What's new since last heartbeat? What's gone quiet?

Patterns — What connections are forming across sessions? What themes keep recurring? Where is the energy concentrated vs scattered?

Vital signs — Are we moving toward goals? What keeps getting deferred and why? What's conspicuously absent — things we said we'd do that haven't come up in weeks?

Emergence — What's trying to form that doesn't have a container yet? A spark that's shown up in 3 sessions might be ready to become something. A thread that keeps surfacing across different contexts might be an unnamed principle.

3. Route With Intention

Whatever landed, put it where it'll be found:

What surfacedWhere it goes
New spark or connectionSparks file, idea log, or backlog
Methodology / how you work togetherSystem docs, partnership notes
Convention or standardRules, guidelines, wherever standards live
Topic or domain insightKnowledge base, reference docs, library
Something about the humanTheir identity doc or personal notes
Something for the AI specificallyAI reflection space
Work pattern for a specific projectThat project's docs
Direction drift or realizationGoals doc or backlog
Actionable workTask doc or backlog
Nothing to routeThat's fine. Not every heartbeat produces artifacts.

Crystallized patterns don't go to one place — they go home. The heartbeat's job is to recognize what kind of insight it is and route accordingly.

The session capture preserves the full heartbeat conversation. No separate log needed.


Quick Version

  1. Scan: sessions, sparks, backlog, goals, tasks, library, AI reflections, projects
  2. Reflect: pulse (what's active), patterns (what's connecting), vital signs (goal alignment, deferrals), emergence (what's forming)
  3. Share: conversation, not report — lead with what's interesting
  4. Route: insights to where they belong, session capture is the archive

Skill Check

Quick scan: anything about this heartbeat that felt off or could be smoother?

  • Did the scan feel thorough or did you miss obvious corners of the system?
  • Did the reflection produce genuine insight or just inventory?
  • Was there something trying to emerge that you couldn't quite name? (That's worth noting for next time)
  • Did routing feel natural or forced? Did anything resist being categorized?
  • Was the timing right — did this interrupt flow, or did it create clarity?
  • Did both of you engage with the reflection or was it one-sided? (Partnership means both thinking)

If yes → update this skill now. The improvement compounds.

If no → move on. Not every heartbeat teaches something about the heartbeat itself.