Skip to content

A workday with Claude Code

  1. Design planner
    1. Start a design spec extractor
    2. Brief a prototype builder
    3. Ask the spec tab for a fidelity review
    4. Send the fix round back for a re-gate
    5. Close the spec tab, send the last fixes
    6. Verify fix round three and its media
  2. Morning triage
    1. Collect urgent tickets from tracker and chat
    2. Start two investigations in new tabs
    3. Post a short triage report to my phone
    4. Ship the ready tickets, one tab each
    5. Allowlist is set, tell the ship tab to merge
    6. Hand the third PR to a new ship tab
  3. Move planner
    1. Check a bulk move ticket against the code
    2. Hand a read-only code trace to a child
    3. Read the trace report
    4. Write the sign-off plan page
    5. Screenshot it, scan for secrets, push
    6. Plan host unreachable, flag it to the parent
  4. Schedule planner
    1. Investigate automatic schedule application
    2. Start two code tracers, one per service
    3. Read both trace reports
    4. Chart the results, build the plan page
    5. Save the findings to memory. Done
  5. Code trace
    1. Trace the bulk move path, read-only
    2. Find the server-side flag for the overview
    3. Write trace notes, verify line cites
  6. Prototype
    1. Build a local prototype with mock data
    2. Write tests for the review steps
    3. Commit the prototype locally
    4. Re-seed, re-record stills and video
    5. Commit fix round one
    6. Commit fix round three
  7. Editor ship
    1. Merge main, resolve one conflict
    2. Start an evidence recorder
    3. Open PR, move the ticket to review
    4. Start an adversarial reviewer
    5. Approved. Hold merge for a flag allowlist
    6. Merged
  8. Editor evidence
    1. Find a free dev slot and wait for the lock
    2. Stop an idle watcher to free RAM
    3. Record the before and after flows
    4. Build a labelled mp4 and gif
    5. Splice the recording into the PR body
    6. Release the slot. Done
  9. Practice ship
    1. Merge main, resolve three spec conflicts
    2. Start a gates runner and an evidence recorder
    3. Open PR, move the ticket to review
    4. Add guards and specs from the review, push
    5. Ask for approval, arm squash auto-merge
    6. Merged
  10. Practice review
    1. Pull existing comments to skip duplicates
    2. Post three inline findings
    3. Post the summary and read it back
  11. Editor review
    1. Fetch the diff and existing comments
    2. Start a second-model challenge
    3. Trace every reader of the editor preference
    4. Post one inline finding
    5. Second model failed auth, post a solo summary
  12. Cron triage
    1. Cron run: collect urgent tickets
    2. Check the pick is not already taken
    3. Start one investigation in a new tab
    4. Send the plan's open questions to my phone
    5. Retry the plan push. Done
  13. Find bar plan
    1. Check prior art for an in-page find bar
    2. Trace the find shortcut and highlight code
    3. Check open PRs that touch the same files
    4. Write the plan page, check for em dashes
    5. Screenshot the plan at phone width
    6. Plan ready for sign-off
  14. PR reviewer
    1. Review a teammate's PR in a clean worktree
    2. Run its specs on a scratch database
    3. Write a spec to probe an edge case
    4. Build a review page, screenshot it
    5. Hold approval: specs pass, scope gaps
  15. Panel ship
    1. Merge main into the open PR
    2. Start gates, evidence and review tabs
    3. Write failing specs for two findings
    4. Fix both, run red then green gates
    5. Reply to threads, post the round summary
    6. Start review round three
  16. Panel review
    1. Review round two, diff since round one
    2. Start a second-model challenge
    3. Run the merged test suites under a lock
    4. Post two inline findings
    5. Post the round summary
sessions
30
commits
12
PRs merged
2