Scrum Master Agent

A production-ready Scrum Master assistant designed for SaaS startups and application engineering teams. This skill provides intelligent sprint analytics, capacity planning, backlog prioritization, and actionable insights with token-efficient, context-aware output formatting.

Capabilities

Sprint Management

• Sprint Planning: Capacity-based story allocation with velocity tracking

• Backlog Grooming: Priority scoring with effort/value/risk analysis

• Sprint Health Monitoring: Real-time burndown tracking with predictive alerts

• Velocity Analysis: Historical trend analysis with forecasting

Team Operations

• Daily Standups: Ultra-lightweight progress summaries (50-100 tokens)

• Capacity Planning: Team availability calculation with holiday/PTO handling

• Sprint Retrospectives: Action items extraction with sentiment analysis

• Risk Detection: Automated alerts for scope creep, velocity drops, blocked tasks

Multi-Tool Integration

• Linear: Native JSON import with Linear-specific field mapping

• Jira: REST API adapter with custom field support

• GitHub Projects: GraphQL integration with issue/PR tracking

• Azure DevOps: Work item queries with sprint hierarchy

Notification Integration

• Slack Notifications: Token-efficient webhook integration with rich block formatting

• MS Teams Notifications: Adaptive Card integration for Microsoft Teams channels

• Optional/Disabled by Default: No setup required to use skill, notifications opt-in

• User Choice: Select Slack or Teams via configuration or environment variables

• Concise Summaries: 50-100 token notifications with top 3 risks only

Intelligent Output Design

• Context Detection: Automatically adapts to Claude AI Desktop vs Claude Code

• Token Efficiency: Summary-first approach with progressive disclosure

• Conditional Alerts: Only shows warnings/risks when they exist

• Format Optimization: Markdown tables for Claude AI, ASCII charts for CLI

Input Requirements

Supported Formats

JSON (Recommended):

{ "tool": "linear|jira|github|azure", "sprint_name": "Sprint 45", "start_date": "2025-11-05", "end_date": "2025-11-19", "team_capacity": 80, "stories": [...] }

CSV:

story_id,title,points,status,assignee,priority,blocked STORY-123,User login,5,In Progress,Alice,High,false

YAML:

sprint: name: "Sprint 45" team: - name: Alice capacity: 40 - name: Bob capacity: 40

Tool-Specific Exports:

• Linear: Export to JSON from project view

• Jira: Use REST API or CSV export

• GitHub Projects: GraphQL query or CSV export

• Azure DevOps: Work Item Query Results

Required Fields

• Sprint metadata: name, start_date, end_date, team_capacity

• Stories: id, title, points, status, assignee

• Optional: priority, blocked, dependencies, labels, created_date

Data Quality

• Story points must be numeric (Fibonacci or T-shirt sizes)

• Dates in ISO 8601 format (YYYY-MM-DD)

• Status values normalized to: Todo, In Progress, In Review, Done

• Team capacity in story points per sprint

Output Formats

1. Daily Standups (Ultra-Lightweight)

Token Budget: 50-100 tokens

🚀 Sprint 45 - Day 7/10

✅ Completed: 3 stories (13 pts) 🔄 In Progress: 5 stories (21 pts) ⚠️ Blocked: 1 story (5 pts) - Needs DB access

Velocity: On track (65% complete, 70% time elapsed)

2. Sprint Planning (Moderate Detail)

Token Budget: 200-500 tokens

📊 Sprint 45 Planning Summary

Capacity: 80 pts | Committed: 75 pts | Buffer: 5 pts

High Priority (35 pts):

• STORY-123: User authentication (8 pts)
• STORY-124: Payment integration (13 pts)
• STORY-125: Dashboard redesign (8 pts)

Recommendations:

1. P0: Address DB access blocker

2. P1: Reduce scope if velocity drops below 85%

3. P2: Consider splitting STORY-124 (13 pts is risky)

4. Sprint Review (Full Report)

Token Budget: 500-1000 tokens

Includes:

• Velocity trends (ASCII chart for CLI, table for Claude AI)

• Burndown analysis with predictive completion date

• Team performance metrics (throughput, cycle time)

• Risk alerts (conditional - only if issues exist)

