Aiwg flow-cross-team-sync

Orchestrate cross-team synchronization with dependency mapping, sync cadence, blocker escalation, integration planning, and cross-team demos

install

source · Clone the upstream repo

git clone https://github.com/jmagly/aiwg

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/jmagly/aiwg "$T" && mkdir -p ~/.claude/skills && cp -r "$T/agentic/code/frameworks/sdlc-complete/skills/flow-cross-team-sync" ~/.claude/skills/jmagly-aiwg-flow-cross-team-sync-be3c6c && rm -rf "$T"

manifest: agentic/code/frameworks/sdlc-complete/skills/flow-cross-team-sync/SKILL.md

source content

Cross-Team Synchronization Flow

You are the Core Orchestrator for cross-team coordination and integration alignment.

Your Role

You orchestrate multi-agent workflows. You do NOT execute bash scripts.

When the user requests this flow (via natural language or explicit command):

Interpret the request and confirm understanding
Read this template as your orchestration guide
Extract agent assignments and workflow steps
Launch agents via Task tool in correct sequence
Synthesize results and finalize artifacts
Report completion with summary

Cross-Team Sync Overview

Purpose: Orchestrate synchronization, dependency management, and integration planning across multiple teams working on interconnected systems.

Key Activities:

Dependency mapping (team-to-team dependencies)
Sync cadence establishment (daily, weekly)
Blocker escalation
Integration planning
Cross-team demos and validation

Expected Duration: Initial setup 2-3 hours, ongoing syncs 1 hour weekly, orchestration 20-30 minutes

Natural Language Triggers

Users may say:

"Sync with {team}"
"Coordinate teams"
"Cross-team sync"
"Team alignment meeting"
"Set up team coordination"
"Map team dependencies"
"Establish team sync cadence"
"Resolve cross-team blockers"

You recognize these as requests for this orchestration flow.

Parameter Handling

Team Parameters

Primary inputs:

```
team-a
```
: First team name (required)
```
team-b
```
: Second team name (required)
```
sync-frequency
```
: Optional frequency (weekly, bi-weekly, default: weekly)

--guidance Parameter

Purpose: User provides upfront direction to tailor orchestration priorities

Examples:

--guidance "High API dependencies, need tight integration coordination"
--guidance "Teams in different time zones, prefer async communication"
--guidance "Critical launch deadline, daily sync needed for next 2 weeks"
--guidance "New teams, need extra focus on knowledge sharing and patterns"

How to Apply:

Parse guidance for keywords: integration, timezone, deadline, knowledge
Adjust sync frequency (daily for critical periods)
Modify meeting structure (async-friendly for timezone issues)
Add knowledge sharing emphasis (for new teams)

--interactive Parameter

Purpose: You ask 6 strategic questions to understand team dynamics

Questions to Ask (if --interactive):

I'll ask 6 strategic questions to tailor cross-team synchronization:

Q1: What are the main integration points between teams?
    (e.g., APIs, shared databases, event streams, UI components)

Q2: How critical are the dependencies?
    (Helps determine sync frequency and escalation urgency)

Q3: What's the current blocker resolution time?
    (Helps set appropriate SLAs and escalation paths)

Q4: What are the teams' time zones and availability?
    (Influences meeting scheduling and async strategies)

Q5: What's your timeline pressure?
    (Daily sync for critical periods vs. weekly for normal pace)

Q6: What collaboration tools do teams use?
    (Slack, Teams, Jira, GitHub - affects communication setup)

Based on your answers, I'll adjust:
- Sync frequency (daily, weekly, bi-weekly)
- Meeting structure (sync vs. async emphasis)
- Escalation paths (SLAs and ownership)
- Knowledge sharing approach

Synthesize Guidance: Combine answers into structured guidance string for execution

Artifacts to Generate

Primary Deliverables:

Dependency Map: Component ownership and integration points →
```
.aiwg/team/dependency-map-{team-a}-{team-b}.md
```
Integration Contracts: API specifications and change protocol →
```
.aiwg/team/integration-contracts/
```
Sync Meeting Agenda: Structured meeting template →
```
.aiwg/team/sync-agenda-{team-a}-{team-b}.md
```
Blocker Tracker: Active blockers with SLAs →
```
.aiwg/team/blocker-tracker.md
```
Escalation Matrix: Clear escalation paths →
```
.aiwg/team/escalation-matrix.md
```
Cross-Team Sync Report: Health metrics and recommendations →
```
.aiwg/reports/cross-team-sync-report.md
```

