Back to catalog

project-coordination

Interactive browser-based AppSec training game where players identify vulnerabilities in code and learn secure coding practices

  • Category: discovered
  • Tags: github, community
  • Version: 1.0.0
  • Author: walid
  • Downloads: 0
  • GitHub stars: 2
  • Updated: 2025-11-21

Download the latest version (v1.0.0) from this page.

SKILL.md

# Project Coordination Skill

## Activation Context
Activates when coordinating team work, managing timelines, tracking progress, or facilitating team communication.

## When to Invoke project-manager Agent
- Planning sprints or iterations
- Coordinating multi-agent work
- Tracking project progress
- Managing timelines and deadlines
- Facilitating team communication
- Resolving blockers
- Reporting status
- Risk management

## Responsibilities

### Planning & Coordination
- Sprint/iteration planning
- Task breakdown and assignment
- Timeline and milestone management
- Resource allocation
- Dependency management
- Risk identification and mitigation

### Progress Tracking
- Daily standups facilitation
- Progress monitoring
- Burndown/burnup tracking
- Velocity tracking
- Status reporting
- Blocker identification

### Team Communication
- Stakeholder updates
- Team synchronization
- Meeting facilitation
- Conflict resolution
- Information dissemination

## Coordination Protocol

### Sprint Planning Process
1. **Review Backlog**: With product-manager
2. **Estimate Effort**: With engineering team
3. **Define Sprint Goal**: Clear, achievable objective
4. **Select Stories**: Based on priority and capacity
5. **Break Down Tasks**: Assign to appropriate agents
6. **Identify Dependencies**: Cross-agent coordination needs
7. **Commit to Sprint**: Team agreement

### Daily Coordination
- **Daily Standup**: 15-minute sync
  - What did you complete yesterday?
  - What will you work on today?
  - Any blockers or dependencies?

- **GitHub Projects Board**: Update in real-time
  - Move cards as work progresses
  - Tag blockers
  - Update estimates

### Agent Coordination
- Ensure no conflicts (same file, overlapping work)
- Facilitate handoffs between agents
- Monitor for blockers between agents
- Coordinate parallel work

## GitHub Projects Setup

### Board Columns
```
Backlog → Ready → In Progress → In Review → Done
```

### Card Metadata
- **Assignee**: Which agent is responsible
- **Labels**: Priority, type, complexity
- **Estimate**: Story points or hours
- **Dependencies**: Linked issues
- **Due Date**: Timeline commitment

### Automation Rules
- New issues → Backlog
- Assigned → Ready
- PR opened → In Review
- PR merged → Done

## Task Management

### Issue Creation Template
```markdown
## Description
Clear description of what needs to be done

## Acceptance Criteria
- [ ] Specific, testable criterion 1
- [ ] Specific, testable criterion 2
- [ ] Specific, testable criterion 3

## Technical Approach
Brief outline of how to implement

## Dependencies
- Depends on #123
- Requires input from @agent

## Estimated Effort
[1, 2, 3, 5, 8, 13 story points or hours]

## Agent Assignment
@backend-engineer (or appropriate agent)

## Labels
priority: high, type: feature, complexity: medium
```

### Task Breakdown Guidelines
- Each task should be completable in 1-3 days
- Break down large features into smaller tasks
- Ensure tasks have clear acceptance criteria
- Assign to single agent (no shared ownership)
- Identify all dependencies upfront

## Sprint Ceremonies

### Sprint Planning (Beginning of Sprint)
**Duration**: 1-2 hours
**Attendees**: All agents (via coordination)
**Outcome**: Sprint backlog with committed work

**Agenda**:
1. Review sprint goal
2. Review and refine backlog
3. Estimate stories
4. Select stories for sprint
5. Break down into tasks
6. Identify risks and dependencies

### Daily Standup (Every Day)
**Duration**: 15 minutes
**Format**: Asynchronous (GitHub comments) or synchronous

**Each Agent Reports**:
- Completed: What was finished
- In Progress: Current work
- Planned: What's next
- Blockers: Any impediments

### Sprint Review (End of Sprint)
**Duration**: 1 hour
**Attendees**: Team + Stakeholders
**Outcome**: Demonstration of completed work

**Agenda**:
1. Demo completed features
2. Review sprint goal achievement
3. Gather stakeholder feedback
4. Update product backlog

### Sprint Retrospective (End of Sprint)
**Duration**: 1 hour
**Attendees**: Development team
**Outcome**: Action items for improvement