• Prioritized recommendations (P0/P1/P2)

4. Retrospective Analysis

Token Budget: 300-500 tokens

🔍 Sprint 45 Retrospective

What Went Well:

• 95% velocity achievement
• Zero production incidents
• Early story completion (3 days before deadline)

What Needs Improvement:

• 2 stories blocked for >2 days
• Code review delays (avg 18 hours)

Action Items: [P0] Establish DB access protocol (Owner: Alice, Due: 11/12) [P1] Set 8-hour code review SLA (Owner: Bob, Due: 11/15) [P2] Add automated status updates (Owner: Team, Due: 11/20)

5. Optional JSON Export

For tool integration and dashboards:

{ "sprint": "Sprint 45", "metrics": { "velocity": 75, "completion_rate": 0.95, "cycle_time_avg": 3.2 }, "risks": [...], "recommendations": [...] }

How to Use

Quick Invocations

Daily Standup:

@scrum-master-agent

Generate a quick standup summary for Sprint 45 using the attached Linear export.

Sprint Planning:

@scrum-master-agent

Help me plan Sprint 46. Team capacity is 80 points. Here's the backlog (CSV attached). Prioritize based on effort, value, and risk.

Burndown Analysis:

@scrum-master-agent

Analyze Sprint 45 burndown. Are we on track? When will we likely finish? Attached: Jira sprint export (JSON)

Retrospective:

@scrum-master-agent

Generate retrospective report for Sprint 45. Focus on blockers and cycle time. Attached: GitHub Projects export (CSV)

Capacity Planning:

@scrum-master-agent

Calculate team capacity for next sprint. Alice is on PTO for 3 days, Bob has 2 days of meetings. Team size: 4 engineers (40 pts each normally).

Advanced Usage

Multi-Tool Comparison:

Compare velocity trends across last 3 sprints using Linear data for Sprint 43-44 and Jira data for Sprint 45.

Risk Analysis:

Identify high-risk stories in the backlog. Flag anything with >8 points, blockers, or missing dependencies.

Custom Metrics:

Calculate sprint health score based on: velocity (40%), burndown trend (30%), blocked items (20%), team morale (10%).

Scripts

Core Modules

• parse_input.py : Multi-format parser (JSON/CSV/YAML) with tool-specific adapters

• tool_adapters.py : Integration adapters for Linear, Jira, GitHub, Azure DevOps

• calculate_metrics.py : All 6 metric calculations (velocity, burndown, capacity, priority, health, retrospective)

• detect_context.py : Environment detection (Claude AI Desktop vs Claude Code)

• format_output.py : Context-aware report generation with token efficiency

• notify_channels.py : Slack and MS Teams webhook integrations (optional)

• prioritize_backlog.py : Priority scoring with effort/value/risk analysis

Calculation Details

1. Velocity Analysis:

• Historical average over last 3-5 sprints

• Trend analysis (improving/declining/stable)

• Forecasting for next sprint

2. Burndown Tracking:

• Daily story point completion

• Ideal burndown line calculation

• Predictive completion date (linear regression)

3. Capacity Planning:

• Team availability calculation (PTO, holidays, meetings)

• Story point allocation

• Buffer recommendation (10-20% of capacity)

4. Priority Scoring:

• Effort: Story points (normalized 0-10)

• Value: Business impact (High=10, Medium=5, Low=2)

• Risk: Blockers, dependencies, complexity (0-10)

• Formula: priority_score = (value * 2 + (10 - effort) + (10 - risk)) / 4

5. Sprint Health Score:

• Velocity: Actual vs committed (40% weight)

• Burndown: Actual vs ideal (30% weight)

• Blocked Items: Count and duration (20% weight)

• Team Morale: Optional sentiment input (10% weight)

• Scale: 0-100 (90+ = Excellent, 70-89 = Good, 50-69 = Fair, <50 = At Risk)

6. Retrospective Analysis:

• Completed vs committed stories

• Blocked item analysis (count, duration, causes)

• Cycle time metrics (avg time from start to done)

• Action item extraction from retro notes

Best Practices

Data Quality

• Consistent Story Pointing: Use Fibonacci (1,2,3,5,8,13) or T-shirt sizes (XS=1, S=2, M=3, L=5, XL=8)

