What is Claude Code? I Run 4 of Them in Parallel on One PC

By Lazar Milicevic · Published June 15, 2026 · 9 min read

Every tutorial shows Claude Code editing one file in one repo. That's the toy version. If you're a solo builder or running a small team, the interesting question isn't "can the AI write a function" — it's "can I move three client projects forward in a single evening for under ten euros." Here's exactly how I built that, what breaks first, and the briefing format that makes the agents ship instead of guess.

The Boring Definition, Then the Real One

Claude Code is an agentic command-line tool from Anthropic. You point it at a folder on your machine, it reads the codebase, edits files, runs commands, executes your test suite, calls git, installs packages. Think of it less as a chatbot and more as a contractor who already has a terminal open inside your project.

That's the baseline every tutorial stops at. The real framing, once you've used it for a few weeks, is different: Claude Code is a workforce orchestration problem. The moment one instance works reliably, your next thought is "what if I run two." Then four. Then you discover the actual bottleneck — which is not the AI, not the machine, not the API quota. It's you.

The official pitch is "Claude Code helps you code faster." The honest pitch is "Claude Code turns you into a fleet manager." Whether that's an upgrade depends entirely on whether you enjoy reading diffs.

The Hardware Is Embarrassingly Boring

Let me show you the actual setup. It's a regular desktop PC sitting in the corner of my office. Not a workstation, not a rack server. It runs Windows with WSL Ubuntu on top. The entire "infrastructure" is:

# Inside WSL Ubuntu
tmux new -s fleet

# Split into 4 panes
# Ctrl+b " (horizontal split)
# Ctrl+b % (vertical split)
# Ctrl+b o (cycle panes)

# Pane 1
cd ~/projects/fakturko && claude

# Pane 2
cd ~/projects/una-intel && claude

# Pane 3
cd ~/projects/bizflowai.io-catalyst && claude

# Pane 4
cd ~/projects/client-saas-refactor && claude

That's it. No Kubernetes, no orchestrator, no message queue, no agent framework. One terminal window, tmux, four panes, four projects, four Claude Code instances. One keyboard.

Resource numbers from a typical evening session, not estimates:

• RAM peak: ~32 GB across all four instances + WSL + browser + editor
• CPU: the agents are I/O-bound most of the time (waiting on API), not CPU-bound
• Disk: each project reads 50-500 MB of source depending on how deep the task digs
• Network: ~5-20 MB per session, mostly streaming tokens back

The PC cost less than a single month of a junior dev's salary. The bottleneck was never going to be the hardware.

The Brief Is the Product: CLAUDE.md

Here's the part nobody warns you about. If you prompt these four agents the way you prompt ChatGPT — vague one-liners like "make the dashboard better" — you will get four piles of garbage in parallel, which is strictly worse than one pile of garbage in series. You now have to clean up four times the mess.

The shift you have to make is to stop prompting and start briefing. The way you'd brief a freelance contractor on day one.

The mechanism is a file called CLAUDE.md at the root of each repo. Claude Code reads it automatically on launch. Think of it as the onboarding document a new hire would get. Mine has five sections, always in this order:

# CLAUDE.md — Fakturko

## 1. What this project does
Invoicing automation SaaS for Serbian small businesses.
Generates compliant PDF invoices, syncs with eFakture (gov system),
emails clients on schedule.

## 2. Stack & conventions
- Python 3.11, FastAPI, Postgres 15, SQLAlchemy 2.x
- Package manager: uv (NOT pip, NOT poetry)
- Test runner: pytest
- Formatter: ruff format, ruff check --fix
- Commit style: conventional commits (feat:, fix:, chore:)

## 3. Where things live
- app/api/        → FastAPI routes
- app/services/   → business logic
- app/models/     → SQLAlchemy models
- app/integrations/efakture/ → government API client
- tests/          → mirror of app/ structure

## 4. Do NOT touch without asking
- app/integrations/payments/ (Stripe live keys flow)
- alembic/versions/ (migrations — propose, never apply)
- .env.production
- app/integrations/efakture/signing.py (cert handling)

## 5. Before you say you're done
1. Run: uv run pytest -x
2. Run: uv run ruff check .
3. Report: which files changed, which tests pass, any TODOs left

Once that file exists, prompts get short. Instead of explaining the project every time, you type:

Add a date_from / date_to query filter to GET /invoices. Follow conventions in CLAUDE.md. Write a test. Run the suite before reporting back.

The agent reads the relevant files, makes the edits, runs the tests, comes back with a summary diff. Now do that four times, in parallel, in four different stacks.

What a good brief looks like vs. a bad one

• Bad: "improve the dashboard" → agent guesses, refactors three unrelated files, breaks two tests
• Bad: "add caching" → agent invents a Redis layer in a project with no Redis
• Good: "add a 5-minute in-memory LRU cache to get_client_invoices() in app/services/invoices.py, max 1000 entries, follow the cache pattern already used in app/services/users.py"
• Good: "the test in tests/api/test_invoices.py::test_date_filter is failing with a timezone mismatch, fix it without changing the API contract"

The pattern: name the file, name the function, name the pattern to follow, name the constraint. Three sentences max.

What an Evening Actually Looks Like