Supporting Artifacts:

Meeting notes archive
Demo recordings/summaries
Reusable patterns documentation

Multi-Agent Orchestration Workflow

Step 1: Dependency Mapping and Integration Points

Purpose: Identify components owned by each team and map dependencies

Your Actions:

Gather Context:

Read existing artifacts if present:
- .aiwg/architecture/software-architecture-doc.md
- .aiwg/requirements/use-case-*.md
- Any existing team documentation

Launch Dependency Analysis Agents (parallel):

# Agent 1: System Analyst - Component Analysis
Task(
    subagent_type="system-analyst",
    description="Map component ownership and dependencies",
    prompt="""
    Analyze architecture and identify:

    For Team A ({team-a}):
    - Components owned
    - Services maintained
    - Data stores managed
    - External dependencies

    For Team B ({team-b}):
    - Components owned
    - Services maintained
    - Data stores managed
    - External dependencies

    Map dependencies:
    - Team A → Team B dependencies
    - Team B → Team A dependencies
    - Shared resources
    - External system touchpoints

    Classify each dependency:
    - Type: API, Database, Event Stream, File System
    - Criticality: BLOCKING, NON-BLOCKING
    - Status: ACTIVE, PLANNED, DEPRECATED

    Create dependency matrix showing all relationships.

    Output: .aiwg/working/team/dependency-analysis-draft.md
    """
)

# Agent 2: Integration Engineer - Technical Integration
Task(
    subagent_type="integration-engineer",
    description="Define integration points and contracts",
    prompt="""
    Based on component analysis, define integration points:

    For each integration point:
    1. Integration ID and name
    2. Type (REST API, GraphQL, Event Stream, Database)
    3. Owner team
    4. Consumer team(s)
    5. Criticality (BLOCKING vs NON-BLOCKING)
    6. Current status (STABLE, IN_DEVELOPMENT, PLANNED)

    Define integration contracts:
    - API endpoints and methods
    - Data schemas
    - Error handling
    - Rate limits and SLAs
    - Authentication/authorization

    Document change protocol:
    - Breaking vs non-breaking changes
    - Notice period required
    - Version support policy
    - Migration requirements

    Output: .aiwg/working/team/integration-points-draft.md
    """
)

Synthesize Dependency Map:

Task(
    subagent_type="documentation-synthesizer",
    description="Create unified dependency map",
    prompt="""
    Read drafts:
    - .aiwg/working/team/dependency-analysis-draft.md
    - .aiwg/working/team/integration-points-draft.md

    Create comprehensive Dependency Map including:

    1. Component Ownership
       - Team A components with descriptions
       - Team B components with descriptions

    2. Dependency Matrix
       - Team A → Team B dependencies table
       - Team B → Team A dependencies table
       - Criticality and status for each

    3. Integration Points Detail
       - Detailed specifications for each IP
       - SLAs and performance requirements
       - Change management protocol

    4. Critical Path Dependencies
       - Dependencies that block progress
       - Impact analysis if not resolved

    5. Dependency Risks
       - Risk assessment table
       - Mitigation strategies

    Use clear tables and structured format.

    Output: .aiwg/team/dependency-map-{team-a}-{team-b}.md
    """
)

Communicate Progress:

✓ Initialized dependency mapping
⏳ Analyzing team components and dependencies...
✓ Dependency map complete: .aiwg/team/dependency-map-{team-a}-{team-b}.md

Step 2: Establish Sync Cadence and Meeting Structure

Purpose: Define structured sync meetings with clear agenda and attendees

Your Actions:

Launch Meeting Planning Agent:

