How I Use Claude to Plan My Day

I have a TickTick with hundreds of tasks, a Jira board, an PR queue, a calendar full of meetings, an Oura ring and Pixel Watch 4 (via Fitbit) feeding health data, and a full personal life as a single dad.

Left alone, whatever yells loudest wins the day. So over the last month or two I’ve been building a system in Claude that turns the pile into a single short list, runs it through the day with me, and at the end of the year hands me a half-written self-review. The whole thing is anchored by one slash command: /stream.

Lake vs Stream

The mental model is two buckets:

• The Lake is everything I have ever said yes to. Hundreds of items across TickTick, Jira, and email. It is supposed to be big. Its job is to remember things so I don’t have to.
• The Stream is what I’m actually doing today. Roughly 5 work tasks plus 1-2 personal tasks. It lives in a daily note in Obsidian, not in a task manager.

The whole point of /stream is that I never have to open the Lake to decide what to do. Claude is the filter. I pour the Lake in, a Stream comes out.

Morning: /stream

Every workday at around 9am I run /stream (no arguments, defaults to both work and personal). Before showing me anything, it pulls together:

• Calendar for today and tomorrow (meetings, focus blocks, fragmentation, largest contiguous block)
• Health signals from Oura (readiness, sleep, HRV) and Fitbit (steps, active minutes), so a 5-hour sleep night doesn’t get a 3-deep-task plan
• Candidate tasks from TickTick (work and personal lists) and Jira (assigned, in progress, due soon)
• Open PRs I either own or am reviewing
• Yesterday’s note, including the unchecked items from yesterday’s Stream and the machine-readable nudges and seeds the previous evening’s /stream close left behind
• The Monday Preload on Mondays, which the Friday weekly review wrote into the prior week’s note
• Active project state files, so anything tied to an at-risk project gets surfaced
• Meeting prep, looking for the most recent 1:1 note for each person I have a 1:1 with that day, plus any project meetings on the calendar
• Weather and deliveries for the personal side, so “pick up packing boxes” can be paired with “USPS arriving today”

Then it asks me one question: roughly how many hours do I expect to actually work today? That number is the declared capacity, and it gets written into the note as a YAML-ish HTML comment. It’s the bit that keeps me honest, because it lets me size the plan for the day I’m actually about to have, not the day I wish I had.

After that, it proposes a Stream. Each task has a one-line “Why today?” annotation: “good 90-minute morning block”, “carried 3 days, needs closure”, “unblocks Joe’s review”, “deadline tomorrow.” If something doesn’t fit, it tells me what would get bumped and asks. I either accept, swap, or push back, and it writes the agreed-upon list into today’s daily note under # Stream, plus an # Agenda for meetings, plus a # Health block, plus a tonight’s-personal-task line.

Then it offers to time-block the day. This is a small bash script I wrote called calblock that talks to macOS Calendar via AppleScript. Once the Stream is finalized, Claude builds a schedule plan: fixed-time errands first, deep work into the largest contiguous block, medium tasks into mid-sized gaps between meetings, small tasks into whatever’s left, with buffers before and after meetings so deep work doesn’t get scheduled into the 30 minutes before a sync. It writes the plan as JSON, then calblock plan creates the events on a dedicated “Stream” calendar, prefixed so they’re easy to spot. Re-running the morning clears today’s blocks first so I never end up with duplicates, but past days are never touched, which means the Stream calendar becomes a permanent historical record of what I planned to do, visible right next to the meetings I actually attended. The plan is now physically present on my calendar, not just in a note I might forget to open.

The daily note is still the source of truth for the rest of the day.

Midday: /stream update

Around 1pm I sometimes run /stream update. It re-reads the calendar (a meeting got cancelled, or a fire dropped on me), checks what I’ve already finished, and rebalances what’s left. It edits the existing # Stream section in place. I do not get a second plan, I get the same plan, brought back into sync with reality.

End of day: /stream close

Around 5pm I run /stream close. It’s the inverse of the morning:

• Refreshes TickTick, Jira, PRs, calendar, and Fitbit one more time
• Compares planned vs actual, scores the day (well-scoped, over-scoped, fragmented, etc.)
• Asks me one question: how many hours did I actually work? The delta between declared and actual is the calibration signal.
• Infers, without asking, why anything carried over (heavy meeting day, blocked on a reviewer, a deep task on a low-readiness day, etc.)
• Generates 3-5 forward-looking insights, the kind that only show up when you have a week’s worth of closes to compare against. “Meeting-heavy days average 45% completion. Tomorrow has 4. Cap tomorrow at 3 tasks.”
• Writes a # Close section to today’s note with a completion summary, what got done, carryover, energy, perf-worthy callouts (more on those in a second), and the insights

What it leaves behind for tomorrow is the part I lean on most:

<!-- stream-nudges
scope: light
carry: CG-7
reserve-reviews: true
-->
 
<!-- stream-seed
- id: CG-7
  title: Ownership wizard flow
  why: carryover, deep work in flight
- id: b5/b5!32959
  title: Review Joe's credential list PR
  why: unblocks teammate
-->

