Automate Daily Standup Reports with AI CLI Agents

The Morning Ritual That Wastes Your Time

It is 9:47 AM. Your standup starts in 13 minutes. You open GitHub to figure out what you merged yesterday. Then Slack, to see if anyone flagged something overnight. Then Linear, to check which tickets moved. You copy bits from each app, paste them into a message, reword things so they sound coherent, and post it. Three browser tabs. Fifteen minutes. Every single morning.

Now picture this instead: you type one command in your terminal. Ten seconds later, a structured report appears -- what you shipped, what you are working on, what is blocking you. The data came from GitHub, Slack, and Linear automatically. You glance at it, hit send, and get back to real work.

That is what you will build in this article.

By the end, you will have:

• Three MCP server connections (GitHub, Slack, Linear) configured in a single .mcp.json
• A CLAUDE.md standup workflow that tells the agent exactly how to aggregate and format your update
• A structured output template the agent follows every time
• A repeatable command you can alias or drop into a cron job

The total setup takes about 25 minutes. After that, your daily standup prep drops from 15 minutes to zero.

Why Standup Reports Are a Perfect Automation Target

Think of a standup report like a receipt at a restaurant. The meal already happened. The prices are already in the system. The receipt just assembles information that already exists into a standard format. Nobody writes a receipt by hand.

Your standup is the same. The commits are in GitHub. The messages are in Slack. The tickets are in Linear. The report is just retrieval and formatting. That is exactly what MCP tool chains do well -- they are bridges between your terminal and the outside world, letting the agent reach into each service, grab what it needs, and assemble the result.

Three properties make this ideal for automation:

1. Deterministic inputs. The data sources are the same every day: commits since yesterday, active tickets, unread mentions.
2. Structured output. The report format never changes: done, doing, blocked. Think of it like filling in a form instead of writing a letter.
3. Low stakes. A slightly imperfect standup draft is trivially fixable. You review it for 10 seconds before posting.

Prerequisites

You need these installed and authenticated:

• Claude Code v2.1+ with API access
• Node.js 18+ (for MCP servers)
• GitHub CLI (gh) authenticated with your account
• A Slack workspace where you have a bot token (or use an existing MCP server)
• A Linear account with an API key

If you have never built an MCP server before, the Build Your First MCP Server tutorial covers the fundamentals in 20 minutes. This article assumes you understand how MCP tool registration and .mcp.json configuration work.

Step 1: Configure MCP Server Connections

MCP servers are bridges between Claude Code and your external services. Each bridge handles one service. You need three bridges: one for GitHub, one for Slack, one for Linear.

You do not need to build them from scratch. The MCP ecosystem already has production-grade servers for all three. You configure them in your project's .mcp.json:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    },
    "slack": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-your-bot-token",
        "SLACK_TEAM_ID": "T01ABCDEF"
      }
    },
    "linear": {
      "command": "npx",
      "args": ["-y", "@linear/mcp-server"],
      "env": {
        "LINEAR_API_KEY": "lin_api_your_key_here"
      }
    }
  }
}

Alternatively, register them globally so they are available across all your projects:

claude mcp add github --scope user -- npx -y @modelcontextprotocol/server-github
claude mcp add slack --scope user -- npx -y @anthropic/mcp-server-slack
claude mcp add linear --scope user -- npx -y @linear/mcp-server

After adding, restart Claude Code and run /mcp to verify all three servers show green status.

Important: Store tokens in environment variables, not in .mcp.json directly. Use a .env file or your shell profile to export them. The example above shows inline values for clarity only.

Step 2: Understand the Tool Chain

When you ask Claude Code for a standup report, it does not make one big call. It executes a chain of smaller calls, like a researcher visiting three different libraries and then writing a summary.

Here is what happens under the hood:

1. GitHub tool call -- The agent calls search_repositories or list_commits with a date filter for the past 24 hours, scoped to your username. It also calls list_pull_requests filtered to PRs you authored or reviewed.

