home / skills / willsigmon / sigstack / daily-driver

This skill helps you start each workday fast by loading context, setting priorities, and guiding a focused standup across projects.

npx playbooks add skill willsigmon/sigstack --skill daily-driver

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.7 KB
---
name: Daily Driver
description: Start each day efficiently - standup, priorities, context loading
allowed-tools: Read, Bash, ToolSearch
model: haiku
---

# Daily Driver

Start fast, stay focused.

## Morning Startup (2 minutes)

### Quick Context Load
```
"What's the state of [project]?"

Claude checks:
- Git status
- Recent commits
- Open TODOs
- Last session notes
```

### Priority Setting
```
"Top 3 things for today?"

Based on:
- Yesterday's progress
- Blockers cleared
- Deadlines
```

## Daily Standup Pattern

### Solo Dev Standup
```
"Standup:
- Yesterday: [what you did]
- Today: [what you'll do]
- Blockers: [anything stopping you]"

Claude records, suggests priorities.
```

### End of Day
```
"EOD:
- Done: [completed tasks]
- WIP: [in progress]
- Tomorrow: [next priorities]"

Creates handoff for next session.
```

## Quick Starts

### Resume Work
```
"Continue where we left off"

Claude checks:
- Last conversation summary
- Memory MCP for context
- Git for recent changes
```

### Fresh Start
```
"New day, new focus: [area]"

Clears old context.
Loads relevant files.
```

### Quick Fix Mode
```
"Quick bug: [description]"

Fast path:
- Find issue
- Fix it
- Commit
- Move on
```

## Context Switching

### Between Projects
```
"Switch to [other project]"

Claude:
- Saves current context
- Loads new project CLAUDE.md
- Checks that project's state
```

### Between Tasks
```
"Park this, work on [other thing]"

Claude notes:
- Current state
- What's pending
- Resume point
```

## Energy Management

### High Energy Tasks
```
Morning:
- Architecture decisions
- Complex debugging
- New feature design

→ Use Opus when needed
```

### Low Energy Tasks
```
Afternoon:
- Code cleanup
- Documentation
- Simple fixes

→ Use Haiku
```

## Quick Commands

### Status Check
```
"Status" → Git status + recent work
"What's broken?" → Check tests/errors
"What's next?" → Priority list
```

### Time Boxing
```
"30 min on [task]"

Claude focuses only on that.
Reminds when time's up.
```

### Quick Notes
```
"Note: [thought]"

Stored in memory MCP.
Retrieved when relevant.
```

## Daily Patterns

### Monday
```
"Week planning: what's the focus?"

Review:
- Last week's progress
- This week's goals
- Blockers to clear
```

### Friday
```
"Week wrap: what shipped?"

Summary:
- Completed items
- Learnings
- Next week prep
```

## Anti-Patterns

### Don't
```
❌ Start without context
❌ Work on many things at once
❌ Skip end-of-day capture
❌ Forget yesterday's blockers
```

### Do
```
✓ 2-minute standup start
✓ Single focus per session
✓ Capture progress before closing
✓ Review blockers first
```

Use when: Starting each day, context switching, maintaining momentum

Overview

This skill helps you start each day efficiently by loading project context, setting priorities, and running a short standup pattern. It minimizes context switching and keeps momentum through quick commands for resuming work, focused time boxing, and end-of-day handoffs. It’s designed for individual developers and small teams using code, notes, and memory checkpoints.

How this skill works

On startup it inspects project state (Git status, recent commits, open TODOs) and recent session summaries to build an immediate context snapshot. It then suggests a Top 3 priority list based on yesterday’s progress, blockers, and deadlines. Throughout the day it supports quick switches, focused timers, notes captured to memory, and an EOD routine that records done/WIP/tomorrow for easy handoffs.

When to use it

  • Beginning your workday to load context and set priorities
  • Resuming work after a break or switching between projects
  • Running a fast solo standup or end-of-day summary
  • Tackling a quick bug or time-boxed task
  • Planning weekly goals (Monday) or wrapping the week (Friday)

Best practices

  • Do a 2-minute standup at the start of every session to capture context and priorities
  • Stick to a single focused session (time-box if needed) to avoid multitasking
  • Save an EOD note with Done, WIP, and Tomorrow to make resuming trivial
  • Use prioritized Top 3 daily items to keep work aligned with deadlines
  • Park work before switching projects: record state, pending items, and a clear resume point

Example use cases

  • Morning startup: automatic Git check, recent commits, open TODOs, and suggested Top 3 for the day
  • Quick fix flow: locate the failing test or error, apply a fix, commit, and note the change
  • Context switch: save the current session state, load another project’s context and CLAUDE.md, then start focused work
  • Time-boxed focus: set a 30-minute timer on a task and receive reminders when time’s up
  • End-of-day handoff: create a compact EOD summary with completed items, in-progress work, and next-day priorities

FAQ

How quickly does it load project context?

Context loads in a couple of minutes by checking Git, recent commits, open TODOs, and last session notes so you can act immediately.

Can I park work and resume later without losing progress?

Yes. The skill records the current state, pending items, and a resume point so switching projects or tasks preserves context.