• Accurate Status Updates: Update story status daily (automate if possible)

• Blocked Item Tracking: Always document why items are blocked and who can unblock

• Sprint Boundaries: Never change sprint scope after day 3 (exception: critical bugs)

Workflow Integration

• Daily Standups: Generate lightweight summary every morning (automated)

• Sprint Planning: Use priority scoring to allocate top 80% of capacity

• Mid-Sprint Check: Run health score on day 5-7 to catch issues early

• Retrospectives: Generate within 24 hours of sprint end while feedback is fresh

Token Efficiency

• Progressive Disclosure: Start with summary, offer details on request

• Conditional Alerts: Only show risks if they exist (don't report "No issues")

• Lazy Calculation: Compute detailed metrics only when asked

• Caching: Reuse calculations across multiple report types

Team Adoption

• Start Simple: Begin with daily standups, add complexity gradually

• Customize Thresholds: Adjust health score weights based on team values

• Automate Inputs: Set up CI/CD to export tool data automatically

• Iterate: Refine priority scoring based on team feedback

Limitations

Data Requirements

• Requires structured sprint data (not suitable for ad-hoc work)

• Story points must be assigned (can't prioritize unpointed stories)

• Historical data needed for velocity trends (minimum 3 sprints)

Accuracy Considerations

• Priority scoring is heuristic-based, not ML-driven (no predictive analytics)

• Burndown predictions assume linear velocity (doesn't account for holidays, blockers)

• Health score is subjective and depends on accurate weight configuration

Scope Boundaries

• Does NOT: Integrate directly with tools (requires exports)

• Does NOT: Send notifications or update tool state (read-only)

• Does NOT: Replace Scrum Master judgment (augments decision-making)

Tool-Specific Notes

• Linear: Requires manual JSON export (no API key support in this version)

• Jira: Custom fields may need mapping in tool_adapters.py

• GitHub Projects: Beta GraphQL API may change (adapter may need updates)

• Azure DevOps: Work item hierarchy can be complex (flatten in export)

When NOT to Use This Skill

• Kanban workflows: Skill is optimized for Scrum sprints (not continuous flow)

• Non-software projects: Priority scoring assumes software development context

• Single-person teams: Overhead not justified for solo developers

• Ad-hoc work: Requires structured sprint planning and tracking

Installation

Claude Code (Recommended)

cp -r scrum-master-agent ~/.claude/skills/

Claude AI Desktop

Drag the scrum-master-agent.zip file into Claude Desktop.

Claude API

Use the /v1/skills endpoint to upload the skill package.

Notification Setup (Optional)

Notifications are disabled by default and completely optional. The skill works perfectly without any notification setup.

Option 1: Configuration File (Recommended)

Copy example config

cp config.example.yaml config.yaml

Edit config.yaml with your webhook URLs

Set enabled: true

Choose channel: slack or teams

Option 2: Environment Variables

export NOTIFY_ENABLED=true export NOTIFY_CHANNEL=slack # or teams export SLACK_WEBHOOK_URL=https://hooks.slack.com/services/YOUR/WEBHOOK/URL export TEAMS_WEBHOOK_URL=https://outlook.office.com/webhook/YOUR/WEBHOOK/URL

Getting Webhook URLs:

Slack:

• Go to https://api.slack.com/messaging/webhooks

• Create app and activate Incoming Webhooks

• Add webhook to workspace and select channel

• Copy webhook URL

Microsoft Teams:

• Open Teams channel

• Click "..." → Connectors → Incoming Webhook

• Configure webhook with name

• Copy webhook URL

Using Notifications:

@scrum-master-agent

Generate daily standup summary and send notification to Slack.

Notifications are token-efficient (50-100 tokens max) with:

• Sprint name and status

• Velocity and health metrics

• Top 3 risks only (conditional)

• Rich formatting (Slack blocks, Teams Adaptive Cards)

Version

Version: 1.1.0 (with Notification Support) Last Updated: 2025-11-05 Author: Claude Code Skills Factory License: MIT

Support

For issues, feature requests, or contributions, see the skill's GitHub repository or contact the Skills Factory maintainers.