2. Slack tool call -- The agent calls search_messages to find messages mentioning your username or in channels you follow, filtered to the last 24 hours.

3. Linear tool call -- The agent calls list_issues filtered to issues assigned to you with status "In Progress", "Done" (completed yesterday), or "Blocked".

4. Aggregation -- The agent receives structured JSON from all three sources. It cross-references: a merged PR maps to a "Done" item, an in-progress Linear ticket maps to "Doing", a Slack thread asking for your review maps to a potential blocker. Think of this step as the agent laying all the puzzle pieces on the table and connecting the ones that match.

5. Structured output -- The agent formats everything into the standup template.

This is a tool_use chain, not a single tool call. Each step depends on the previous results. Claude Code handles the orchestration automatically. You do not write any glue code. You define the tools (via MCP servers) and the desired output format (via CLAUDE.md). The agent figures out the execution order.

Step 3: Write the CLAUDE.md Standup Workflow

CLAUDE.md is like a briefing document you hand to an assistant before they start working. The more specific you are, the better the output. Add this block to your project's CLAUDE.md (or ~/.claude/CLAUDE.md for global use):

## Standup Report Workflow

When I ask for a standup report, follow this exact sequence:

### Data Collection
1. GitHub: fetch my commits and merged PRs from the last 24 hours.
   Use my GitHub username: YOUR_USERNAME
2. Slack: search for messages mentioning me or in my DMs from the last 24 hours.
   Focus on: action items, questions directed at me, decisions made.
3. Linear: list my assigned issues. Group by status: Done (completed yesterday),
   In Progress, Blocked.

### Cross-Reference Rules
- If a merged PR references a Linear ticket ID (e.g., PROJ-123), link them.
- If a Slack thread discusses a PR or ticket, note the context.
- If an In Progress ticket has no commits in 48+ hours, flag it as at risk.

### Output Format
Use this exact structure:

