← 22.323.1 →
2082 words No Slides

Video 22.4: Community Tools and Automation

Course: Claude Code - Parallel Agent Development (Course 4) Section: S22 - Git Worktrees and Manual Patterns Video Length: 4-5 minutes Presenter: Daniel Treasure

Opening Hook

The manual approach works, but it doesn't scale. Once you're coordinating multiple agents, task assignments, merging, and tracking progress, you're managing a lot. Fortunately, the community has built powerful tools to automate this. Let's explore agentree, ccswarm, Crystal, and others — and see how they simplify parallel development.

Key Talking Points

What to Say: The Tool Landscape

  • agentree: Automated worktree orchestration with hooks. Sets up worktrees, handles branching, runs setup scripts per worktree. Great for standardized projects where every worktree needs the same environment.
  • ccswarm: Full multi-agent orchestration with specialized agent pools (Frontend, Backend, DevOps, QA). Built-in task templating and role-based assignment. Best for large teams or complex projects.
  • Crystal: Desktop GUI for managing multiple Claude Code sessions in parallel. Launch sessions, see all worktrees in one app, assign tasks visually. Great if you prefer not touching the terminal.
  • parallel-cc: Automated parallel management of Claude Code instances. Simpler than ccswarm, lighter-weight. Good middle ground between manual and full orchestration.
  • clash: Merge conflict detection across worktrees. Early warning system for overlapping work. Can be used standalone or integrated into other tools.
  • ccpm: Project management for parallel development. GitHub Issues integration, task tracking, agent assignment. Pairs with any orchestration tool.

What to Say: When to Use Tools vs. Manual

  • Go manual if: You have 1-3 agents, clearly separated work, don't need heavy automation. The manual pattern (worktrees + tmux) works perfectly.
  • Go agentree if: You want automated setup but keep orchestration simple. Each worktree is a clone of the others; you just need consistency.
  • Go ccswarm if: You have 5+ agents, specialized roles, complex workflows, and want the tool to manage task distribution and merging.
  • Go Crystal if: You prefer GUI interaction, don't want terminal management, or are new to tmux and worktrees.
  • Mix and match: You can use clash with any approach. You can use ccpm for task tracking while using manual worktrees. Tools are composable.

