Agent Config Adapter

---
name: Parallel Dev Work
description: Orchestrated parallel feature development where the outer Claude Code session plans, spawns, monitors, and merges work from multiple inner sessions. Use when user says "parallel dev work", "implement in parallel", "batch work", or provides multiple GitHub tickets/issues to work on simultaneously.
allowed-tools: Bash, Write, Read, Edit, Grep, Glob, Task, Skill, SlashCommand, WebSearch, WebFetch, mcp__jina__*, Bash(gh:*), Bash(git:*), Bash(tmux:*)
---

# Parallel-Dev-Work Skill

Orchestrated parallel feature development where the outer Claude Code session
plans, spawns, monitors, and merges work from multiple inner sessions.

## Trigger Phrases

- "Parallel dev work on [features]"
- "Implement [feature1], [feature2], [feature3] in parallel"
- "Dev work in parallel: [task list]"
- GitHub references: "#42, #43, #44" or "GH-42, GH-43"
- "Work on these tickets: [URLs]"

---

# Autonomous Dev Work

## **Flow:** Plan → Independent Review → Parallel TMUX → Cleanup

## Workflow Phases

### Phase 0: Reconnaissance

Check if planning already exists:

```bash
# Check for existing taskNotes
ls taskNotes/*/taskFindings.md 2>/dev/null
```

- **If taskNotes exist** → Skip to Phase 3 (spawn sessions)
- **If no taskNotes** → Start with Phase 1 (planning)

---

### Phase 1: Planning (Outer Claude)

For EACH feature in the parallel request, run planning:

```
/codePlanner {feature-1}
/codePlanner {feature-2}
/codePlanner {feature-3}
```

This creates:

- `taskNotes/{feature-1}/taskFindings.md`
- `taskNotes/{feature-2}/taskFindings.md`
- `taskNotes/{feature-3}/taskFindings.md`

**CRITICAL**: Do NOT ask user to review plans. Do NOT wait for approval. Proceed
immediately to Phase 2.

---

### Phase 2: Plan Digest & Human Checkpoint

Extract key signals from each `taskFindings.md` and present digest:

### Extract Signals

Read the plan at `{taskFindings.md path}` and extract ONLY these signals. No
opinions, no recommendations — just extract facts.

Understand that the plan must have `Origina Ask` h2 section.

The rest of the plan is the plan and Original Ask is my requirements.

Ultrathink and analyze the plan against Original Ask to extract these signals:

- Any gaps
- Edge Case
- Potential Bugs
- Can the plan be simplified while still meeting Original Ask?

Respond in this EXACT format:

---
**📋 Plan Digest: {task-name}**

| Signal | Value |
|--------|-------|
| Complexity | Score and summarized reason |
| Gaps found | {list} OR "None" |
| Edge cases | {list} OR "None" |
| Potential bugs | {list} OR "None" |
| Simplifications possible | {yes/no} + brief explanation |
| External deps added | {list} OR "None" |
| Highest risk | {single riskiest part of the plan} |
| Files touched | {count}: {comma-separated list} |
| New abstractions | {count}: {names} OR "None" |
| Existing code modified | {Yes — what / No — additive only} |

**Rejected alternatives:** {what simpler approaches were considered but skipped, and the stated reason — or "None mentioned"}

**Watch for:** {flag anything unusual: schema migrations, auth changes, new patterns, broad refactors — or "Nothing unusual"}
---

### Present & Wait

Display the extracted digest to user. Then show:

```
Ready? [g]o · [t]weak: {feedback} · [r]eject/show full plan
```

**WAIT for user input. Do not proceed autonomously.**

### Handle Response

| Input                                  | Action                                                                |
| -------------------------------------- | --------------------------------------------------------------------- |
| `g`, `go`, `yes`, 👍                   | Proceed to Phase 3 (YOLO)                                             |
| `t: {feedback}` or `tweak: {feedback}` | Update taskFindings.md per feedback, re-run extraction, present again |
| `r`, `reject`, `plan`, `show`          | Display full taskFindings.md, wait for further input                  |
| `stop`, `cancel`                       | Abort workflow                                                        |