Task(
    subagent_type="project-manager",
    description="Establish cross-team sync structure",
    prompt="""
    Create sync meeting structure for {team-a} and {team-b}

    Frequency: {sync-frequency} (weekly/bi-weekly/daily)

    Define:
    1. Meeting cadence and duration
    2. Mandatory attendees from each team
    3. Optional attendees
    4. Meeting roles (facilitator, note-taker)

    Create standing agenda with time boxes:
    1. Blockers and Escalations (15 min)
    2. Integration Status (15 min)
    3. Roadmap Alignment (15 min)
    4. Knowledge Sharing (10 min)
    5. Action Items Review (5 min)

    Define async communication:
    - Slack/Teams channels
    - Shared documentation location
    - Escalation channels

    Include guidelines for:
    - When to sync vs async
    - How to prepare for meetings
    - Meeting notes storage

    Output: .aiwg/team/sync-agenda-{team-a}-{team-b}.md
    """
)

Create Meeting Template:

Task(
    subagent_type="scrum-master",
    description="Create reusable meeting notes template",
    prompt="""
    Create meeting notes template for recurring syncs:

    Include sections for:
    - Date and attendees
    - Blockers discussed
    - Integration updates
    - Roadmap changes
    - Demo/knowledge shared
    - Action items with owners and dates
    - Parking lot items

    Make it easy to copy/paste for each meeting.

    Output: .aiwg/team/meeting-notes-template.md
    """
)

Communicate Progress:

⏳ Establishing sync cadence...
✓ Sync structure defined: {sync-frequency} meetings
✓ Meeting agenda created: .aiwg/team/sync-agenda-{team-a}-{team-b}.md

Step 3: Blocker Tracking and Escalation Setup

Purpose: Create blocker tracking system with clear SLAs and escalation paths

Your Actions:

Launch Blocker Management Agents (parallel):

# Agent 1: Project Manager - Blocker System
Task(
    subagent_type="project-manager",
    description="Create blocker tracking system",
    prompt="""
    Design blocker tracking system:

    1. Blocker Severity Levels
       - P0 (Critical): Work stopped, no workaround
       - P1 (High): Workaround exists but suboptimal
       - P2 (Medium): Minor impact, can work on other items
       - P3 (Low): Nice to have, no immediate impact

    2. SLAs by Severity
       - P0: Resolve within 2 business days
       - P1: Resolve within 1 week
       - P2: Resolve within 2 weeks
       - P3: Best effort

    3. Tracking Fields
       - ID, Severity, Blocked Team, Blocking Team
       - Description, Owner, Opened Date, Age
       - Due Date, Status, Resolution

    4. Status Values
       - NEW, IN_PROGRESS, ESCALATED, RESOLVED, CLOSED

    Create initial blocker tracker with example entries.

    Output: .aiwg/team/blocker-tracker.md
    """
)

# Agent 2: Agile Coach - Escalation Matrix
Task(
    subagent_type="agile-coach",
    description="Define escalation paths",
    prompt="""
    Create escalation matrix:

    1. Escalation Triggers
       - Age-based (blocker open too long)
       - Severity-based (P0/P1 immediate escalation)
       - Impact-based (affecting multiple teams)

    2. Escalation Levels
       - Level 1: Tech Leads
       - Level 2: Engineering Managers
       - Level 3: Directors
       - Level 4: VPs/Executives

    3. Escalation Actions
       - Who to notify
       - Meeting to schedule
       - Communication required
       - Decision authority

    4. Response SLAs
       - How quickly escalation must be acknowledged
       - Resolution timeline after escalation

    Create clear escalation flowchart.

    Output: .aiwg/team/escalation-matrix.md
    """
)

Create Blocker Resolution Process:

Task(
    subagent_type="scrum-master",
    description="Document blocker resolution workflow",
    prompt="""
    Define end-to-end blocker resolution process:

    1. Identification
       - How blockers are identified
       - Who can raise blockers
       - Where to log them

    2. Assignment
       - How owners are assigned
       - Default ownership rules
       - Handoff process

    3. Resolution
       - Daily standup updates
       - Status tracking
       - Workaround documentation

    4. Closure
       - Verification steps
       - Retrospective for patterns
       - Process improvements

    Include example scenarios.

    Output: .aiwg/team/blocker-resolution-process.md
    """
)

Communicate Progress:

⏳ Setting up blocker management...
✓ Blocker tracker created with SLAs
✓ Escalation matrix defined: .aiwg/team/escalation-matrix.md

Step 4: Integration Planning and API Contracts

Purpose: Document API contracts and establish change management protocol

