Time to level up: 3-4 weeks
User: "Add email validation, rate limiting, and audit logging"
AI: *plans email validation*
*implements email validation*
*plans rate limiting*
*implements rate limiting*
*plans audit logging*
*implements audit logging*
"Done—all three features implemented"
User: "Add email validation, rate limiting, and audit logging.
These are independent—use dispatching-parallel-agents."
AI: *invokes dispatching-parallel-agents*
*Agent 1: email validation* (runs in parallel)
*Agent 2: rate limiting* (runs in parallel)
*Agent 3: audit logging* (runs in parallel)
*waits for all to complete*
*aggregates results*
"All 3 features implemented in parallel. Summary:
- Email validation: ✓ (12 tests)
- Rate limiting: ✓ (8 tests)
- Audit logging: ✓ (6 tests)"
dispatching-parallel-agentsUse when you have 2+ independent tasks.
Launches multiple agents in parallel for work that doesn't share state or have sequential dependencies.
"Use dispatching-parallel-agents for these independent tasks"
When to use:
subagent-driven-developmentUse when executing plans with independent tasks in the current session.
Keeps main context clean by delegating implementation to focused subagents.
"Use subagent-driven-development to execute this plan"
When to use:
using-git-worktreesUse when you need isolation for parallel work.
Creates isolated git worktrees so parallel agents don't conflict.
"Use using-git-worktrees to create isolated workspace"
When to use:
Before starting your next 10 tasks, ask: "Is there independent work here?"
Train your eye to spot parallelizable work:
| Sequential (dependencies) | Parallel (independent) |
|---|---|
| Build → Test → Deploy | Feature A + Feature B + Feature C |
| Create table → Insert data | Investigate bug + Write docs |
| Parse input → Transform → Output | Frontend change + Backend change (different endpoints) |
Practice: For each task, write down:
Even if you don't use parallel agents yet, build the habit of analyzing task graphs.
Find a real task with 2+ independent subtasks and run them in parallel.
Start simple:
"I need to:
1. Add input validation to UserController
2. Add input validation to OrderController
3. Update the API documentation for both
These are independent. Use dispatching-parallel-agents."
What to notice:
For your next complex task, use subagent-driven-development.
Instead of:
User: "Implement this 5-phase plan"
AI: *implements phase 1 in main context*
*implements phase 2 in main context*
*context gets cluttered with implementation details*
Try:
User: "Use subagent-driven-development to implement this plan"
AI: *dispatches subagent for phase 1*
*dispatches subagent for phase 2*
*main context stays clean with just summaries*
"All phases complete. Here's the summary..."
The benefit: Your main conversation stays focused on outcomes, not implementation noise.
Complete 3 tasks using parallel agents where you previously would have gone sequential.
For each task:
dispatching-parallel-agentsGoal: See a measurable time reduction with parallel execution.
For a task where parallel agents might conflict, use git worktrees.
"I need to refactor the UserService and OrderService.
They share some utilities, so use using-git-worktrees
to create isolated workspaces, then dispatch parallel agents."
When to use worktrees:
You've reached L4 when:
| Metric | L3 | L4 Target |
|---|---|---|
| Average turns per task | 3-5 | 1-2 |
| Identifies parallel work | Rarely | Before every complex task |
| Uses parallel agents | Never | For all independent subtasks |
| Context management | All in main | Delegates to subagents |
The clearest sign: You instinctively analyze tasks for parallelism before starting, and your complex work completes in 1-2 turns.
❌ "Run the build, tests, and deploy in parallel" ✅ "Build first, then tests if build passes, then deploy if tests pass"
Dependencies must be respected. Parallel execution is for independent work only.
❌ Two agents edit the same file, causing conflicts ✅ "These might conflict—use using-git-worktrees for isolation"
When in doubt, isolate. Worktrees are cheap; merge conflicts are expensive.
❌ Dispatching 10 agents for tiny tasks ✅ Batching related small tasks, parallelizing truly independent chunks
There's overhead to agent dispatch. 2-5 agents is usually the sweet spot.
❌ Dispatch agents and forget what they're doing ✅ Clear naming, clear boundaries, clear aggregation
Each parallel agent should have a specific, well-defined scope.
Start with your task
│
▼
Is there more than one subtask?
│
┌───┴───┐
No Yes
│ │
▼ ▼
Just Do any subtasks
do it depend on others?
│
┌───┴───┐
Yes No
│ │
▼ ▼
Sequential PARALLEL!
execution Use dispatching-
parallel-agents
| Skill | When to Use | Trigger Phrase |
|---|---|---|
dispatching-parallel-agents | 2+ independent tasks | "Use dispatching-parallel-agents" |
subagent-driven-development | Keep main context clean | "Use subagent-driven-development" |
using-git-worktrees | Need isolation for parallel work | "Use using-git-worktrees" |
"Add these 3 independent features in parallel:
1. Email notifications
2. SMS notifications
3. Slack notifications
Use dispatching-parallel-agents"
"I'm seeing slow response times. Investigate in parallel:
1. Database query performance
2. External API latency
3. Memory usage patterns
Use dispatching-parallel-agents"
"Update our logging across these independent modules:
1. UserService
2. OrderService
3. PaymentService
Use dispatching-parallel-agents"
Once you consistently:
You're ready for L4-to-L5: Orchestrator to Architect.
The next level is about multiplying your impact—creating skills that help your entire team, not just yourself.
Remember: L3 → L4 is about thinking in parallel. The mindset shift—from "what's next" to "what can run together"—is more important than the specific skills.