What to Show on Screen: Installation and Quick Demo

  • Show the installation process for one major tool (agentree or ccswarm, depending on what's easiest to demonstrate)
  • Show how it simplifies worktree creation (one command instead of multiple)
  • Show how it automates branching and setup
  • Demonstrate assigning a task through the tool's interface
  • Show it launching Claude Code sessions automatically
  • Show the merge/integration phase and how the tool handles it
  • Optionally show Crystal's GUI if time permits

Demo Plan

Timing: ~2.5 minutes for demo (focused on one tool for clarity)

Recommendation: Feature agentree or ccswarm

For this demo, we'll showcase agentree (simpler, clearer for viewers new to tools). If you prefer ccswarm (more full-featured), adjust the commands accordingly.

Step 1: Install agentree (1 minute)

  1. Show the installation command (from agentree docs):
  2. npm install -g agentree (or equivalent for your platform)
  3. Or: pip install agentree (if Python-based)
  4. Or: brew install agentree (if available on macOS)
  5. Verify installation: agentree --version
  6. Explain: agentree is now available globally

Step 2: Initialize agentree for a Project (1 minute)

  1. Navigate to a test project repo: cd ~/test-project
  2. Verify the project is a Git repo: git status
  3. Initialize agentree: agentree init
  4. Show the output: agentree creates a config file (e.g., agentree.json or .agentree/config.yaml)
  5. Optionally show the config file: cat agentree.json
  6. Explain: this config defines how worktrees are created and set up

Step 3: Create Multiple Worktrees with agentree (1 minute)

  1. Use agentree to create worktrees automatically:
  2. agentree create auth — creates a worktree for auth feature
  3. agentree create database — creates a worktree for database feature
  4. (or agentree create --count 2 to create multiple at once)
  5. Show the output: agentree creates branches, sets up directories, runs setup hooks
  6. Verify: git worktree list — shows all worktrees created by agentree
  7. Optionally show the directory structure: ls -la to see new worktree directories

Step 4: List and Assign Tasks (1 minute)

  1. List current worktrees and their status:
  2. agentree status or agentree list
  3. Show the output: each worktree listed with its branch, status, and assigned agent (if any)
  4. Assign a task to a worktree (syntax depends on agentree):
  5. agentree assign auth "Implement user authentication service"
  6. agentree assign database "Design user and role tables"
  7. Show the confirmation: tasks are now tracked in agentree

Step 5: Launch Parallel Claude Sessions (1 minute)

  1. Use agentree to launch Claude Code sessions:
  2. agentree run-agents or agentree launch
  3. (This either opens Claude in each worktree, or shows you the commands to run)
  4. If agentree launches them directly, show multiple Claude windows opening
  5. If it shows commands, show the commands and explain you'd run them in separate terminals/tmux panes
  6. Verify: Claude is running in each worktree, aware of its assigned task

Step 6: Monitor and Merge with agentree (45 seconds)

  1. Show agentree's monitoring interface:
  2. agentree monitor or similar
  3. Show stats: number of agents running, commits per worktree, detected conflicts
  4. When agents are done (or for demo purposes), trigger merge:
  5. agentree merge or agentree integrate (merges all worktrees back to main)
  6. Show the merge progress and final result
  7. Explain: agentree handled merging and conflict resolution automatically (or flagged conflicts for you to resolve)

Alternative: Brief Mention of Other Tools (30 seconds)

If you have extra time, quickly show the others: - ccswarm: ccswarm init and ccswarm orchestrate — more complex setup, more powerful - Crystal: Show the desktop app launching and managing worktrees visually - parallel-cc: Show a simpler command (parallel-cc run) for managing multiple instances

Code Examples & Commands

agentree Usage

# Install agentree
npm install -g agentree
# or
pip install agentree
# or
brew install agentree

# Initialize for a project
cd ~/my-project
agentree init

# Create worktrees
agentree create feature-1
agentree create feature-2
agentree create --count 3   # Create multiple at once

# List worktrees and status
agentree list
agentree status

# Assign tasks
agentree assign feature-1 "Implement authentication"
agentree assign feature-2 "Design database schema"

# Launch Claude sessions
agentree run-agents
# or individually
agentree run feature-1
agentree run feature-2

# Monitor progress
agentree monitor
agentree status

# Merge and integrate
agentree merge
agentree integrate

ccswarm Usage (Alternative)

# Install ccswarm
npm install -g ccswarm

# Initialize with templates
ccswarm init --template "web-app"

# Create agent pool
ccswarm add-agent Frontend
ccswarm add-agent Backend
ccswarm add-agent DevOps

# Assign task to agent pool
ccswarm assign "Frontend" "Build login page"
ccswarm assign "Backend" "Create user API endpoints"

# Run orchestration
ccswarm orchestrate

# View progress
ccswarm watch

# Merge results
ccswarm merge-all

Crystal (Desktop App)

# Install Crystal
brew install crystal-ai  # macOS
# or download installer from GitHub

# Launch Crystal
crystal

# Inside the app:
# - Create worktrees visually
# - Assign tasks with drag-and-drop
# - Launch Claude sessions with one click
# - Monitor all agents in a dashboard
# - Merge when ready

parallel-cc Usage

# Install parallel-cc
npm install -g parallel-cc

# Run agents in parallel
parallel-cc run --agents 2 --project ~/my-project

# Or with more control
parallel-cc create feature-a
parallel-cc create feature-b
parallel-cc start-all
parallel-cc monitor

clash Integration

# Clash can work standalone or with orchestration tools

# Scan worktrees for conflicts
clash scan

# Detailed conflict report
clash report --verbose

# Integrate with agentree workflow (if supported)
agentree merge --conflict-check  # Uses clash before merging

Gotchas & Tips

Common Pitfalls

  • Over-engineering for simple projects: If you only have 1-2 agents, the manual approach (worktrees + tmux) is simpler than learning a new tool. Don't add complexity you don't need.
  • Tool versions and maintenance: Community tools are great but may lag behind Claude Code updates. Check that your tool version supports your Claude Code version.
  • Configuration complexity: Tools like ccswarm are powerful but have learning curves. Budget time for learning if you're adopting them.
  • Lock-in: Some tools have specific workflows. If you switch tools later, migrating your setup can be annoying. Keep it simple if possible.
  • Merge conflicts still happen: Tools automate worktree setup and launching, but they don't eliminate merge conflicts. You still need good task design.

Pro Tips

  • Start manual, add tools when needed: Learn the manual pattern first (videos 22.1-22.3). Once you understand it, tools become much more useful because you know what they're automating.
  • Combine tools: Use agentree for worktree setup, clash for conflict detection, and ccpm for task tracking. Each tool does one thing well.
  • Read the docs: Community tools evolve. Always check the latest documentation for your tool before recording or teaching.
  • Test beforehand: If you're demoing a specific tool, install and test it on your demo repo before recording. Tool setups can be finicky.
  • Keep backups: Before using any new tool in a real project, back up your repo. Some automated merge tools might not do what you expect.

When to Recommend Each Tool

Tool Best For When to Skip
agentree Standardized projects, simple automation Complex workflows, specialized roles
ccswarm Large teams, specialized agents, complex workflows Small projects, simple splits
Crystal GUI-first users, visual task management Terminal-friendly devs, headless servers
parallel-cc Lightweight parallel running Complex orchestration needs
clash Conflict detection (any workflow) No overlap work (unlikely in practice)
ccpm Task tracking, GitHub integration Simple projects, no formal PM

Lead-out

Now you've seen the full spectrum: from manual worktree management (simple, clear) to full orchestration platforms (powerful, complex). The right choice depends on your project's scale and complexity. Whether you go manual or automated, the foundation is always the same: Git worktrees, Claude Code, and thoughtful task design. Use the tools to remove toil, not to hide confusion.

That wraps up Section 22: Git Worktrees and Manual Patterns. In Section 23, we'll move to more advanced topics: orchestrating agents across distributed systems, managing state and coordination, and building custom orchestration with the Claude Agent SDK. See you there.

Reference URLs

Prep Reading

  • Browse the README and quick-start of at least 2 tools (agentree and ccswarm recommended)
  • Install the tool you'll demo before recording (test on your demo project)
  • Skim the features of the other tools so you can explain them during the video
  • Check GitHub stars and activity to mention which tools are most actively maintained
  • Look for any recent blog posts or community discussions about these tools

Notes for Daniel

This video is a landscape overview followed by a deep demo of one tool. Don't try to demo all tools in 5 minutes — it'll feel rushed. Pick one (agentree is simplest to understand), walk through it smoothly, then mention the others and when you'd use them.

The key insight is: tools automate the tedious parts (worktree setup, session launching, merging) but don't remove the core challenge (good task design, conflict prevention). Emphasize this.

When demoing the tool, make sure it feels natural and works cleanly. If you run into errors or verbose output, that kills the vibe. Test thoroughly beforehand.

The table at the end (when to recommend each tool) is super useful for viewers. You can show it as a slide or reference it verbally. It helps people make a real choice.

At the end, emphasize that Section 22 was about patterns (manual) and tooling (automated), but the real skill is knowing when to use which. A viewer watching this series should feel confident doing parallel development either way: with tmux and git commands, or with a tool that automates it.

Optional: If you have time, show a quick before-and-after comparison: setting up parallel agents manually (5 minutes of commands) vs. with a tool (one command). Drives home the value.