Your Actions:

Launch API Contract Documentation (for each integration point):

# For each major integration point identified in Step 1
Task(
    subagent_type="api-designer",
    description="Create API contract for {integration-point}",
    prompt="""
    Create detailed API contract:

    Integration Point: {integration-point}
    Owner: {owner-team}
    Consumer: {consumer-team}

    Document:
    1. API Specification
       - OpenAPI 3.0 format preferred
       - Endpoints, methods, parameters
       - Request/response schemas
       - Error responses

    2. Performance SLA
       - Response time targets (p50, p95, p99)
       - Throughput limits
       - Rate limiting rules

    3. Security
       - Authentication method
       - Authorization rules
       - Data encryption requirements

    4. Versioning Strategy
       - URL versioning (/v1/, /v2/)
       - Header versioning
       - Deprecation timeline

    5. Change Protocol
       - Breaking vs non-breaking changes
       - Notice period (2 sprints for breaking)
       - Migration support period

    Output: .aiwg/team/integration-contracts/api-{integration-point}.yaml
    """
)

Create Change Management Protocol:

Task(
    subagent_type="architecture-designer",
    description="Define API change management protocol",
    prompt="""
    Create comprehensive change management protocol:

    1. Change Categories
       - Additive (non-breaking): New endpoints, optional fields
       - Evolving (backward compatible): Deprecations with warnings
       - Breaking: Removing fields, changing types

    2. Process by Category
       - Additive: Deploy anytime with notice
       - Evolving: 1 sprint notice, 3 sprint deprecation
       - Breaking: 2 sprint notice, new version required

    3. Communication Requirements
       - Where to announce changes
       - Documentation updates required
       - Consumer notification process

    4. Version Support Policy
       - How many versions supported simultaneously
       - Sunset timeline for old versions
       - Migration assistance provided

    5. Testing Requirements
       - Contract testing in CI/CD
       - Consumer testing coordination
       - Rollback procedures

    Output: .aiwg/team/api-change-protocol.md
    """
)

Communicate Progress:

⏳ Documenting integration contracts...
✓ API contracts created: {count} integration points
✓ Change management protocol established

Step 5: Cross-Team Knowledge Sharing

Purpose: Facilitate demos, pattern sharing, and cross-pollination of ideas

Your Actions:

Setup Knowledge Sharing Framework:

Task(
    subagent_type="technical-lead",
    description="Create knowledge sharing structure",
    prompt="""
    Design knowledge sharing framework:

    1. Demo Cadence
       - Monthly cross-team demos
       - 60 minutes duration
       - Recording for async viewing

    2. Demo Structure
       - Team A: 25 minutes
       - Team B: 25 minutes
       - Open discussion: 10 minutes

    3. Knowledge Topics
       - Integration patterns that worked
       - Performance optimizations
       - Debugging techniques
       - Testing strategies
       - Tooling improvements
       - Incident learnings

    4. Documentation
       - Shared patterns library
       - Reusable code snippets
       - Best practices guide

    5. Collaboration Opportunities
       - Pair programming sessions
       - Architecture reviews
       - Code reviews across teams

    Create demo agenda template and knowledge base structure.

    Output: .aiwg/team/knowledge-sharing-framework.md
    """
)

Create Initial Demo Schedule:

Task(
    subagent_type="program-manager",
    description="Schedule first cross-team demo",
    prompt="""
    Plan first cross-team demo:

    1. Proposed Date/Time
       - Within next 2 weeks
       - Consider team time zones

    2. Initial Topics
       - Team A: {suggested topics based on recent work}
       - Team B: {suggested topics based on recent work}

    3. Attendee List
       - Mandatory: Tech leads, architects
       - Optional: All team members
       - Guests: Other interested teams

    4. Preparation Checklist
       - Demo environment setup
       - Slides/materials preparation
       - Recording setup

    Create calendar invite template.

    Output: .aiwg/team/first-demo-plan.md
    """
)

Communicate Progress:

⏳ Setting up knowledge sharing...
✓ Knowledge sharing framework created
✓ First demo scheduled: {date}

Step 6: Generate Cross-Team Sync Status Report

Purpose: Compile comprehensive status report with health metrics

Your Actions:

