pair-programming-rounds

Pair Programming Rounds

A Claude Code plugin for structured pair programming. Instead of delegating work entirely to Claude, this skill organizes sessions into collaborative rounds with explicit task ownership, keeping you in the driver's seat.

What it does

• Rounds — Each round starts with collaborative brainstorming to shape the work
• Phases — Work is broken into phases with tasks assigned to you, Claude, or both
• Retros — Every round ends with a lightweight retrospective to tune working styles, ownership splits, and pacing
• Check-ins — Tiered summaries after each task (status line), at phase boundaries (compact view), and on request (full detail)
• Advanced brainstorming — Goes beyond surface-level planning: challenges assumptions, explores edge cases, maps constraints, and identifies risks before any code is written
• Plan verification — Every plan is checked against a 5-point checklist (completeness, ordering, ownership clarity, testability, scope match) before execution begins
• Active engagement — Claude uses recommend-and-probe patterns, always noting alternatives considered and asking real questions — not "sound good?"
• Subagent dispatch — Claude manages the session and dispatches coding work to focused subagents, keeping its context clean for conversation
• Persistence — Progress is saved to disk with YAML frontmatter so nothing gets lost between sessions or context compactions
• Live dashboard — Optional companion dashboard that watches the progress file and renders a persistent browser view
• Tufte visualizations — Self-contained HTML visualizations using pre-built templates for dependency maps, state machines, treemaps, and more
• Testing — Defaults to RED-GREEN TDD, confirms testing strategy with you before writing code

Install

# Add the marketplace
/plugin marketplace add jah2488/pair-programming-rounds

# Install the plugin
/plugin install pair-programming-rounds

Optional: Live Dashboard

The dashboard watches your progress file and renders a live view in your browser. To use it, you need to run it from the plugin's tools/ directory (or copy dashboard.js and package.json somewhere convenient):

# From the plugin directory:
node tools/dashboard.js /path/to/your/project

# Or if you copied the files:
node dashboard.js /path/to/your/project

Then open http://localhost:3456. The page auto-refreshes when the progress file changes.

Usage

Start any session with something like:

• "Let's pair on adding an inventory system"
• "Let's work on refactoring the event handler"
• "I want to build a combat system, let's pair"

Claude will walk you through the structure and start brainstorming.

Architecture

┌─────────────────────────────────────────────────┐
│  Main Skill: pair-programming-rounds             │
│  Role: Session manager + conversation partner    │
│  - Round/phase/task lifecycle                    │
│  - Brainstorming, check-ins, retros             │
│  - Dispatches work to subagents                  │
│  - Writes progress file (YAML frontmatter + MD) │
└──────────┬──────────────┬───────────────────────┘
           │              │
    ┌──────▼──────┐ ┌─────▼──────────┐
    │ Code Worker │ │ Viz Generator  │
    │ (subagent)  │ │ (subagent)     │
    │ - Reads code│ │ - Fills HTML   │
    │ - Writes    │ │   templates    │
    │   impl      │ │ - Writes .html │
    │ - Runs tests│ │                │
    └─────────────┘ └────────────────┘

The main skill stays focused on managing the session and conversation. When coding work needs to happen, it dispatches to a subagent that gets a clean context window dedicated to that task. When visualizations are needed, another subagent fills a pre-built HTML template with data.

This means the session manager isn't carrying implementation details in its context, and the coding subagents aren't burdened with session management rules.

How it works

flowchart TD
    S[Session Start] --> RP{Progress file exists?}
    RP -->|yes| Resume[Resume from saved state]
    RP -->|no| Fresh[Fresh start]
    Resume --> Confirm[Confirm state with user]
    Confirm --> R
    Fresh --> Explain[Explain structure:\nRounds contain Phases contain Tasks]
    Explain --> R

    subgraph R [Round]
        direction TB
        B[Brainstorm] --> Explore[Explore & plan\nmax 2 questions per message]
        Explore --> Test[Confirm testing strategy]
        Test --> Checklist{All checked?\nTasks · Owners · Scope\nPhases · Explored · Testing}
        Checklist -->|no| Explore
        Checklist -->|yes| Formalize[Formalize plan\nto docs/plans/]
        Formalize --> Verify{Plan verified?\nComplete · Ordered · Owned\nTestable · Scoped}
        Verify -->|issues| Formalize
        Verify -->|yes| P1