Run 15 Parallel Claude Sessions Like Anthropic's Top Dev.

Quick Answer: Boris Cherny, creator of Claude Code, runs 10-15 concurrent Claude sessions: 5 in terminal tabs (numbered 1-5 with system notifications), 5-10 in browser on claude.ai, plus mobile sessions started in the morning. He uses a "teleport" command to move work between web and local environments. This parallel approach enables him to ship 22-27 PRs daily without ever waiting for AI.

When developers first hear that Boris Cherny runs 15 parallel Claude sessions, it sounds chaotic. But his approach is systematic—a "fleet management" strategy that maximizes throughput while maintaining focus.

Here's exactly how he does it and how you can implement a similar workflow.

Watch: Theo's Parallel Claude Code Workflow

Theo demonstrates running 6 parallel Claude Code instances simultaneously—the same approach Boris Cherny uses to ship 27 PRs daily.

The Problem: Waiting for AI

Traditional AI-assisted development has a bottleneck: waiting. You send a request, wait for the response, review it, send another request, wait again.

With complex tasks and high-quality models like Opus 4.5 (which Cherny uses exclusively), response times can be 30-60 seconds or more. That's 30-60 seconds of doing nothing—multiplied across dozens of interactions per day.

The Traditional Single-Session Workflow

Task A: Request → Wait 45s → Review → Request → Wait 45s → Done
Task B: Request → Wait 45s → Review → Done
Task C: Request → Wait 45s → Review → Request → Wait 45s → Done

Total time: 270 seconds of waiting

Most of your time is spent waiting, not working.

The Parallel Session Solution

Task A: Request → [Work on Task B] → Review → Request → [Work on Task C] → Done
Task B: Request → [Work on Task A] → Review → Done
Task C: Request → [Work on Task A] → Review → Request → [Work on Task B] → Done

Total waiting: Near zero (always something ready)

By running multiple sessions, waiting time becomes productive time on other tasks.

Boris Cherny's Fleet Setup

"I run 5 Claudes in parallel in my terminal. I number my tabs 1-5, and use system notifications to know when a Claude needs input." — Boris Cherny

Cherny's setup has three layers:

Layer 1: Terminal Sessions (5)

Five Claude Code sessions in terminal tabs, numbered 1-5:

• Each handles a distinct task or feature
• System notifications alert when input is needed
• Quick keyboard shortcuts to switch between tabs

Layer 2: Browser Sessions (5-10)

Additional sessions on claude.ai in the browser:

• Useful for tasks that benefit from web interface
• Can be "teleported" to local terminal as needed
• Different context/conversation for each

Layer 3: Mobile Sessions

Sessions started on mobile in the morning:

• Background tasks that don't need immediate attention
• Check back later when results are ready
• Perfect for research or analysis tasks

Total Fleet Size

System Notifications: The Key to Parallel Work

Managing 15 sessions sounds overwhelming. Cherny's secret: system notifications.

"I number my tabs 1-5, and use system notifications to know when a Claude needs input."

Instead of constantly checking each session, notifications alert him when:

• A session has completed its task
• A session needs user input
• A session has encountered an issue

This allows focus on productive work while staying aware of session status.

Setting Up Notifications

In Claude Code, notifications can be configured:

# Enable system notifications in settings
claude config set notifications true

When any session needs attention, your OS notification system alerts you.

The Teleport Command: Web to Local

"I also run 5-10 Claudes on claude.ai in my browser, using a teleport command to hand off work between the web and my local machine."

The "teleport" feature allows seamless handoff between environments:

1. Start a conversation on claude.ai (web)
2. Develop the approach, gather context
3. "Teleport" to local Claude Code for implementation
4. Continue with full local tool access

Why Teleport Matters

Browser advantages:

• Easier to share context (paste URLs, images)
• Good for exploratory conversations
• Works anywhere with internet
• Better for non-coding discussions

Local advantages:

• Full codebase access
• Can run commands, edit files
• Tool use for verification
• Better for implementation

Teleport gives you the best of both worlds.

How to Use Teleport

From a claude.ai conversation, use the teleport command to transfer context to your local Claude Code session. The conversation history, context, and current task move to your development environment.

Implementing Your Own Fleet

Ready to run parallel sessions? Here's a step-by-step guide:

Step 1: Set Up Terminal Tabs

Configure your terminal for easy tab management:

# In iTerm2, Terminal.app, or similar
# Create 5 tabs with Claude Code sessions
# Assign keyboard shortcuts for quick switching:
# Cmd+1 = Tab 1, Cmd+2 = Tab 2, etc.

Name each tab with the current task for easy identification.

Step 2: Enable Notifications

Configure notifications so you're alerted when sessions need attention:

# Enable in Claude Code config
claude config set notifications true

Test that notifications work properly on your system.

Step 3: Develop Task Assignment Strategy

Not all tasks are equal. Assign to sessions strategically:

This structure ensures balanced progress across different work types.

Step 4: Master Context Switching

Parallel work requires efficient context switching:

When switching to a session:

1. Read the last few messages (where were we?)
2. Review any pending output
3. Provide next instruction
4. Switch away while processing