Launch Report Generation:

Task(
    subagent_type="project-manager",
    description="Generate cross-team sync status report",
    prompt="""
    Read all generated artifacts:
    - .aiwg/team/dependency-map-{team-a}-{team-b}.md
    - .aiwg/team/sync-agenda-{team-a}-{team-b}.md
    - .aiwg/team/blocker-tracker.md
    - .aiwg/team/escalation-matrix.md
    - .aiwg/team/integration-contracts/*.yaml
    - .aiwg/team/knowledge-sharing-framework.md

    Generate comprehensive status report:

    1. Executive Summary
       - Teams involved
       - Sync frequency established
       - Key dependencies identified
       - Current health status

    2. Dependency Analysis
       - Total dependencies: {count}
       - Critical (blocking): {count}
       - Documented with contracts: {percentage}%
       - Integration test coverage: {percentage}%

    3. Blocker Status
       - Active blockers: {count}
       - Average resolution time: {days}
       - Escalations this period: {count}

    4. Sync Meeting Health
       - Attendance rate: {percentage}%
       - Action items completion: {percentage}%
       - Meeting effectiveness score

    5. Integration Health
       - API contract coverage: {percentage}%
       - Breaking changes planned: {count}
       - Integration test pass rate: {percentage}%

    6. Knowledge Sharing
       - Demos conducted: {count}
       - Patterns documented: {count}
       - Cross-team code reviews: {count}

    7. Risks and Recommendations
       - Top risks identified
       - Recommended actions
       - Process improvements

    8. Next Steps
       - Immediate actions (this week)
       - Short-term (next sprint)
       - Long-term (next quarter)

    Output: .aiwg/reports/cross-team-sync-report.md
    """
)

Present Summary to User:

# You present this directly

Read .aiwg/reports/cross-team-sync-report.md

Present summary:
─────────────────────────────────────────────
Cross-Team Synchronization Setup Complete
─────────────────────────────────────────────

**Teams**: {team-a} ↔ {team-b}
**Sync Frequency**: {weekly | bi-weekly | daily}
**Status**: OPERATIONAL

**Dependencies Mapped**:
✓ Total dependencies: {count}
✓ Critical/Blocking: {count}
✓ Integration points documented: {count}

**Sync Structure Established**:
✓ Meeting cadence: {frequency}
✓ Agenda template created
✓ Mandatory attendees identified
✓ Async channels defined

**Blocker Management**:
✓ Tracking system: ACTIVE
✓ Severity levels: P0-P3 defined
✓ SLAs established
✓ Escalation matrix: 4 levels

**Integration Planning**:
✓ API contracts: {count} documented
✓ Change protocol: DEFINED
✓ Version strategy: ESTABLISHED

**Knowledge Sharing**:
✓ Demo schedule: Monthly
✓ First demo: {date}
✓ Pattern library: INITIATED

**Artifacts Generated**:
- Dependency Map (.aiwg/team/dependency-map-{team-a}-{team-b}.md)
- Sync Agenda (.aiwg/team/sync-agenda-{team-a}-{team-b}.md)
- Blocker Tracker (.aiwg/team/blocker-tracker.md)
- Escalation Matrix (.aiwg/team/escalation-matrix.md)
- Integration Contracts (.aiwg/team/integration-contracts/)
- Knowledge Framework (.aiwg/team/knowledge-sharing-framework.md)
- Status Report (.aiwg/reports/cross-team-sync-report.md)

**Immediate Actions**:
1. Schedule first sync meeting
2. Share dependency map with both teams
3. Train teams on blocker tracking process
4. Review and sign off on API contracts

**Recommendations**:
- Start with weekly sync, adjust based on needs
- Focus first meetings on critical blockers
- Document patterns from first demo
- Review sync effectiveness after 4 weeks

─────────────────────────────────────────────

Communicate Progress:

⏳ Generating status report...
✓ Cross-team sync report complete: .aiwg/reports/cross-team-sync-report.md

Quality Gates

Before marking workflow complete, verify:

Dependency map comprehensive and accurate
All integration points have documented contracts
Sync meeting structure agreed by both teams
Blocker tracking system operational
Escalation paths clear and communicated
Knowledge sharing framework established
First meetings/demos scheduled

