How I Run 8 Claude Code Sessions at Once

March 24, 2026

Last Tuesday I opened my laptop at 8:30am and scoped 8 tasks across 6 projects. By noon, all 8 had commits ready for review. I wrote zero lines of code.

That’s not a flex. That’s a Tuesday.

Here’s the setup, the workflow, and the thing that makes it work.

The physical setup

I use iTerm2 with 8 tabs. Each tab is a Claude Code session in a different project directory. No split panes – full-screen tabs. I flip between them.

Tab 1: ~/projects/scouter
Tab 2: ~/projects/triumfit
Tab 3: ~/projects/lucid
Tab 4: ~/projects/logline
Tab 5: ~/projects/jwp/sites/jwallaceparker
Tab 6: ~/projects/jwp/sites/octopuscoder
Tab 7: ~/projects/jwp/marketing
Tab 8: ~/projects/pwa-marketing

Each tab has one Claude Code instance running. Each instance has one scoped task. That’s it.

The scoping ritual

This is where the workflow lives or dies. I wrote a full breakdown of this in scoping tasks for background agents, but here’s the short version.

Every morning I spend 15–20 minutes writing task scopes. Not prompts. Scopes. The difference matters.

A prompt is: “Add an export feature to Lucid.”

A scope is: “Add PDF export to the Lucid journal view. Use the existing renderEntry() function. Generate the PDF client-side with jspdf. Add an export button to the journal toolbar, right side, matching the existing icon style. The button should export the current entry only. No multi-entry export. Write the feature in src/features/export/ and add the toolbar button in src/components/JournalToolbar.tsx.”

The prompt needs me in the loop. The scope doesn’t.

I can hand that scope to Claude Code, switch to another tab, and come back in 20 minutes to review the output. If the scope is tight enough, the output is close to right. If it’s vague, the output is a creative interpretation of what I might have meant. Creative interpretations are expensive.

The cadence

Here’s what a typical session looks like:

8:30–8:50 – Scope all tasks. Open each tab, paste the scope, let it run. Some tasks take 3 minutes. Some take 30. I don’t watch any of them.

8:50–9:20 – Coffee. Or email. Or walking the dog. The agents are building.

9:20–10:00 – First review pass. I go tab by tab and look at what happened. Most tasks are done. I accept some, leave comments on others, kick one or two back with corrections.

10:00–10:30 – Second round. The kicked-back tasks are usually fixed by now. I scope 2–3 new tasks for any tabs that are free.

10:30–12:00 – Same cycle. Scope, let it run, review, accept or correct.

By lunch I’ve moved forward on 6 projects. None of them got a full focused day. All of them got meaningful, reviewed, committed progress.

What makes this work

Three things.

1. Specs, not prompts. Every task references existing architecture, file paths, function names, and acceptance criteria. Claude Code doesn’t guess. It executes.

2. Small tasks. I don’t scope “build the entire feature.” I scope “add the database migration” or “write the API endpoint” or “create the UI component.” Small tasks finish fast and are easier to review.

3. Trust the diff, not the process. I don’t watch Claude Code work. I review the output. If the diff is right, I don’t care how it got there. If the diff is wrong, I give better instructions. The code is the artifact. The process is just the process.

The part nobody talks about

This workflow is boring. There’s no drama. No “watch me build a SaaS in 30 minutes” energy. It’s just scoping, waiting, reviewing, accepting. Over and over. Across 6–8 projects.

The exciting part is the output. Not the process.

Last week: new Scouter API endpoints, Triumfit onboarding redesign, Lucid export feature, two blog posts, a landing page variant, and a skill library draft. One person. One week. No heroics.

The octopus doesn’t work hard. It works in parallel. If you want to see how this looks hour by hour, I wrote up an actual Tuesday.

Try it

If you’re currently working on one project at a time, here’s how to scale up gradually.

Pick 3 projects you need to move forward. Open 3 terminal tabs. Write a tight scope for each one – file paths, function names, acceptance criteria. Paste them. Go get coffee.

Come back and review the diffs.

That feeling – checking 3 projects and finding progress on all of them – that’s the workflow.