scrum

name	Scrum
description	Agile project management framework for iterative software development with sprints, roles, and ceremonies
license	MIT
compatibility	["Python","JavaScript","Java","Go","All Agile Teams"]
audience	Software Developers, Product Owners, Scrum Masters
category	software-development

Scrum

What I Do

I provide comprehensive guidance on implementing Scrum, the most popular Agile framework for managing complex software projects. Scrum structures work into time-boxed iterations called sprints (typically 2-4 weeks), enabling teams to deliver working software incrementally while continuously inspectinG and adapting their process. I cover all Scrum artifacts, events, and roles, helping teams transition from traditional waterfall methodologies to iterative, incremental development that embraces change and maximizes value delivery.

When to Use Me

Use Scrum when your software project has uncertain or evolving requirements, requires frequent feedback loops, needs to deliver value incrementally, or involves complex problem-solving where upfront planning is difficult. Scrum is ideal for startups building new products, enterprise teams modernizing legacy systems, and any development effort where customer needs might change during development. Avoid Scrum for very small, well-defined projects with fixed requirements where the overhead of Scrum ceremonies would outweigh the benefits.

Core Concepts

• Sprints: Time-boxed iterations (usually 2-4 weeks) where a potentially releasable increment is created
• Product Backlog: Prioritized list of features, bugs, and improvements maintained by the Product Owner
• Sprint Backlog: Subset of the Product Backlog that the team commits to completing during a sprint
• Scrum Roles: Product Owner (value maximization), Scrum Master (process facilitation), Development Team (cross-functional builders)
• Sprint Planning: Meeting at sprint start to determine what can be delivered and how it will be achieved
• Daily Standup: 15-minute daily sync where team members share progress, plans, and blockers
• Sprint Review: Demo of completed work to stakeholders for feedback collection
• Sprint Retrospective: Team reflection meeting to identify and implement process improvements
• Definition of Done: Shared understanding of criteria that must be met for work to be considered complete
• Velocity: Historical measure of work completed per sprint used for capacity planning

Code Examples

from dataclasses import dataclass
from datetime import datetime
from typing import List, Optional
from enum import Enum

class StoryPointEstimate(Enum):
    """Fibonacci-like story point scale for effort estimation"""
    ONE = 1
    TWO = 2
    THREE = 3
    FIVE = 5
    EIGHT = 8
    THIRTEEN = 13
    TWENTY_ONE = 21

@dataclass
class UserStory:
    """Represents a user story in the Product Backlog"""
    id: str
    title: str
    description: str
    priority: int  # 1 = highest priority
    story_points: Optional[StoryPointEstimate]
    acceptance_criteria: List[str]
    status: str = "TODO"
    assignee: Optional[str] = None

    def meets_definition_of_done(self) -> bool:
        """Check if all acceptance criteria are met"""
        return all(criterion.startswith("[x]") for criterion in .acceptance_criteria)


 :
    
    name: 
    start_date: datetime
    end_date: datetime
    goals: []
    backlog: [UserStory]

     () -> :
        
        delta = .end_date - datetime.now()
         (, delta.days)

     () -> :
        
        total_points = (s.story_points.value  s  .backlog  s.story_points)
        completed_points = (
            s.story_points.value  s  .backlog
             s.story_points  s.status == 
        )
         (completed_points / total_points * )  total_points >   

 :
    
     ():
        .name = name
        .product_owner = product_owner
        .scrum_master = scrum_master
        .developers = developers
        .velocity_history: [] = []

     () -> :
        
        developers_count = (.developers)
        hours_per_day =   
        hours_per_point =   
        available_days = sprint_days - holidays
         developers_count * available_days * hours_per_day // hours_per_point

     () -> :
        
        .velocity_history.append(completed_points)

     () -> :
        
        recent = .velocity_history[-last_n_sprints:]
         (recent) / (recent)  recent  


 () -> Sprint:
    
    avg_velocity = team.average_velocity()
    capacity = team.calculate_capacity(sprint_duration_days)
    
    selected_stories = []
    remaining_capacity = capacity
    
     story  (product_backlog, key= s: s.priority):
         story.story_points  remaining_capacity >= story.story_points.value:
            selected_stories.append(story)
            remaining_capacity -= story.story_points.value
    
    sprint = Sprint(
        name=,
        start_date=datetime.now(),
        end_date=datetime.now(),
        goals=[, ],
        backlog=selected_stories
    )
    
    ()
    ()
    ()
    
     sprint

class DailyStandup:
    """Manages daily scrum meeting tracking and blocker resolution"""
    def __init__(self, team_members: List[str]):
        self.team_members = team_members
        self.standup_log: List[dict] = []

    def conduct_standup(
        self,
        date: datetime,
        updates: dict
    ) -> List[str]:
        """Conduct daily standup and identify blockers"""
        blockers = []
        
        for member in self.team_members:
            if member in updates:
                update = updates[member]
                self.standup_log.append({
                    "member": member,
                    "date": date,
                    "yesterday": update.get("completed", []),
                    "today": update.get("planned", []),
                    "blocker": update.get("blocker", None)
                })
                
                if update.get("blocker"):
                    blockers.append((member, update["blocker"]))
        
        return blockers

    def escalate_blockers(self, blockers: List[tuple]) -> :
        
         member, blocker  blockers:
            ()

class SprintRetrospective:
    """Facilitates sprint retrospective for continuous improvement"""
    def __init__(self, team: ScrumTeam):
        self.team = team
        self.feedback_items: List[dict] = []

    def add_feedback(
        self,
        category: str,
        what_went_well: str,
        what_to_improve: str,
        action_item: str
    ) -> None:
        """Add retrospective feedback item"""
        self.feedback_items.append({
            "category": category,
            "well": what_went_well,
            "improve": what_to_improve,
            "action": action_item,
            "owner": None,
            "completed": False
        })

    def generate_improvement_plan(self) -> List[dict]:
        """Generate prioritized improvement actions"""
        actions = [
            item for item in self.feedback_items
            if item["action"] and not item["completed"]
        ]
        return sorted(actions, key=lambda x: x[])

Best Practices

• Keep sprints at consistent 2-week intervals to establish reliable rhythm and predictability
• Product Owner should maintain a refined, prioritized backlog with clear acceptance criteria
• Daily standups must be time-boxed to 15 minutes with standing to maintain urgency
• Sprint Review should include real working software demonstrations, not status reports
• Retrospectives must result in actionable improvement items with assigned owners
• Story points should estimate complexity, not hours, and remain consistent across the team
• Definition of Done should be enforced strictly to ensure quality and technical debt control
• Avoid scope creep during sprint by strictly managing sprint backlog changes
• Velocity should be used for capacity planning, not as a performance metric
• Technical debt should be explicitly included in each sprint, typically 10-20% of capacity

Common Patterns

• ** backlog Refinement**: Regular grooming sessions (weekly) to prepare high-priority stories for upcoming sprints
• Burndown Charts: Visual tracking of remaining work versus time to identify early warning signs
• Estimation Poker: Team-based story point estimation using planning poker for better accuracy
• Scrum of Scrums: Scaling pattern for multiple teams coordinating on shared objectives
• Feature Teams: Cross-functional teams organized around features rather than components