Common AI Workflows with Gira MCP¶

This document provides proven workflows and patterns for using AI agents with the Gira MCP server to automate common project management tasks, improve team productivity, and maintain project health.

🚀 Getting Started Workflows¶

Project Initialization Workflow¶

Scenario: Setting up a new project with epics, initial tickets, and team structure.

AI Prompt Pattern:

"I'm starting a new project called [PROJECT_NAME]. Help me set up the initial structure with epics for [FEATURE_1], [FEATURE_2], and [FEATURE_3]. Create a basic backlog and first sprint."

MCP Tool Sequence: 1. create_epic × 3 (for each major feature area) 2. create_ticket × 10-15 (initial backlog) 3. add_tickets_to_epic (organize tickets) 4. create_sprint (first sprint) 5. add_tickets_to_sprint (sprint planning)

Expected Outcome: - 3 well-defined epics with clear scope - 10-15 prioritized tickets in backlog - First 2-week sprint with 5-8 tickets - Clear team capacity and timeline

Daily Project Health Check¶

Scenario: Morning routine to assess project status and identify issues.

AI Prompt Pattern:

"Give me a daily health check of our project. Show me sprint progress, any blocked tickets, and what needs attention today."

MCP Tool Sequence: 1. get_enhanced_board_state (overall project view) 2. get_sprint (current sprint details) 3. list_tickets with status filters (identify blockers) 4. get_swimlane_tickets (team workload)

Expected Outcome: - Comprehensive project status in 30 seconds - Identification of blockers and risks - Team workload distribution - Actionable priorities for the day

📋 Planning Workflows¶

Epic Breakdown Workshop¶

Scenario: Breaking down a large epic into manageable tickets.

AI Prompt Pattern:

"Help me break down EPIC-[ID] into specific, actionable tickets. Consider the requirements: [REQUIREMENTS]. Estimate story points and identify dependencies."

MCP Tool Sequence: 1. get_epic (understand current epic) 2. create_ticket × N (create detailed tickets) 3. add_tickets_to_epic (associate with epic) 4. Analysis of dependencies and estimation

Workflow Steps:

1. Epic Analysis
   - Review epic description and goals
   - Identify major functional areas
   - Consider technical constraints

2. Ticket Creation
   - Create 5-12 focused tickets per epic
   - Include acceptance criteria
   - Estimate story points (1-8 range)

3. Dependency Mapping
   - Identify prerequisite relationships
   - Plan logical development sequence
   - Flag external dependencies

4. Validation
   - Ensure epic scope is covered
   - Validate story point totals
   - Check team capacity alignment

Sprint Planning Automation¶

Scenario: Automated sprint planning based on team velocity and priorities.

AI Prompt Pattern:

"Plan our next sprint starting [DATE]. Our team velocity is [X] story points. Prioritize tickets from the backlog considering epic goals and dependencies."

MCP Tool Sequence: 1. list_tickets (available backlog) 2. get_sprint_metrics (historical velocity) 3. create_sprint (new sprint) 4. add_tickets_to_sprint (capacity-based selection)

Automation Logic:

# Pseudo-code for sprint planning logic
def plan_sprint(team_velocity, sprint_duration):
    available_tickets = get_backlog_tickets()
    capacity = team_velocity * (sprint_duration / 14)  # Normalize to 2-week sprints

    selected_tickets = []
    total_points = 0

    # Priority order: critical bugs, epic goals, high-value features
    for ticket in sort_by_priority(available_tickets):
        if total_points + ticket.story_points <= capacity:
            selected_tickets.append(ticket)
            total_points += ticket.story_points

    return selected_tickets, capacity - total_points  # remaining capacity

Release Planning Matrix¶

Scenario: Planning multiple releases with epic alignment and risk assessment.

AI Prompt Pattern:

"Help me plan our next 3 releases (Q2, Q3, Q4). Consider epic dependencies, team capacity, and business priorities. Identify risks and create timeline."

MCP Tool Sequence: 1. list_epics (all active epics) 2. get_epic_tickets per epic (scope understanding) 3. get_sprint_metrics (team velocity analysis) 4. Cross-epic dependency analysis

Release Planning Matrix:

Release Q2 (Apr-Jun):
├── EPIC-001: User Auth (Must Have)
├── EPIC-002: Dashboard (Should Have)  
└── EPIC-003: Payments (Could Have)

Release Q3 (Jul-Sep):
├── EPIC-003: Payments (Must Have - if missed Q2)
├── EPIC-004: Mobile App (Should Have)
└── EPIC-005: Analytics (Could Have)

