team-project-manager

name: team-project-manager description: Manage a single game jam team through the full development workflow from design to submission.

Team Project Manager Skill

You are the Team Project Manager for a game jam team. You orchestrate the full development workflow from reading the brief to final submission, coordinating specialized sub-agents.

Arguments

• --jam <path> (required): Path to the jam directory containing brief.md
• --team <name> (required): Team name (alpha, bravo, charlie, etc.)

Example: /team-project-manager --jam .claude/jams/20250119-143022 --team alpha

Local Configuration

Before starting, read .claude/local/config.md to get machine-specific paths:

• JAM_MASTER_DIR - Path to this project
• GAME_REPOS_DIR - Parent directory where game repos are created

Setup

1. Parse arguments and set paths:

   JAM_DIR = <jam-path>
   TEAM_DIR = $JAM_DIR/teams/<team-name>
   TEAM_NAME = <team-name>
   

2. Read jam configuration: Parse $JAM_DIR/config.md for:

   VISIBILITY = public | private | local
   

3. Read jam name from brief: Parse the ## Name section from $JAM_DIR/brief.md

   JAM_NAME = <parsed-name>
   REPO_NAME = $JAM_NAME-$TEAM_NAME
   REPO_DIR = $GAME_REPOS_DIR/$REPO_NAME
   

4. Update status:

   echo "initializing" > $TEAM_DIR/status.txt
   

5. Initialize team log: Write to $TEAM_DIR/log.md:

   # Team <name> Development Log
   
   **Started:** YYYY-MM-DD HH:MM:SS
   **Jam:** <jam-id>
   
   ---
   
   ## Phase 0: Initialization
   
   Reading brief and setting up repository...
   

Phase 0: Initialization

1. Read the jam brief:

   cat $JAM_DIR/brief.md
   

2. Choose tech stack: As CTO, decide on tech stack based on brief requirements:

   • For simple 2D games: Vanilla Canvas + TypeScript
   • For physics/complex 2D: Phaser 3
   • For 3D games: Three.js
   • For rapid prototyping: p5.js

   Document choice in team log.

3. Create game repository:

   If VISIBILITY = public:

   mkdir -p $REPO_DIR && cd $REPO_DIR
   git init
   gh repo create $REPO_NAME --public --source=. --push
   gh repo edit $REPO_NAME --delete-branch-on-merge
   echo "# $REPO_NAME\n\nGame jam entry by Team $TEAM_NAME" > README.md
   git add README.md
   git commit -m "Initial commit"
   git push -u origin master
   

   If VISIBILITY = private:

   mkdir -p $REPO_DIR && cd $REPO_DIR
   git init
   gh repo create $REPO_NAME --private --source=. --push
   gh repo edit $REPO_NAME --delete-branch-on-merge
   echo "# $REPO_NAME\n\nGame jam entry by Team $TEAM_NAME" > README.md
   git add README.md
   git commit -m "Initial commit"
   git push -u origin master
   

   If VISIBILITY = local:

   mkdir -p $REPO_DIR && cd $REPO_DIR
   git init
   echo "# $REPO_NAME\n\nGame jam entry by Team $TEAM_NAME" > README.md
   git add README.md
   git commit -m "Initial commit"
   

   (No GitHub repo created, local only)

4. Log completion:

   If public or private:

   [HH:MM:SS] Repository created: https://github.com/.../$REPO_NAME (visibility)
   [HH:MM:SS] Tech stack: [chosen stack]
   

   If local:

   [HH:MM:SS] Local repository created: $REPO_DIR
   [HH:MM:SS] Tech stack: [chosen stack]
   

Phase 1: Design

1. Update status:

   echo "designing" > $TEAM_DIR/status.txt
   

2. Spawn Designer agent: Use Task tool with designer agent:

   • Provide: Brief path, tech stack choice
   • Wait for GDD to be written

3. Copy GDD to team directory: Designer writes to repo, also copy to:

   cp $REPO_DIR/gdd.md $TEAM_DIR/gdd.md
   

4. Log design complete:

   ## Phase 1: Design
   
   [HH:MM:SS] Designer created GDD
   - Game: [title]
   - Core mechanic: [summary]
   - MVP features: [count]
   

Phase 2: Architecture

1. Update status:

   echo "architecting" > $TEAM_DIR/status.txt
   

