Workshops: Agentic Coding Tools in Depth

Claude Code Subagents & Git Worktrees: Parallel Agents Workshop

One Claude Code session working through one task at a time is only the starting point. Teams that want more throughput use specialised subagents for research, testing and review and let several sessions work in parallel in separate git worktrees. This workshop shows how to decompose work so parallel agents help instead of colliding, and how a developer stays in control of the result.

Who is this workshop for?

  • Experienced Claude Code users who hit the limits of a single session
  • Senior developers and tech leads planning larger features or refactorings
  • Teams with well-tested codebases that want more parallel throughput
  • Developer experience engineers defining shared subagents for the organisation
  • Architects who want to split agent work along module boundaries

What you will take away

  • Define project subagents with their own instructions, tool restrictions and a suitable model.
  • Keep the main context lean by sending exploration, log analysis and test runs to subagents that return only a summary.
  • Run several Claude Code sessions in parallel in separate git worktrees, each with its own branch, dependencies and dev server.
  • Break a feature into independent, verifiable work packages with clear interfaces before any agent starts coding.
  • Integrate parallel results through small pull requests and a final review pass instead of one huge merge.

Agenda

  1. Module 1

    Why one session is not enough

    • Context window limits and why long sessions drift
    • Delegation versus parallelism: two different problems
    • Proven roles: explorer, implementer, tester, reviewer
  2. Module 2

    Subagents in Claude Code

    • Anatomy of a subagent definition: description, prompt, tools, model
    • Exercise: a read-only codebase explorer and a test runner
    • Descriptions that make the main agent delegate at the right moment
  3. Module 3

    Parallel sessions with git worktrees

    • One worktree and branch per task; separating ports, env files and dependencies
    • Exercise: three sessions on one repository without conflicts
    • Headless sessions for batch tasks across many packages
  4. Module 4

    Decomposing and orchestrating work

    • Slicing features along module and interface boundaries
    • Plan first: a task list or spec as the coordination point
    • Exercise: plan, distribute and track a multi-part change
  5. Module 5

    Integration and review

    • Merge order, conflicts and rebasing agent branches
    • A reviewer subagent as a second pair of eyes, not the last one
    • How many parallel sessions one person can really supervise

Where parallel agents pay off, and where they don't

Parallel sessions shine with independent work: separate endpoints, isolated components, test coverage for different modules, or the same migration repeated across many packages. They fail when tasks touch the same files, depend on decisions nobody has made yet, or when the team cannot review output as fast as the agents produce it.

  • Good fit: repetitive changes across modules, test generation, documentation, isolated bug fixes
  • Poor fit: core domain logic in flux, cross-cutting refactorings without tests, unclear requirements

The developer stays the conductor

Five parallel sessions do not mean five times the output if nobody can follow what each one is doing. We practise a supervision rhythm: precise task briefs, checkpoints, short status summaries from every session and a fixed point where a person reviews and decides what gets merged.

neooutput AI Code Engineers run the day with your repository or a sandbox clone, on-site or online, in German or English. You need a codebase with a working test suite; we can provide a practice project if yours cannot be used.

Frequently asked questions

Do subagents increase cost?

Each subagent works with its own context, so delegation consumes additional tokens. Overall it often saves cost because the main session stays shorter and focused. We show how to pick smaller models for routine subagents and how to watch usage.

Aren't separate branches enough?

Branches alone share one working directory, so two sessions would overwrite each other's files. Worktrees give every session its own directory on its own branch while sharing the repository history. Containers and separate clones are alternatives we also discuss.

Does this only work with Claude Code?

The worktree approach is tool-agnostic and works with OpenAI Codex, Cursor or other terminal agents too. Subagent definitions are specific to Claude Code; we briefly map comparable concepts in other tools.

Workshop

Get in touch

Which part of your backlog could three agents work on in parallel?

Tell us roughly how many people will join and pick dates that work – we will get back to you within 24 hours with a proposal for content, format and schedule.

Prefer to talk first?

15 minutes, free and without obligation – with our AI Trainers and AI Code Engineers.

Book a call for free (opens in new tab) +49 761 519 751 50 (24/7)

Request a training / workshop

Workshop: Claude Code Subagents & Git Worktrees: Parallel Agents Workshop · 1 day

Dates that work for you (optional)

Suggestions about 2 weeks ahead – pick as many as you like

Reply usually within 24 hours · jocapps is ISO 27001 certified · Privacy