Those HTML comments are invisible in Obsidian’s rendered view, but tomorrow morning’s /stream parses them on the way in. The nudges block tunes the next plan (cap the scope, protect focus, reserve a slot for reviews). The seed block pre-loads 2-3 high-confidence candidates so the morning Stream doesn’t start cold.

Perf-worthy callouts

Inside the daily note, I leave Obsidian callouts whenever something happens that’s worth remembering for performance reviews:

> [!staff] Led cross-team migration decision
> Aligned MSP and Core on the partner portal data model in the architecture sync,
> unblocked three downstream tickets.
 
> [!senior] Resolved SCIM provisioning regression under deadline pressure

/stream close scans for these and surfaces a one-liner each evening: “Perf-worthy today: 1 staff + 1 senior callout (…)”. They live inline in the note, where the context is fresh, and they get harvested upward by the rest of the system. I never have to remember in November what I did in March, because in March I dropped a [!staff] block in that day’s note and forgot about it.

Friday: /weekly-review

End of day Friday, after the last /stream close, I run /weekly-review. By Friday the daily notes are inputs to the weekly note.

It reads every work daily note for the week and pulls:

• Stream sections (planned vs completed, carryover, drops)
• Capacity blocks (declared/adjusted/actual hours)
• Close sections (scope assessments, fragmentation, insights)
• Perf-worthy callouts
• Journal entries
• Meeting notes

Cross-references against Jira completed-this-week, PRs merged, calendar, and the week of Oura and Fitbit data. Then it produces a weekly note with:

• A metrics table (week-over-week deltas)
• Planning accuracy (how often did the plan survive contact with the day)
• Task type throughput (deep vs shallow vs review completion rates)
• Carryover diagnosis for anything that carried 3+ days, with a classified cause and suggested action
• A “Consider Dropping” list for things that have been on multiple Streams without progress
• Health and recovery averages, with an energy-vs-output correlation
• A load signal (normal, elevated, high) when meeting load and declining health markers line up
• An impact summary that distinguishes shipped work from maintenance and admin
• The week’s perf-worthy highlights, deduped

Finally, a Monday Preload section to bridge to next week. Top priorities, carryover that matters, immediate follow-ups, risks, suggested Monday shape, and a Stream Seed. Monday morning’s /stream reads that preload and starts the next week pre-loaded with Friday’s considered judgment.

Monthly review reads the weekly notes, never the daily ones.

The Pyramid

Reviews are nested:

Annual     ← 2 half-year reviews
Half-Year  ← 2 quarterly reviews + perf-capture + goals + competencies
Quarterly  ← 3 monthly reviews + goals + decisions
Monthly    ← 4-5 weekly reviews + project state
Weekly     ← daily notes + Jira + PRs + health
Daily      ← /stream + /stream close

/review month, /review quarter, /review half, and /review year each read primarily from the level below. A monthly review never re-parses daily notes, it reads the four or five weekly reviews and synthesizes patterns invisible at the weekly level. A quarterly review reads the three monthlies and asks a different question: are we heading the right direction. Half-year reads the quarterlies and asks: can I prove my impact. Annual reads the halves and asks: what story does this year tell.

Each level answers a different question:

What this gives me at review time

Twice a year my company runs a performance cycle: a midyear check-in in July, a year-end review in November. Every cycle the self-review asks the same four questions:

1. What did you accomplish that had the biggest impact?
2. What are your opportunities to improve or grow?
3. What support will help you get there?
4. How would you rate your performance, with examples?

When I run /review half two or three weeks before the deadline, it reads both quarterly reviews for the half, the perf-capture artifacts, my running brag entries, the goals doc, the senior and staff competency rubrics, and the previous half-year review’s commitments. Then it produces:

• A 6-month narrative arc
• A competency evidence map (for each of the seven competencies, the strongest evidence at Senior and Staff level, with links)
• Goal outcomes (met, partial, unmet, with evidence)
• A highlight reel of the top 5-7 accomplishments
• A gap analysis identifying which competencies have thin Staff-level evidence and what specifically would close the gap
• Drafted answers to all four self-review questions, with links to tickets, PRs, and notes

I edit and submit. The drafts are not the final text, they are starting points sourced from real evidence I captured back when it happened, in a daily note, in March. The annual review compounds that one more level up.

Why this works (for me)

Capture happens at the moment, not at review time. The [!staff] callout I drop after a meeting on March 14 is the same artifact that ends up in November’s self-review. I’m not trying to remember anything.

Each layer reads the layer below. Nothing gets recomputed. The daily note is the only place I hand-write context, and every higher level treats it as input.

The close has no upside in flattering me, because tomorrow’s stream is reading the nudges it writes. Declared hours vs actual hours, planned tasks vs completed, insights about over-scoping that I can’t pretend not to see.

Honestly, the day-to-day part is the reason I keep running it. Starting the day with one short list, ending it knowing tomorrow will be slightly better-calibrated. The compounding into weekly, quarterly, and half-year reviews is the bonus.

The slash commands are all just SKILL.md files in ~/.claude/skills/. Mine talk to my specific tools (Obsidian, TickTick, Oura, Fitbit, Jira, GitHub), but the structure is portable. The smallest version that’s still useful is a daily note with # Stream and # Close, plus the Lake/Stream split.