**Agenda**:
1. What went well?
2. What could be improved?
3. Action items for next sprint

## Progress Tracking

### Metrics to Track
- **Velocity**: Story points completed per sprint
- **Burndown**: Work remaining over time
- **Lead Time**: Time from start to done
- **Cycle Time**: Time in active development
- **Throughput**: Items completed per time period

### Status Reporting

#### Weekly Status Update Template
```markdown
# Week of [Date] - Project Status

## Highlights
- Major accomplishment 1
- Major accomplishment 2
- Major accomplishment 3

## Sprint Progress
- Sprint Goal: [Goal]
- Completion: [X]% (Y/Z story points)
- On track: ✅ / ⚠️ / 🔴

## Completed This Week
- ✅ Feature 1 (backend-engineer)
- ✅ Feature 2 (frontend-engineer)
- ✅ Security review (security-engineer)

## In Progress
- 🔨 Feature 3 (backend-engineer) - 60% complete
- 🔨 UI components (frontend-engineer) - 30% complete

## Upcoming Next Week
- Feature 4 planning
- Performance optimization
- Documentation updates

## Blockers & Risks
- 🔴 Critical: [Blocker description]
- ⚠️ Risk: [Risk and mitigation]

## Metrics
- Velocity: X story points
- Bugs: Y open, Z resolved
- PRs: A merged, B in review

## Agent Utilization
- backend-engineer: Fully allocated
- frontend-engineer: Capacity for additional work
- security-engineer: Waiting on PRs to review
```

## Blocker Management

### Blocker Identification
- Agent reports blocker in standup
- Label issue with `blocked`
- Tag relevant people
- Update project board

### Blocker Resolution Process
1. **Identify**: What is blocking progress?
2. **Analyze**: Why is it blocking?
3. **Options**: What are possible solutions?
4. **Escalate**: If needed, involve stakeholders
5. **Act**: Implement solution
6. **Verify**: Confirm blocker is removed
7. **Document**: Record for future reference

### Common Blockers
- **Dependency**: Waiting on another agent
- **Technical**: Technical challenge or unknown
- **Resource**: Missing access, tools, or information
- **Decision**: Awaiting product/business decision
- **External**: Third-party dependency

## Risk Management

### Risk Assessment
- **Probability**: High/Medium/Low
- **Impact**: High/Medium/Low
- **Priority**: Probability × Impact

### Risk Register Template
```markdown
## Risk: [Description]

**Category**: Technical/Resource/Schedule/External
**Probability**: High/Medium/Low
**Impact**: High/Medium/Low
**Priority**: High/Medium/Low

### Mitigation Strategy
Steps to reduce probability or impact

### Contingency Plan
What to do if risk occurs

### Owner
@agent responsible for monitoring
```

## Handoff Coordination

### Agent Handoff Template
```markdown
@next-agent Handoff from @current-agent

**Context**: Brief summary of what was done

**What's Complete**:
- Item 1
- Item 2

**Next Steps**:
- Step 1: [What needs to be done]
- Step 2: [Additional work]

**Important Notes**:
- Note about approach/decisions
- Edge cases to consider
- Related PRs or issues

**Files Modified**:
- file1.js
- file2.js

**Branch**: feature/123-description
**PR**: #456
```

## Communication Best Practices

### Asynchronous Communication
- Use GitHub comments for updates
- Tag relevant agents with @mentions
- Update project board in real-time
- Document decisions in issues
- Use labels and milestones effectively

### Synchronous Communication
- Schedule meetings when needed
- Keep meetings focused and time-boxed
- Document outcomes and action items
- Share meeting notes in issues

### Escalation Protocol
1. **Try to resolve** with relevant agents first
2. **Document the issue** clearly
3. **Tag stakeholders** if unresolved after 2 hours
4. **Create escalation issue** with `blocked` label
5. **Provide context** and possible solutions

## Timeline Management

### Milestone Planning
- Define clear milestones
- Set realistic dates
- Include buffer for unknowns
- Track progress to milestones
- Adjust as needed based on data

### Deadline Management
- Communicate deadlines clearly
- Track progress toward deadlines
- Identify risks early
- Escalate if deadline at risk
- Manage scope if needed

## Best Practices
- Keep communication transparent
- Update status frequently
- Address blockers immediately
- Track metrics consistently
- Facilitate, don't micromanage
- Trust but verify
- Document decisions
- Celebrate wins
- Learn from setbacks
- Adapt process as needed