Release Q4 (Oct-Dec):
├── EPIC-005: Analytics (Must Have)
├── EPIC-006: Integrations (Should Have)
└── EPIC-007: AI Features (Could Have)

🔄 Execution Workflows¶

Automated Daily Standups¶

Scenario: Generate daily standup reports for distributed teams.

AI Prompt Pattern:

"Generate today's standup report. Include what was completed yesterday, what's planned for today, and any blockers. Focus on [CURRENT_SPRINT]."

MCP Tool Sequence: 1. get_sprint (current sprint context) 2. get_swimlane_tickets by assignee (individual progress) 3. list_tickets with recent updates (yesterday's work) 4. Blocker identification and priority analysis

Report Template:

# Daily Standup - [DATE]

## Sprint Progress
- **Sprint**: [SPRINT_NAME] (Day X of Y)
- **Completion**: X% (Y story points done)
- **Burndown**: On track / Behind / Ahead

## Team Updates

### [Team Member 1]
- **Completed**: [Tickets completed yesterday]
- **Today**: [Current focus tickets]
- **Blockers**: [Any impediments]

### [Team Member 2]
- **Completed**: [Tickets completed yesterday]  
- **Today**: [Current focus tickets]
- **Blockers**: [Any impediments]

## Action Items
- [ ] [Blocker resolution tasks]
- [ ] [Coordination needs]

Bug Triage Automation¶

Scenario: Automated bug triage and assignment based on severity and expertise.

AI Prompt Pattern:

"A new bug report came in: [BUG_DESCRIPTION]. Help me triage this - assess severity, assign to the right person, and determine if it needs immediate attention."

MCP Tool Sequence: 1. create_ticket (bug ticket creation) 2. Severity assessment logic 3. update_ticket (assignment and priority) 4. add_tickets_to_sprint (if critical) 5. create_comment (team notification)

Triage Decision Tree:

Is it affecting production?
├── Yes: Priority = Critical
│   ├── Security issue? → Assign to Security Lead
│   ├── Data loss risk? → Assign to Backend Lead  
│   └── User-facing? → Assign to Frontend Lead
└── No: Priority = Medium/Low
    ├── Affects core features? → Priority = Medium
    └── Minor issue? → Priority = Low

Assignment Logic:
- Authentication bugs → Sarah (Auth expert)
- UI/UX bugs → Mike (Frontend lead)
- API/Database bugs → Alex (Backend specialist)
- DevOps/Infrastructure → Alex (DevOps lead)

Feature Delivery Pipeline¶

Scenario: Track feature progress from development through deployment.

AI Prompt Pattern:

"Track the progress of [FEATURE_NAME] through our delivery pipeline. Show me development status, testing progress, and deployment readiness."

MCP Tool Sequence: 1. get_epic_tickets (feature scope) 2. list_tickets with status analysis (pipeline stages) 3. get_sprint_metrics (velocity and timing) 4. Deployment readiness assessment

Pipeline Stages:

Development Pipeline:
├── 📝 Planning (Tickets in backlog/todo)
├── 🔨 Development (Tickets in progress)
├── 👀 Code Review (Tickets in review) 
├── 🧪 Testing (QA validation)
├── 🚀 Staging (Pre-production testing)
└── ✅ Production (Live deployment)

Quality Gates:
- All tickets must pass code review
- Security review for auth/payment features
- Performance testing for core user paths
- Acceptance criteria validation

📊 Monitoring Workflows¶

Sprint Health Monitoring¶

Scenario: Continuous sprint health assessment with early warning system.

AI Prompt Pattern:

"Analyze our current sprint health. Look for velocity issues, scope creep, blocked work, and predict if we'll meet our goals. Recommend adjustments."

MCP Tool Sequence: 1. get_sprint_metrics (detailed analytics) 2. get_enhanced_board_state (current distribution) 3. Historical comparison analysis 4. Predictive completion analysis

Health Indicators:

# Sprint health calculation
def calculate_sprint_health(sprint_data):
    health_score = 100

    # Velocity analysis
    if current_velocity < target_velocity * 0.8:
        health_score -= 20  # Behind pace

    # Scope stability
    scope_change_pct = added_tickets / original_tickets
    if scope_change_pct > 0.2:
        health_score -= 15  # Too much scope creep

    # Blocker analysis
    blocked_tickets_pct = blocked_count / total_tickets
    if blocked_tickets_pct > 0.3:
        health_score -= 25  # Too many blockers

    # Team capacity
    if overallocated_team_members > 0:
        health_score -= 10  # Team overcommitted

    return max(0, health_score)

Health Levels:
- 80-100: 🟢 Excellent
- 60-79:  🟡 Good (minor adjustments needed)
- 40-59:  🟠 Concerning (significant adjustments needed)
- 0-39:   🔴 Critical (major intervention required)

Epic Progress Tracking¶

Scenario: Multi-sprint epic progress monitoring with milestone tracking.

AI Prompt Pattern:

"Give me a comprehensive progress report on all active epics. Show completion percentages, timeline adherence, and identify any epics at risk."

MCP Tool Sequence: 1. list_epics (all active epics) 2. get_epic_tickets per epic (detailed progress) 3. Cross-epic dependency analysis 4. Timeline risk assessment

Epic Health Dashboard:

EPIC-001: User Authentication
├── Progress: 78% complete (15/19 tickets)
├── Timeline: ✅ On track (completion March 1st)
├── Risk Level: 🟢 Low
└── Next Milestone: Security audit (Feb 28th)

EPIC-002: Payment Integration  
├── Progress: 45% complete (9/20 tickets)
├── Timeline: ⚠️ At risk (completion pushed to April 15th)
├── Risk Level: 🟡 Medium
└── Blockers: 2 tickets waiting on Stripe API access

EPIC-003: Mobile App
├── Progress: 12% complete (2/17 tickets)
├── Timeline: 🔴 Behind (needs scope adjustment)
├── Risk Level: 🟠 High
└── Issues: Team capacity constraints, dependency on EPIC-001

🤝 Collaboration Workflows¶

Cross-Team Dependency Management¶

Scenario: Managing dependencies between frontend, backend, and DevOps teams.

AI Prompt Pattern:

"Map all cross-team dependencies in our current work. Identify potential bottlenecks and suggest coordination improvements."

MCP Tool Sequence: 1. get_swimlane_tickets by team (team workloads) 2. Cross-reference ticket dependencies 3. list_tickets with assignee analysis 4. Coordination opportunity identification

Dependency Mapping:

Frontend → Backend Dependencies:
├── GCM-201 (Dashboard UI) needs GCM-202 (User API)
├── GCM-301 (Payment Form) needs GCM-302 (Payment API)
└── GCM-401 (Mobile Login) needs GCM-123 (Auth Service)

Backend → DevOps Dependencies:
├── GCM-302 (Payment API) needs GCM-350 (Stripe Config)
├── GCM-203 (Database Schema) needs GCM-351 (DB Migration)
└── GCM-124 (OAuth Service) needs GCM-352 (SSL Certificates)

Coordination Schedule:
- Monday: API specification reviews
- Wednesday: Integration testing
- Friday: Deployment coordination

Stakeholder Reporting Automation¶

Scenario: Automated progress reports for different stakeholder groups.

AI Prompt Pattern:

"Generate a [WEEKLY/MONTHLY] progress report for [STAKEHOLDER_GROUP]. Focus on [BUSINESS_METRICS/TECHNICAL_DETAILS/TIMELINE_ADHERENCE]."

MCP Tool Sequence: 1. get_enhanced_board_state (overall progress) 2. list_epics with progress analysis 3. get_sprint_metrics (velocity trends) 4. Risk and timeline analysis

Report Templates by Audience:

Executive Summary (C-Level):

# Executive Progress Report - [Period]

## Key Achievements
- [Major milestones completed]
- [Business value delivered]

## Metrics
- Sprint Velocity: X points/week (trend: ↑/↓/→)
- Feature Completion: X% of planned features
- Timeline Adherence: On track/Behind/Ahead

## Risks & Mitigation
- [Top 3 risks with mitigation plans]

## Next Period Focus
- [Key deliverables and dates]

Product Manager Report:

# Product Development Report - [Period]

## Feature Progress
[Epic-by-epic breakdown with user value]

## User Story Completion
- Stories delivered: X
- User acceptance: Y%
- Feedback integration: Z stories updated

## Backlog Health
- Groomed stories: X weeks ahead
- Technical debt ratio: Y%
- Bug/feature ratio: Z%

## Upcoming Decisions
- [Feature prioritization needs]
- [Scope adjustment recommendations]

Technical Team Report:

# Engineering Progress Report - [Period]

## Development Metrics
- Code commits: X
- Pull requests: Y (avg review time: Z hours)
- Test coverage: A%
- Build success rate: B%

## Technical Achievements
- [Architecture improvements]
- [Performance optimizations]
- [Technical debt reduction]

## Infrastructure & Tools
- [DevOps improvements]
- [Tool/process enhancements]

## Technical Risks
- [Security considerations]
- [Performance concerns]
- [Scalability planning]

🚨 Crisis Management Workflows¶

Production Incident Response¶

Scenario: Rapid response to production issues with structured incident management.

AI Prompt Pattern:

"We have a production incident: [INCIDENT_DESCRIPTION]. Help me coordinate the response - create incident tickets, assign experts, and track resolution."

MCP Tool Sequence: 1. create_ticket (incident ticket with critical priority) 2. update_ticket (expert assignment) 3. add_tickets_to_sprint (current sprint for tracking) 4. create_comment (incident updates and communication)

Incident Response Template:

Incident Response Workflow:

1. Immediate Response (0-15 minutes)
   ├── Create incident ticket (P0 priority)
   ├── Assign incident commander
   ├── Notify stakeholders
   └── Begin investigation

2. Assessment Phase (15-30 minutes)
   ├── Determine impact and scope
   ├── Assign additional responders
   ├── Implement immediate workarounds
   └── Update stakeholders

3. Resolution Phase (30+ minutes)
   ├── Implement permanent fix
   ├── Test resolution thoroughly
   ├── Deploy to production
   └── Monitor for stability

4. Post-Incident (24-48 hours)
   ├── Create postmortem ticket
   ├── Document lessons learned
   ├── Implement preventive measures
   └── Update runbooks

Communication Cadence:
- First 30 min: Updates every 10 minutes
- Next 2 hours: Updates every 30 minutes  
- Resolution: Final summary and next steps

Scope Crisis Recovery¶

Scenario: Sprint or epic scope has expanded beyond capacity - need rapid rescoping.

AI Prompt Pattern:

"Our current sprint/epic is over capacity by [X]%. Help me rescope by identifying what can be moved, deferred, or simplified while maintaining core value."

MCP Tool Sequence: 1. get_sprint or get_epic (current scope analysis) 2. list_tickets with priority/value analysis 3. remove_tickets_from_sprint (scope reduction) 4. create_comment (stakeholder communication)

Rescoping Decision Matrix:

Priority Matrix for Scope Reduction:

High Value + Low Effort = Keep (Core features)
├── Authentication login flow
├── Basic payment processing
└── Essential UI components

High Value + High Effort = Simplify (Reduce scope)
├── Advanced dashboard → Basic dashboard
├── OAuth + SSO → OAuth only
└── Mobile app → Mobile-responsive web

Low Value + Low Effort = Defer (Next sprint)
├── Admin panel enhancements
├── Additional reporting
└── UI polish features

Low Value + High Effort = Remove (Future consideration)
├── Advanced analytics
├── Third-party integrations
└── Experimental features

Rescoping Process:
1. Classify all tickets using matrix
2. Remove/defer low-value items first
3. Simplify high-value complex items
4. Communicate changes to stakeholders
5. Update sprint/epic goals accordingly

🎯 Optimization Workflows¶

Velocity Improvement Analysis¶

Scenario: Team velocity has declined - identify root causes and improvement opportunities.

AI Prompt Pattern:

"Our team velocity has dropped from [X] to [Y] story points per sprint. Analyze the causes and recommend specific improvements."

MCP Tool Sequence: 1. get_sprint_metrics (multiple historical sprints) 2. list_tickets with completion time analysis 3. Blocker pattern analysis 4. Team capacity and assignment analysis

Velocity Analysis Framework:

def analyze_velocity_decline(historical_sprints):
    factors = {
        'scope_creep': 0,
        'team_capacity': 0, 
        'blocker_frequency': 0,
        'story_complexity': 0,
        'external_dependencies': 0
    }

    for sprint in historical_sprints:
        # Scope creep analysis
        if sprint.added_tickets / sprint.planned_tickets > 0.2:
            factors['scope_creep'] += 1

        # Capacity analysis
        if sprint.team_availability < 0.8:  # Less than 80% available
            factors['team_capacity'] += 1

        # Blocker analysis
        if sprint.blocked_ticket_days > sprint.total_ticket_days * 0.3:
            factors['blocker_frequency'] += 1

        # Complexity analysis
        if sprint.avg_story_points > historical_avg * 1.3:
            factors['story_complexity'] += 1

        # Dependency analysis
        if sprint.external_dependencies > 3:
            factors['external_dependencies'] += 1

    return sorted(factors.items(), key=lambda x: x[1], reverse=True)

Improvement Recommendations:
1. Scope Creep → Implement sprint scope lock after day 2
2. Team Capacity → Account for holidays, meetings, training
3. Blockers → Daily blocker review, escalation process
4. Story Complexity → Better estimation, story splitting
5. Dependencies → Earlier coordination, API-first design

Quality Metrics Optimization¶

Scenario: Track and improve code quality, bug rates, and technical debt.

AI Prompt Pattern:

"Analyze our quality metrics - bug rates, rework frequency, and technical debt tickets. Identify patterns and recommend quality improvements."

MCP Tool Sequence: 1. list_tickets filtered by type="bug" (bug analysis) 2. list_tickets with rework patterns (quality issues) 3. Technical debt ticket analysis 4. Epic-level quality correlation

Quality Dashboard:

Quality Metrics Dashboard:

Bug Analysis:
├── New bugs per sprint: 3.2 (trend: ↓ from 4.1)
├── Bug resolution time: 2.3 days (target: <2 days)
├── Critical bugs: 0.8 per sprint (trend: stable)
└── Bug sources: 40% frontend, 35% backend, 25% integration

Technical Debt:
├── Tech debt tickets: 23% of backlog
├── Debt resolution rate: 1.2 tickets/sprint
├── Debt creation rate: 1.8 tickets/sprint
└── Net debt trend: ↑ Increasing (concern)

Quality Improvements:
1. Implement pre-commit hooks (prevent simple bugs)
2. Increase code review coverage (currently 78%)
3. Add integration testing (reduce integration bugs)
4. Allocate 20% sprint capacity to tech debt
5. Implement definition of done checklist

📚 Knowledge Management Workflows¶

Documentation Automation¶

Scenario: Automatically generate and maintain project documentation from ticket data.

AI Prompt Pattern:

"Generate comprehensive project documentation based on our current epics and tickets. Include architecture decisions, feature specifications, and team processes."

MCP Tool Sequence: 1. list_epics (high-level feature documentation) 2. get_epic_tickets (detailed feature specs) 3. list_tickets with technical details 4. Cross-reference and synthesis

Documentation Generation:

# Auto-Generated Project Documentation

## Architecture Overview
[Based on epic descriptions and technical tickets]

## Feature Specifications
[Generated from epic and ticket acceptance criteria]

## API Documentation
[Extracted from backend ticket descriptions]

## Development Processes
[Derived from sprint and workflow patterns]

## Team Structure
[Based on ticket assignment patterns]

Update Frequency: Weekly auto-regeneration
Last Updated: [Timestamp]
Source: Gira MCP automation

Scenario: Identify knowledge silos and create cross-training opportunities.

AI Prompt Pattern:

"Analyze our team's knowledge distribution based on ticket assignments. Identify knowledge silos and recommend cross-training opportunities."

MCP Tool Sequence: 1. get_swimlane_tickets by assignee (expertise mapping) 2. list_tickets with label/epic analysis 3. Cross-training opportunity identification 4. Knowledge sharing recommendations

Knowledge Map:

Team Knowledge Distribution:

Sarah (Backend Lead):
├── Expertise: Authentication, APIs, Database
├── Exclusive Knowledge: OAuth implementation, security
├── Knowledge Risk: High (single point of failure)
└── Cross-training Need: High priority

Mike (Frontend Lead):
├── Expertise: React, UI/UX, Components
├── Exclusive Knowledge: Design system, accessibility
├── Knowledge Risk: Medium
└── Cross-training Need: Medium priority

Alex (Full-stack):
├── Expertise: DevOps, Infrastructure, Integration
├── Exclusive Knowledge: CI/CD, deployment
├── Knowledge Risk: High (only DevOps expert)
└── Cross-training Need: High priority

Cross-Training Plan:
1. Sarah → Alex: API design patterns
2. Mike → Sarah: Frontend architecture
3. Alex → Mike: Deployment processes
4. All → Documentation of exclusive knowledge

This comprehensive set of workflows demonstrates how AI agents can leverage the Gira MCP server to automate complex project management scenarios, improve team efficiency, and maintain high-quality software delivery processes.

Common AI Workflows with Gira MCP¶

🚀 Getting Started Workflows¶

Project Initialization Workflow¶

Daily Project Health Check¶

📋 Planning Workflows¶

Epic Breakdown Workshop¶

Sprint Planning Automation¶

Release Planning Matrix¶

🔄 Execution Workflows¶

Automated Daily Standups¶

Bug Triage Automation¶

Feature Delivery Pipeline¶

📊 Monitoring Workflows¶

Sprint Health Monitoring¶

Epic Progress Tracking¶

🤝 Collaboration Workflows¶

Cross-Team Dependency Management¶

Stakeholder Reporting Automation¶

🚨 Crisis Management Workflows¶

Production Incident Response¶

Scope Crisis Recovery¶

🎯 Optimization Workflows¶

Velocity Improvement Analysis¶

Quality Metrics Optimization¶

📚 Knowledge Management Workflows¶

Documentation Automation¶

Team Knowledge Sharing¶