Writing
·6 min read

I Automated My Daily Standup With Claude. It Reads Git Logs So I Don't Have To.

Standups are a translation problem: commit messages → accomplishment statements. That translation is high-friction, low-value work — exactly what language models are good at. I built ai-standup: one command reads git history across all my repos, sends it to Claude, and generates a professional standup in 4 seconds. Here's how it works and what it reveals about AI-native dev tooling.

developer toolscliaiworkflowengineeringanthropic

Every morning I spend about three minutes writing a standup update. What I worked on yesterday. What I'm doing today. Any blockers. Three minutes doesn't sound like much — but it's three minutes of reconstruction: pulling up git log, skimming commit messages, translating them from "feat: add SSE endpoint" into "shipped streaming API for the comparison tool." I automated all of that with a single CLI command.

The standup problem

Standups are a communication contract. You're translating raw work (commits, PRs, code changes) into human-readable progress updates for teammates or stakeholders. The challenge is that the raw material is already there — in your git history. You just have to process it.

The processing is the annoying part. git log --since="1 day ago" gives you commit messages. But commit messages are written for git history, not for people. "feat: add BM25 scoring to retrieval pipeline" is a useful commit message. As a standup bullet point it's jargon soup. The translation layer — from commit message to accomplishment statement — is where time disappears.

This is exactly what language models are good at. They can read technical commit messages and synthesize them into professional accomplishment statements. They know the difference between "I merged three commits in a repo" and "I shipped a feature." They handle the translation.

How ai-standup works

The tool is a Node.js script that does three things: collects commits, groups them by repo, sends them to Claude.

$ node ~/bin/ai-standup

📊 Found 8 commits across 3 repos (last 24h)

# 📋 Engineering Standup — Sunday, March 1, 2026

## Yesterday

- **Portfolio expansion**: Added AI Eval Lab as project #29 and updated all
  portfolio surfaces (/ask context, /stats page, /now) to reflect the new app.
- **Analytics dashboard**: Shipped /stats page with portfolio analytics, live
  GitHub activity feed, and tech stack breakdown by framework frequency.
- **System monitoring**: Expanded health monitor coverage from 19 to 32 apps
  with category-based organization.
- **Content sync**: Updated /ask chat with latest blog posts and CLI tools.
  Fixed missing content mappings in the blog router.

## Today

- Validate /stats live data and optimize query performance if needed.
- Continue shipping — iterate on the AI Eval Lab scoring engine.

## Blockers

None

## Stats

8 commits across 3 repos in the last 24h

That output — synthesized from 8 actual commits — took about 4 seconds and required zero manual work. The commits were:

  • feat: add AI Eval Lab as project #29 + update counts
  • feat: add /stats page — portfolio analytics + live GitHub activity
  • feat: expand health monitor from 19 → 32 apps
  • feat: update /ask chat with 24 blog posts, ai-changelog, AI Eval Lab
  • … and 4 more

Claude grouped related work, translated commit-speak into accomplishment-speak, and inferred reasonable next steps. The standup is better than what I would have written manually — more specific, more organized, less time.

The implementation

The script collects all git repos in my workspace directory (~/clawd), then runs git log in each one filtered to the last N hours:

function getCommitsFromRepo(repoDir, sinceHours) {
  const log = runGit(
    `git log --since="${sinceHours} hours ago" \
      --pretty=format:"%s|||%an|||%ad" \
      --date=short --no-merges`,
    repoDir
  );
  return log.split('\n').filter(Boolean).map(line => {
    const [subject, author, date] = line.split('|||');
    return { subject, author, date };
  });
}

Each repo's commits are grouped into a commitData object — repo name as key, array of commit objects as value. That structure is formatted into a prompt:

Personal-Page (4 commits):
  - feat: add /stats page — portfolio analytics + live GitHub activity
  - feat: update /ask context — 29 apps, /stats page, project-context CLI
  - feat: add ai-standup CLI — 7 tools now, update /now, /stats, /ask context
  - feat(now): update march 1 with latest projects and tools

mission-control (1 commit):
  - feat: expand health monitor from 19 → 32 apps, organized by category

ai-eval-lab (1 commit):
  - feat: AI Eval Lab — prompt evaluation with test cases and fix suggestions

The prompt gives Claude the grouped commits, the time period, a description of the desired output format, and instructions to synthesize accomplishments rather than repeat commit messages. The key instruction: "Be specific and confident. Don't hedge. Sound like a senior engineer giving a sync update."

The format is configurable. --format slack produces Slack-friendly formatting. --format linear produces clean markdown for Linear or Notion. --copy pipes to clipboard. --save writes to ~/standup-YYYY-MM-DD.md.

The broader toolkit context

This is the seventh CLI tool in my AI dev toolkit. The pattern across all seven is identical:

  1. Capture context automatically. Don't make the user paste anything. Read the git diff, the file contents, the log. The context is already there.
  2. Ask for exactly what you want. Not "summarize this" — but "generate a standup with exactly these sections, in this tone, for this audience."
  3. Stream the output. Seven of seven tools stream Claude's response token-by-token rather than waiting for the full response. The output appears immediately, which feels faster and is faster for long outputs.
  4. No external dependencies. Every tool uses Node's built-in https, child_process, and readline. Drop the script in ~/bin, make it executable, done.

The full toolkit as of March 2026:

  • ai-commit — staged diff → 3 commit messages → pick with arrow keys
  • smart-pr — branch diff → structured PR description
  • ai-explain — pipe any code → plain English explanation
  • ai-review — pre-push code review with severity ratings (🔴🟠🟡🟢)
  • ai-changelog — git log → grouped changelog by type (Features / Fixes / Refactors)
  • project-context — generates AI-ready context doc for any repo (for agent handoffs)
  • ai-standup — git commits → professional standup update in 4 seconds

What this toolchain tells you about AI-native development

Each of these tools took 1-3 hours to build. Together they've saved me far more time than they took to build. But the more interesting observation is structural: these tools didn't exist when I started building seriously in January 2026. They emerged from noticing friction in my own workflow and asking "can Claude do this?"

That question — "can Claude do this?" — is the core loop of AI-native development. You're not building applications for users (yet). You're building accelerants for your own work. Each accelerant increases your building velocity. Higher building velocity means more opportunities to discover new friction. More friction means more accelerants to build.

This is how I went from 15 apps in my first month to 29 in six weeks. Not just by working harder — but by systematically reducing the overhead cost of building. The CLI tools are one layer. Matua (my persistent AI agent that does overnight builds) is another. The project-context tool feeds structured context into agent handoffs. The ai-changelog tool turns git history into release notes in one command.

The standup tool is small. But it's emblematic of the mindset: notice the friction, identify the available context, write the prompt, ship the tool. The question isn't whether AI can help — it almost always can. The question is whether you stop to ask it.

Try it

The standup tool is straightforward to adapt to your own workflow. Run it in any directory with git repos and an Anthropic API key. The logic is simple enough that you can modify the prompt to fit your team's standup format in ten minutes.

All seven tools are in my portfolio — see the Stats page for the full toolkit description. The pattern is the same in all of them. Once you've built one, building the next takes half the time.

Back to Writing