**Standup -- [today's date]**

**Done:**
- [ticket-id] Description (PR #number if applicable)

**Doing:**
- [ticket-id] Description -- expected completion: [date or "today"]

**Blocked:**
- [ticket-id] Description -- blocked by: [reason]
  Action needed: [what would unblock it]

**Mentions requiring response:**
- [channel/person]: summary of what they need

### Rules
- Keep each bullet to one line.
- Use ticket IDs as prefixes, not PR numbers (PRs are supplementary detail).
- If no blockers exist, write "No blockers" instead of omitting the section.
- Do not editorialize. Report facts only.

Replace YOUR_USERNAME with your actual GitHub handle. If you work across multiple GitHub orgs, list them explicitly so the agent scopes its search correctly.

This workflow configuration follows the same CLAUDE.md writing principles that apply to any agent task: be specific about inputs, define the output structure, and set clear rules for edge cases.

Step 4: Run It

Open your terminal, launch Claude Code, and type:

generate my standup

The first time, Claude Code will ask for permission to call each MCP tool. Approve them. On subsequent runs, the approvals are cached -- like a library card that gets you in without showing ID every visit.

You will see the agent work through the chain: GitHub query, Slack search, Linear fetch, then the formatted report. Total time is typically 5-12 seconds depending on your data volume.

The output looks like this:

**Standup -- 2026-03-22**

**Done:**
- PROJ-142 Add rate limiting to /api/upload endpoint (PR #387)
- PROJ-139 Fix timezone offset in scheduled notifications

**Doing:**
- PROJ-145 Migrate user preferences to new schema -- expected completion: today
- PROJ-148 Write integration tests for payment webhook -- expected completion: Monday

**Blocked:**
- PROJ-151 Deploy staging environment for OAuth flow -- blocked by: DevOps
  team has not provisioned the new staging cluster yet
  Action needed: follow up with @infrastructure in #devops

**Mentions requiring response:**
- #frontend (Sarah): asked about the breaking change in the Button component API
- DM (James): requested review on PR #391

Step 5: Automate the Trigger

Once the output looks right after a few days of manual runs, you can remove yourself from the loop entirely.

Option A: Shell Alias

Add to your .zshrc or .bashrc:

alias standup='claude -p "generate my standup"'

Now standup in any terminal produces the report.

Option B: Cron Job

Run it before your standup meeting and pipe the output to clipboard:

# macOS -- runs at 9:45 AM weekdays
45 9 * * 1-5 cd ~/your-project && claude -p "generate my standup" | pbcopy

Option C: Pipe to Slack

Post the report directly to your standup channel:

claude -p "generate my standup" | curl -X POST \
  -H "Authorization: Bearer $SLACK_BOT_TOKEN" \
  -H "Content-Type: application/json" \
  -d "{\"channel\": \"C01STANDUP\", \"text\": \"$(cat -)\"}" \
  https://slack.com/api/chat.postMessage

Tuning the Output

After a few days of use, you will notice patterns worth adjusting. This is normal. Think of the first version as a rough draft -- it captures the right information, and now you refine the presentation.

Too verbose. Add a rule to CLAUDE.md: Keep the entire report under 15 lines. Summarize minor commits into a single "misc" bullet.

Missing context. If the agent misses a data source, check /mcp to verify the server is connected. A disconnected MCP server is like a bridge with the drawbridge up -- the agent simply cannot cross it. Missing tools are the number one cause of incomplete reports.

Wrong ticket mapping. If your commit messages do not include ticket IDs, the agent cannot cross-reference. The fix is in your commit workflow, not in the agent config. Start including ticket IDs in commit messages (e.g., git commit -m "PROJ-142: add rate limiting").

Multiple projects. If you work across several repos, specify them in the CLAUDE.md data collection step: GitHub: fetch commits from repos org/repo-a, org/repo-b, org/repo-c.

Extending the Pattern

The standup workflow is a template. The same MCP tool chain pattern -- connect to data sources, retrieve, aggregate, format -- works for:

• Weekly status reports -- expand the time window to 7 days, group by epic instead of individual ticket
• Sprint retrospectives -- pull completed tickets for the sprint, calculate velocity, list carry-over items
• Handoff notes -- when going on vacation, generate a summary of all in-progress work with context for each item

Each variation requires only a new section in CLAUDE.md. The MCP server connections stay the same. You have already built the bridges. Now you just change what you carry across them.

The Multi-Pane Advantage

When you are first setting up this workflow, you are debugging three MCP connections simultaneously. One server might fail to authenticate. Another might return unexpected data formats. A third might be slow to initialize.

Imagine trying to debug a plumbing problem with all the pipes hidden behind a wall. That is what single-terminal debugging feels like. The productive setup is to see everything at once: your CLAUDE.md in one pane, the Claude Code session calling tools in another, and a third pane tailing MCP server logs (npx @modelcontextprotocol/inspector). When something fails, you see the error immediately without switching windows.

Once the workflow is stable, you can switch the layout: standup output in the main pane, raw GitHub data in a side pane for spot-checking, and Slack in a third for immediate follow-up on the mentions the report surfaced.

If you work across multiple projects that each have their own standup cadence, workspace switching lets you flip between project contexts -- each with its own .mcp.json, CLAUDE.md, and terminal layout -- without tearing down and rebuilding your session.

Recap

The standup report is a solved problem. The data already exists in GitHub, Slack, and Linear. MCP servers give Claude Code direct access to that data -- they are the bridges, and the data is already on the other side. A CLAUDE.md workflow section tells the agent how to aggregate and format it. The result is a 10-second standup report that used to take 15 minutes of tab-switching and copy-pasting.

The total setup: three MCP server entries in .mcp.json, one workflow block in CLAUDE.md, and one command to run it. After that, the 15 minutes you reclaim every morning compounds into real time -- roughly 60 hours per year that you get back for actual engineering work.