Keep notes: A simple text file tracking each session's current status helps maintain context:

Tab 1: User auth - waiting for review of login component
Tab 2: Dashboard - implementing chart feature, 60% done
Tab 3: Bug #234 - fixed, needs testing
Tab 4: Writing tests for auth module
Tab 5: Updating README

Step 5: Use Browser Sessions for Specific Tasks

Reserve browser sessions for tasks that benefit from web interface:

• Research: Finding documentation, examples
• Planning: Long-form discussions about approach
• Code review: Discussing PRs, architecture
• Learning: Understanding new concepts

Then teleport to terminal when implementation begins.

Mobile Sessions: Async Advantages

Cherny's mobile sessions add another dimension:

Morning Kickoff

Start tasks in the morning that don't need immediate results:

• "Analyze this codebase and identify improvement opportunities"
• "Review all TODOs in the project and categorize them"
• "Research best practices for [specific technology]"

Check Back Later

These tasks run in background. When you check back:

• Results are waiting
• No time spent waiting
• Immediate access to analysis

Best Mobile Use Cases

Managing Cognitive Load

Fifteen sessions sounds like a recipe for cognitive overload. Here's how to manage it:

Group Similar Tasks

Keep related work in adjacent tabs:

• Tabs 1-2: Main feature development
• Tab 3: Testing for that feature
• Tabs 4-5: Unrelated smaller tasks

Grouping reduces context-switching cognitive cost.

Use Session Isolation

Each session is independent. This is a feature, not a bug:

• Session A can't corrupt session B's context
• Problems in one don't affect others
• Each maintains its own conversation history

Take Breaks Between Deep Switches

When switching between very different tasks, take a moment:

• Read the session status
• Recall what you were doing
• Orient before diving in

Don't Force It

Some days, fewer sessions work better:

• Complex debugging: Maybe 2-3 focused sessions
• Creative design work: 1-2 deep sessions
• Routine implementation: 5+ parallel sessions

Match fleet size to task complexity.

Productivity Patterns

Pattern 1: The Pipeline

Structure work as a pipeline across sessions:

Session 1: Write feature → Session 2: Write tests →
Session 3: Review/refine → Session 4: Documentation

Work flows through sessions like an assembly line.

Pattern 2: The Sprint

All sessions work on different aspects of one feature:

Session 1: Frontend components
Session 2: Backend API
Session 3: Database migrations
Session 4: Integration tests
Session 5: Documentation

All for: User authentication feature

Rapid parallel progress on a single goal.

Pattern 3: The Rotation

Different features cycle through:

Morning: Feature A in Session 1
         Feature B in Session 2

Afternoon: Feature A → Session 3 (testing)
           Feature B → Session 4 (refinement)
           New Feature C in Session 1

Continuous rotation keeps everything moving.

Common Mistakes to Avoid

Mistake 1: Too Many Sessions Too Fast

Starting with 15 sessions is overwhelming. Build up gradually:

• Week 1: 2-3 sessions
• Week 2: 4-5 sessions
• Week 3+: Scale as comfortable

Mistake 2: No Session Tracking

Without tracking, you forget what each session is doing.

Fix: Keep a simple status document.

Mistake 3: Ignoring Notifications

Notifications are only useful if you respond.

Fix: Act on notifications promptly or disable them.

Mistake 4: Context Thrashing

Switching too rapidly between unrelated tasks.

Fix: Group related work, limit switches per hour.

Mistake 5: Never Closing Sessions

Old sessions accumulate, adding confusion.

Fix: Close completed sessions, start fresh for new tasks.

Frequently Asked Questions

Is this overkill for most developers?

It depends on your workload. Even 3-4 parallel sessions significantly reduce waiting time. You don't need 15 to benefit.

How do I know which session needs attention?

System notifications alert you. Additionally, periodic scans of tabs (every few minutes) catch anything notifications missed.

Won't I lose track of what each session is doing?

Keep notes. A simple text file or tab naming convention solves this.

Does this work with other AI tools?

The parallel approach works with any AI assistant. Claude Code's notification and teleport features make it particularly smooth.

How much does running 15 sessions cost?

Sessions are conversations, not concurrent API calls. You're only charged for actual usage in each session. Parallel sessions don't multiply cost unless you're actually sending more requests.

Bottom Line

Boris Cherny's parallel session approach isn't chaos—it's orchestrated efficiency. By running multiple Claude sessions simultaneously:

Key takeaways:

• Eliminate waiting time by always having something ready
• Use terminal sessions for active development (5)
• Use browser sessions for research and planning (5-10)
• Use mobile for async background tasks
• System notifications keep you informed without constant checking
• Teleport moves work between environments seamlessly

You don't need to start with 15 sessions. Even 2-3 parallel sessions transform your productivity by eliminating the waiting bottleneck.

The goal isn't managing more sessions—it's shipping more code. Parallel work is simply the mechanism.

---

Ready to optimize your development workflow with AI? Contact Houston IT Developers to learn how we help teams implement effective AI-assisted development practices.

Sources:

• Fortune: Boris Cherny on Claude Code
• DEV Community: How Boris Cherny Uses Claude Code
• VentureBeat: Creator of Claude Code Workflow