I Got Tired of Writing Standups Manually, So I Built a Claude Code Slash Command

A weekend project that turned into something useful — and what I learned building it

I'll be honest — this started as a personal annoyance, not a grand plan.

Every morning I'd spend a few minutes doing the same thing: opening Jira, scrolling through yesterday's tickets, checking my git log, trying to remember the thing I spent two hours on that I never actually committed. Then writing a standup that was always a little off.

It's not a big problem. But it's a daily one.

I'd been using Claude Code for a few weeks and noticed it had this feature called slash commands — custom markdown files you drop in ~/.claude/commands/ that Claude picks up automatically. The community had built some really useful ones for git workflows, code review, PR automation.

Nobody had built one for standups. So I thought I'd try.

This is what I built, how it works, and what surprised me along the way.

What /standup Does

Type /standup in any Claude Code session and it:

• Pulls your git commits since yesterday


• Reads Claude Code's own session files for everything you worked on — including sessions that crashed before you saved anything


• Optionally connects to Jira via the Atlassian MCP to pull your ticket status


• Formats everything into Yesterday / Today / Blockers


• Asks if you want to post back to Jira

The output looks like this:

📅 STANDUP UPDATE — March 1, 2026



YESTERDAY:

• Fixed authentication timeout bug (commit: ba28b5c)

• Investigated schema drift in orders pipeline — no commit yet

• Reviewed PR #47 for data contract changes



TODAY:

• PIPELINE-124: incremental load strategy (In Progress)

• Complete schema drift investigation



BLOCKERS:

• None



---

Post to Jira? (y/n):

The TODAY section is AI-inferred from context — always worth a quick review before sharing.

The Part That Surprised Me: Session Files

I knew git log would work for commits. The interesting discovery was Claude Code's session files.

Claude Code writes every session to ~/.claude/projects/<project-hash>/*.jsonl — and it writes continuously, not on close. Which means if your session crashes or you kill the terminal, the work is still there.

!find ~/.claude/projects -name "*.jsonl" -newer ~/.standup_last_run -type f

This turned out to be the most useful part of the whole command. Git tells you what you shipped. Session files tell you what you actually worked on — the debugging rabbit holes, the documentation you read, the thing you tried that didn't work. That context is exactly what makes a standup useful and it's usually what gets left out.

Install

git clone https://github.com/AyanPutatunda/claude-standup.git

mkdir -p ~/.claude/commands

cp claude-standup/commands/standup.md ~/.claude/commands/standup.md

Open Claude Code in any git repo. Type /standup. That's it — no npm, no config, no API keys.

Jira integration is optional. If you want it:

claude mcp add --transport sse atlassian https://mcp.atlassian.com/v1/sse

If you don't, the command works fine with just git and session data.

One Thing I Had to Fix After Testing

First version had a bug: if you ran /standup twice in the same day, the second run returned nothing. The timestamp anchor was too precise — it marked the exact time of the last run, so a second run 5 minutes later found no new commits.

The fix was simple: store the date instead of the datetime.

# Before — stored full timestamp, too aggressive

!echo $(date -u +%Y-%m-%dT%H:%M:%SZ) > ~/.standup_last_run



# After — store date only, resets at midnight

!echo $(date +%Y-%m-%d) > ~/.standup_last_run

Now you can run it as many times as you want during the day and always get the full picture. Small thing but it matters for daily use.

How I Built It (The Interesting Part)

I used Claude Code's experimental Agent Teams feature — something I'd read about but never tried.

The idea: the command has four independent concerns. Git data collection. Session file parsing. Jira integration. Output formatting. Each could be researched and built in parallel without stepping on each other.

I enabled agent teams in settings.json:

{ "env": { "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1" } }

Then told Claude to spawn four specialist agents simultaneously — one per concern, each writing to its own file. An orchestrator assembled the final command when all four finished.

I don't know if this was the "right" way to do it. But it was fast, and each agent produced noticeably better output because it wasn't context-switching between four different problem domains.

What's Next

A few things I want to add:

• 
  /retro — same approach for sprint retrospectives


• 
  /debt — technical debt audit from TODOs and stale dependencies


• 
  /context-handoff — end-of-session summary for async teams

If any of these would be useful to you, the repo is open and PRs are welcome. Especially interested in format variants — every team does standups slightly differently and I've only built the one my team uses.

github.com/AyanPutatunda/claude-standup

If you try it and something breaks, open an issue. If it works, a ⭐ helps other people find it.