Here's the timing of a normal Tuesday night session. Not theoretical, what actually happens.

The critical discipline: check the panes every 20 minutes, not every 2 minutes. If you babysit one pane, the other three sit idle and you've built a slower version of doing it yourself. Batching is the entire point.

Real numbers from a heavy session like this:

• API spend: €0.80 to €3.00 per pane per session, depending on how much code got read and rewritten
• Total spend on a heavy night: under €10
• Commits landed: typically 6-12 across the four repos
• Failed/rolled-back attempts: 1-3 (the honest number)

Try hiring four contractors for €10 a night.

Where This Breaks (The Honest Part)

This setup only works for a specific shape of work. Be honest about which side of the line you're on:

Where Claude Code shines unsupervised:

• Refactors with clear before/after
• Bug fixes with a reproducing test
• Adding a clearly scoped endpoint following existing patterns
• Writing tests for existing code
• Migrating a config file or dependency
• Cleaning up unused imports, dead code, lint warnings
• Documentation passes against existing source

Where I do not let it run unsupervised:

• Greenfield architecture decisions
• Anything touching real payment flows without a human reading every line
• Anything where the requirements are still fuzzy in my own head
• Database migrations against production data
• Security-sensitive code: auth, signing, key handling
• Cross-service changes spanning multiple repos at once

The diagnostic question: can I write the CLAUDE.md brief clearly? If yes, the agent can usually execute. If no — if I'm still hand-waving about what "good" looks like — the agent will hand-wave back with confidence, four times faster. Garbage brief, garbage output, parallelized.

The Real Bottleneck Is Your Review Capacity

The thing that breaks first is not the machine, not the API rate limit, not the context window. It's your reviewing capacity.

Four agents producing pull-request-sized changes every twenty minutes means you are now a full-time code reviewer. Per evening, that's roughly:

• 6-12 diffs to read
• 2-5 clarifying questions to answer
• 1-3 rollbacks to decide on
• ~200-800 lines of changed code to evaluate

If you don't enjoy reading code, this setup will burn you out inside a week. The skill that becomes valuable is not writing code — it's reading code fast and knowing when to say "no, do it again, this way." That's the real shift: from using a tool to managing a team.

A couple of practical guardrails I run by default:

# Every agent works on its own branch
git checkout -b claude/add-date-filter

# Before approving, always:
git diff main --stat        # what changed at a glance
git diff main -- '*.py'     # the actual code
uv run pytest -x            # does it still work

I also keep a one-line rule in every CLAUDE.md: "If you're about to change more than 5 files, stop and ask first." This single line has saved more rollbacks than any other configuration.

Why bizflowai.io helps with this

This is exactly the kind of system I build for clients at bizflowai.io — not selling you a course on "AI coding," but setting up the actual fleet: the CLAUDE.md briefs tailored to your codebase, the tmux workflow, the review discipline, the guardrails on which folders are off-limits, and the integration with your existing git flow and CI. Most small teams I work with don't need more developers — they need one engineer who can supervise four agents on the boring 60% of the backlog, so the human time goes to the 40% that actually requires judgment.

Frequently asked questions

What is Claude Code?

Claude Code is an agentic command-line tool from Anthropic. You point it at a folder on your machine and it reads the codebase, edits files, runs commands, executes tests, calls git, and installs packages. Rather than being a chatbot, it operates like a contractor with a terminal already open inside your project, working directly on your local files.

How do I run multiple Claude Code agents in parallel?

Open a terminal, launch tmux, and split it into multiple panes. Place each pane in a different project folder and launch Claude Code in each. No Kubernetes, queue, or orchestrator is needed. A standard setup runs four panes on a WSL Ubuntu desktop, letting one keyboard drive four agents working on four separate projects simultaneously.

What is a CLAUDE.md file and why does it matter?

CLAUDE.md is a file placed at the root of a repo that Claude Code reads automatically as onboarding documentation. It typically contains five sections: what the project does, the tech stack and conventions, key folders, things never to touch without asking, and how to verify work before finishing. It lets you keep prompts short instead of re-explaining the project.

How do I prompt Claude Code effectively?

Stop prompting like ChatGPT with vague one-liners and start briefing it like a freelance contractor. With a CLAUDE.md file in place, prompts become short and specific, such as: add a date filter to the invoices endpoint, follow the conventions in CLAUDE.md, and run the tests before finishing. Vague prompts across parallel agents produce parallel garbage.

When should I use Claude Code for parallel work?

Use parallel Claude Code agents for well-scoped tasks on existing codebases: refactors, bug fixes, adding clearly defined endpoints, writing tests for existing code, migrating configs, and cleaning up dependencies. Check panes every twenty minutes rather than every two, since babysitting one pane leaves the others idle. A heavy evening session typically costs under ten euros in API spend.

Want more like this?

I publish practical AI automation, GenAI engineering, and faceless content workflows on YouTube every week.

Subscribe to bizflowai.io on YouTube — never miss a new tutorial.

Planning an AI automation project or need a second opinion on your architecture?

Connect with me on LinkedIn — Lazar Milicevic, GenAI Engineer & bizflowai.io Founder.

Visit bizflowai.io for our services, case studies, and AI consulting.