### Phase 3: Setup Parallel Sessions (Outer Claude)

#### Step 3.1: Create Full Checkouts

```bash
# For each feature
git clone . agent-{feature-1}/
git clone . agent-{feature-2}/
git clone . agent-{feature-3}/

# Create feature branches in each
cd agent-{feature-1} && git checkout -b feat/{feature-1} && cd ..
cd agent-{feature-2} && git checkout -b feat/{feature-2} && cd ..
cd agent-{feature-3} && git checkout -b feat/{feature-3} && cd ..
```

#### Step 3.2: Spawn tmux Sessions

```bash
# Create sessions
tmux new-session -d -s agent-1 -c agent-{feature-1}/
tmux new-session -d -s agent-2 -c agent-{feature-2}/
tmux new-session -d -s agent-3 -c agent-{feature-3}/

# Start Claude in each
tmux send-keys -t agent-1 'claude' C-m
tmux send-keys -t agent-2 'claude' C-m
tmux send-keys -t agent-3 'claude' C-m
```

#### Step 3.3: Provide Task to Each Session

Attach to each session and run:

```
/startWork taskNotes/{feature}/taskFindings.md, mode: autonomous
```

Or for cloud handoff (remember: no slash commands on cloud):

```bash
# Commit and push first
cd agent-{feature}
git add . && git commit -m "WIP: starting {feature}"
git push -u origin feat/{feature}
cd ..
```

Then in that session, use & to hand off

---

### Phase 4: Monitor & Collect (Outer Claude)

#### Check Local Sessions

```bash
# Quick status
for s in agent-1 agent-2 agent-3; do
  echo "=== $s ==="
  tmux capture-pane -t $s -p -S -30 2>/dev/null | tail -10
  echo ""
done
```

## Anti-Patterns (DO NOT)

- ❌ Ask user to review each plan individually (present digest instead)
- ❌ Ask user to run `/startWork` or `/completeWork` (do it yourself)
- ❌ Implement work in outer Claude Code (delegate to inner sessions)
- ❌ Run `/completeWork` per feature (run once at end for all)
- ❌ Use worktrees instead of full checkouts (conflicts risk)
- ❌ Expect slash commands on cloud sessions (they don't have them)
- ❌ Hand off to cloud without pushing first (will fail)
- ❌ Keep failed sessions running indefinitely (abandon at ~10-20%)

---

## Best Practices (DO)

- ✅ Plan thoroughly in outer (has GitHub, web, memory access)
- ✅ Use full git checkouts for true isolation
- ✅ Present concise digest, not full plans
- ✅ Use local tmux for slash command workflows
- ✅ Use cloud only for long-running implementation
- ✅ Monitor sessions periodically
- ✅ Accept 10-20% abandonment as normal
- ✅ Merge via PRs for team repos
- ✅ Run single `/completeWork` after all merges
- ✅ Cleanup checkouts after successful merge

---

## Example Invocation

**User**: "Parallel dev work on authentication, API rate limiting, and dashboard
redesign"

**Outer Claude**:

1. Runs `/codePlanner authentication`, `/codePlanner rate-limiting`,
   `/codePlanner dashboard`
2. Presents digest table
3. On "go": Creates 3 checkouts, spawns 3 tmux sessions
4. Provides `/startWork` to each
5. Monitors progress, handles any abandonments
6. Merges completed features
7. Runs `/completeWork` for all
8. Cleans up

---

## Related Skills

- **agent-scaling**: Lower-level session management (called by this skill)
- **codePlanner**: Planning phase execution
- **startWork**: Inner session work initiation
- **completeWork**: Final verification and documentation

No companion files

Add companion files to enhance this skill