User Communication

At start: Confirm understanding and list deliverables

Understood. I'll orchestrate cross-team synchronization between {team-a} and {team-b}.

This will establish:
- Dependency mapping and integration points
- Sync meeting cadence ({frequency})
- Blocker tracking with escalation
- API contracts and change protocol
- Knowledge sharing framework

Expected duration: 20-30 minutes.

Starting orchestration...

During: Update progress with clear indicators

✓ = Complete
⏳ = In progress
❌ = Error/blocked
⚠️ = Warning/attention needed

At end: Summary report with status and next steps (see Step 6.2 above)

Error Handling

Teams Not Found:

❌ Team not found in project roster

Teams specified: {team-a}, {team-b}
Missing: {team-name}

Action: Verify team names or add to project roster
Command: /team-roster add {team-name}

No Architecture Available:

⚠️ No architecture documentation found

Cannot automatically map dependencies without:
- Software Architecture Document
- Component diagrams
- Service definitions

Recommendation: Conduct manual dependency mapping workshop
Alternative: Create architecture first with /flow-inception-to-elaboration

Time Zone Conflict:

⚠️ Significant time zone difference detected

Team A: {timezone-1}
Team B: {timezone-2}
Overlap: {hours} hours

Recommendations:
1. Emphasize async communication
2. Rotate meeting times
3. Record all sync meetings
4. Use written updates heavily

High Blocker Volume:

⚠️ High blocker volume detected

Active blockers: {count} (threshold: 10)
P0/P1 blockers: {count}

Recommendations:
1. Increase sync frequency to daily
2. Dedicated blocker resolution session
3. Executive escalation for resource allocation
4. Consider team reorganization

Success Criteria

This orchestration succeeds when:

Dependencies fully mapped with criticality
Integration points documented with contracts
Sync cadence established and agreed
First sync meeting scheduled
Blocker tracking operational
Escalation paths defined and communicated
Knowledge sharing framework in place
Both teams trained on processes

Metrics to Track

During orchestration, track:

Dependency coverage: % of components analyzed
Integration documentation: % with contracts
Blocker age: Average days open
Meeting attendance: % of required attendees
Knowledge sharing: Patterns documented

Ongoing metrics (post-setup):

Blocker resolution velocity
Integration stability (breaking changes)
Meeting effectiveness scores
Cross-team collaboration index
Knowledge reuse rate

Common Failure Modes

Dependency Drift

Symptoms: Teams unaware of each other's changes, integration breaks Remediation:

Enforce change notification protocol
Increase sync frequency
Add pre-integration testing gate
Review and update dependency map quarterly

Meeting Fatigue

Symptoms: Attendance drops, meetings feel unproductive Remediation:

Reduce frequency if dependencies stable
Shorten meeting duration
Focus on blockers only, move other topics async
Rotate facilitator to share ownership

Blocker Stagnation

Symptoms: Blockers remain unresolved for weeks Remediation:

Escalate immediately per escalation matrix
Assign dedicated resources
Executive intervention if needed
Consider architectural changes to reduce dependencies

API Contract Violations

Symptoms: Breaking changes deployed without notice Remediation:

Implement contract testing in CI/CD
Enforce change management protocol
Post-mortem on violation
Improve contract governance

One-Way Communication

Symptoms: One team dominates sync, other team passive Remediation:

Rotate meeting facilitator between teams
Require equal time allocation
Use structured agenda strictly
Private check-in with passive team

References

Templates (via $AIWG_ROOT):

Dependency Map:

templates/analysis-design/dependency-map-template.md

Integration Contract:

templates/analysis-design/integration-contract-template.md

Blocker Card:
```
templates/management/blocker-card.md
```

Escalation Matrix:

templates/management/escalation-matrix-template.md

Sync Agenda:

templates/management/cross-team-sync-agenda-template.md

Demo Agenda:

templates/management/demo-agenda-template.md

Related Flows:

```
flow-risk-management-cycle.md
```
(for dependency risks)
```
flow-architecture-evolution.md
```
(for integration architecture)
```
flow-change-control.md
```
(for API changes)

Multi-Agent Patterns:

docs/multi-agent-coordination-pattern.md

```
docs/orchestrator-architecture.md
```