Scrum Master

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

1. 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": [...]
   }
   

2. CSV:

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

3. YAML:

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

4. 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)

3. 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

1. 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)
2. Accurate Status Updates: Update story status daily (automate if possible)
3. Blocked Item Tracking: Always document why items are blocked and who can unblock
4. Sprint Boundaries: Never change sprint scope after day 3 (exception: critical bugs)

Workflow Integration

1. Daily Standups: Generate lightweight summary every morning (automated)
2. Sprint Planning: Use priority scoring to allocate top 80% of capacity
3. Mid-Sprint Check: Run health score on day 5-7 to catch issues early
4. Retrospectives: Generate within 24 hours of sprint end while feedback is fresh

Token Efficiency

1. Progressive Disclosure: Start with summary, offer details on request
2. Conditional Alerts: Only show risks if they exist (don't report "No issues")
3. Lazy Calculation: Compute detailed metrics only when asked
4. Caching: Reuse calculations across multiple report types

Team Adoption

1. Start Simple: Begin with daily standups, add complexity gradually
2. Customize Thresholds: Adjust health score weights based on team values
3. Automate Inputs: Set up CI/CD to export tool data automatically
4. 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:

1. Go to https://api.slack.com/messaging/webhooks
2. Create app and activate Incoming Webhooks
3. Add webhook to workspace and select channel
4. Copy webhook URL

Microsoft Teams:

1. Open Teams channel
2. Click "..." → Connectors → Incoming Webhook
3. Configure webhook with name
4. 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

Scrum Master v1.2 - Enhanced Workflow

🔄 Workflow

Kaynak: Scrum Guide 2020 & Mountain Goat Software (Mike Cohn)

Aşama 1: Sprint Preparation (Planning)

• Definition of Ready (DoR): Story'nin sprinte alınabilmesi için net kriterler belirle (INVEST: Independent, Negotiable, Valuable, Estimable, Small, Testable).
• Capacity Check: Tatil, hastalık ve toplantı sürelerini düşerek gerçekçi kapasiteyi hesapla.
• Goal Setting: Sadece "iş listesi" değil, ulaşılabilir bir "Sprint Goal" belirle.

Aşama 2: Sprint Execution (Daily & Removal)

• Blocker Management: Standup'ta duyulan her engeli anında "Impediment Log"a ekle ve sahiplen.
• Burndown Hygiene: Burndown chart'ın gerçeği yansıttığını kontrol et. "Done" olmayan işleri erken teşhis et.
• Scope Protection: Sprint ortasında gelen yeni işleri "Scope Creep" olarak işaretle ve Product Owner ile müzakere et.

Aşama 3: Sprint Closing (Review & Retro)

• Definition of Done (DoD): Sadece kodlanmış değil, test edilmiş ve deploy edilebilir işleri "Bitti" say.
• Actionable Retro: Retrospektiften "daha iyi iletişim kuralım" gibi soyut değil, "her sabah 10:15'te code review saati yapalım" gibi somut aksiyonlar çıkar.
• Velocity Tracking: Takımın ortalama hızını güncelle ve gelecek planlamasında kullan.

Kontrol Noktaları