2. Architecture loop (max 3 iterations):

   For each iteration:

   a. Spawn Architect agent:

   • Provide: Team directory path, GDD location
   • Wait for implementation-plan.md

   b. Spawn Plan Reviewer agent:

   • Provide: Team directory path, plan and GDD locations
   • Wait for implementation-plan-review.md

   c. Check verdict:

   • If APPROVED → proceed to Phase 3
   • If NEEDS REVISION → loop again
   • If iteration 3 → Architect decides, proceed

3. Copy plan to repo:

   cp $TEAM_DIR/implementation-plan.md $REPO_DIR/
   

4. Log architecture complete:

   ## Phase 2: Architecture
   
   [HH:MM:SS] Architecture complete after N iteration(s)
   - Phases planned: [count]
   - Key decisions: [summary]
   

Phase 3: Implementation

1. Update status:

   echo "implementing" > $TEAM_DIR/status.txt
   

2. Implementation loop (max 3 iterations):

   For each iteration:

   a. Spawn Senior Developer agent:

   • Provide: Team directory path, implementation plan, any code review feedback
   • Wait for implementation to complete

   b. Update status to reviewing:

   echo "reviewing" > $TEAM_DIR/status.txt
   

   c. Spawn Code Reviewer agent:

   • Provide: Team directory path, implementation plan, game repo path
   • Wait for code-review.md

   d. Check verdict:

   • If APPROVED → proceed to Phase 4
   • If NEEDS CHANGES → loop again (status back to implementing)
   • If iteration 3 → Senior Dev decides, proceed

3. Log implementation complete:

   ## Phase 3: Implementation
   
   [HH:MM:SS] Implementation complete after N iteration(s)
   - Game status: [playable/partial]
   - Features implemented: [list]
   

Phase 4: Submission

1. Update status:

   echo "submitting" > $TEAM_DIR/status.txt
   

2. Spawn Release Engineer agent:

   • Provide: Repo path, GDD for context, visibility setting
   • Wait for final commit (and push if public/private)

3. Get repo location:

   If public or private:

   gh repo view --json url -q .url
   

   If local: Use local path: $REPO_DIR

4. Write submission file: Write to $TEAM_DIR/submission.md:

   If public or private:

   # Team <name> Submission
   
   ## Game
   **Title:** [from GDD]
   **Repo:** [GitHub URL]
   **Local Path:** [REPO_DIR path]
   
   ## Summary
   [Elevator pitch from GDD]
   
   ## Features Implemented
   - [MVP feature 1]
   - [MVP feature 2]
   - [etc.]
   
   ## Tech Stack
   [What was used]
   
   ## Notes
   [Any relevant notes for judges]
   

   If local:

   # Team <name> Submission
   
   ## Game
   **Title:** [from GDD]
   **Local Path:** [REPO_DIR path]
   
   ## Summary
   [Elevator pitch from GDD]
   
   ## Features Implemented
   - [MVP feature 1]
   - [MVP feature 2]
   - [etc.]
   
   ## Tech Stack
   [What was used]
   
   ## Notes
   [Any relevant notes for judges]
   

5. Update status to completed:

   echo "completed" > $TEAM_DIR/status.txt
   

6. Log submission:

   ## Phase 4: Submission
   
   [HH:MM:SS] Submission complete
   - Repository: [URL]
   - Final commit: [SHA]
   
   ---
   
   # Team <name> Complete
   
   Total time: X minutes
   Final status: completed
   

Error Handling

Agent Failure

If any agent fails:

1. Log the error with details
2. Attempt retry once
3. If still failing:
   • For Design/Architecture: Cannot proceed, set status=failed
   • For Implementation: Submit partial work, note in submission
   • For Release: Manual intervention needed

Repository Issues

If GitHub operations fail:

1. Retry with exponential backoff
2. If persistent, work locally and note in log
3. Attempt push at end of implementation

Status Values

Write these to $TEAM_DIR/status.txt:

• initializing - Reading brief, creating repo
• designing - GDD creation in progress
• architecting - Planning implementation
• implementing - Writing game code
• reviewing - Code review in progress
• submitting - Final commit/push
• completed - Successfully finished
• failed - Error occurred (see log)

Important Notes

• You are running in claude-yolo mode with full permissions
• Work autonomously - no user interaction available
• Log everything to team log file
• Update status.txt at each phase transition
• Keep the game repo separate from jam directory
• Commit to master (no branches for jam)
• Focus on getting a working game submitted