---
title: "How I run several projects at once with Claude Code"
date: 2026-10-31T18:36:06.768+00:00
url: https://hurricane.works/blog/running-several-projects-with-claude-code
description: "Each new Claude Code session starts without yesterday's conversation. Three files per project and two small skills let me pick up any project, on any device, in about a minute."
author: "Hurricane Works"
categories: ["AI", "Engineering"]
---

# How I run several projects at once with Claude Code

I usually have four or five projects moving at once, each with Claude Code running in its own terminal window on my computer. I mostly manage those windows from the Claude app, on my phone, a tablet or a browser on another machine, and I jump between them the way you'd jump between chats in a messaging app.

Three text files in each project and two small skills mean I can land in any of those sessions and know where things stand in about a minute.

If you have used Claude Code on one project and found it hard to keep track once you added a second, this is the setup I wish I had started with.

## The problem: every new session starts fresh

Claude Code remembers a conversation only for as long as that conversation lasts. Clear it or open a new terminal, and the next session starts without any of it.

On one project you can carry the gap in your head. You say "carry on with the login page" and fill in the rest. With five projects you can't, and you start every session by explaining things you have already explained.

So the state of a project has to live somewhere other than the chat. I keep it in the project folder, in files Claude can read.

## Five terms, in plain English

| Term | What it means |
|---|---|
| **Session** | One running conversation with Claude Code. |
| **Context** | What Claude can see right now: the conversation, plus any files it has loaded. It has a size limit, and everything in it costs you tokens, the units Claude's usage is measured in. |
| **Harness** | The program wrapped around the model. Claude is the model; Claude Code is the harness that lets it read files and run commands, and asks your permission first. You can configure the harness, and the model will work within it. |
| **Skill** | A set of written instructions saved under a name. Type `/wrapup` and Claude follows them. It takes a text file to make one. |
| **Hook** | A command the harness runs by itself at a set moment, such as when a session starts. Claude doesn't choose to run it. |

The difference comes up a lot: you trigger a skill yourself, whereas a hook runs without anyone remembering to ask.

## The setup: several terminals, one app

Each project gets its own terminal window, with Claude Code running inside it, in that project's folder. Four projects means four windows and four separate sessions. They can all work at the same time, because each one is its own program working in its own folder.

On their own, those windows are hard to manage. You have to be at the computer to see which has finished, and it's easy to miss the one sitting there waiting for an answer.

Remote Control fixes that. With it switched on, every Claude Code session you start on your computer appears in the Claude app by itself. Open the Code tab in the app on your phone, or go to claude.ai/code in a browser on any machine, and you get a list of sessions, one for each terminal window. Tap one and you're in that conversation. You can read what Claude has done and reply, whether that's answering a question or giving it the next task. What you type there shows up in the terminal, and what happens in the terminal shows up in the app.

So the terminals do the work and the app is where I run them. For example, I can set three projects going at my desk and walk away, or carry on from a different machine. When one finishes or needs a decision, my phone gets a notification. I tap it, reply, and that session carries on while the other two keep going.

I rename each session in the Claude app, so the list is easy to read at a glance.

### If you haven't used a terminal before

A terminal is a window where you type commands instead of clicking. On a Mac:

1. Press Cmd + Space, type `Terminal` and press Return.
2. Type `cd` and a space, drag your project folder from Finder into the window, and press Return. That puts the terminal inside the folder.
3. Type `claude` and press Return to start Claude Code.

For a second project, press Cmd + N to open a new window, then repeat steps 2 and 3.

If `claude` isn't recognised, Claude Code isn't installed yet. The first prompt under "How to start" will walk you through it.

## The three files

Every active project gets the same three files in its root folder.

**`CLAUDE.md` is the operating manual.** Claude Code loads it automatically at the start of every session. It holds what a new session needs before it touches anything: the tech stack, the commands, where the key files are, the mistakes already made and how to avoid them.

**`PROJECT_PLAN.md` is the plan and the diary.** It lists the tasks, and each working day gets one dated entry saying what was done and how it was checked. It is only read when needed.

**`PROJECT_PLAN_ARCHIVE.md` is the attic.** Finished sections and entries older than about a month move here, word for word.

The reason for the split is cost. `CLAUDE.md` loads every time, so each kilobyte in it is paid for on every future session. A kilobyte is roughly 250 tokens. A diary entry in that file gets charged for again and again, while the same entry in the plan costs nothing until someone opens it.

So each kind of information has one home: anything the next session must know before acting goes in `CLAUDE.md`, and a record of what happened goes in the plan.

There is also one master `CLAUDE.md` in the folder above all my projects. It holds the rules that apply everywhere: never push without asking, and never delete without confirming. It also gives each project its own local port, so two dev servers never collide.

## Two skills that keep it working

Files only help if they stay accurate, and left alone they won't. So two skills bookend every session.

### `/status`: start of session

`/status` reads the project's docs and its recent git history, then gives me a briefing of under 250 words: what this project is, where we left off, what's next, and anything odd.

Two details make it useful.

It's written to change nothing: it never edits a file or starts work, so it's safe to run anywhere, including from my phone when I only want to check on something.

It also compares the docs against git. The docs say what was intended, and git shows what happened. If there are commits newer than the docs, or a "next step" that was finished last week, it tells me instead of guessing which is right.

### `/wrapup`: end of session

`/wrapup` does the chores I would otherwise skip when I'm tired:

1. Checks git for changes it doesn't recognise, in case another session is working in the same project.
2. Adds today's entry to the plan and marks tasks done, but only ones verified against the code and the live system.
3. Adds anything the next session needs to `CLAUDE.md`, such as a new trap to avoid or a new command.
4. Measures both files against a size budget and offers to archive if they're over.
5. Runs the build, scans for leaked secrets and commits.
6. Asks before pushing, and says what pushing will do.

That last step is worded on purpose. On most of my projects, pushing to the main branch deploys the live site, so the question says so: "Push to main? This publishes it live."

## Using the harness to enforce rules

Instructions in a file are requests, and Claude can forget or misjudge them. For anything that matters, I use the harness as well.

Two examples from my `settings.json`, the harness's config file:

- **A session-start hook prints today's date and day of the week.** Claude isn't good at working out what day a date falls on, and this hook means it never has to. It runs every session without anyone asking.
- **A deny-list blocks dangerous commands.** Mine refuses anything that deletes from my Google Cloud accounts or touches billing, before it runs, however confident Claude is.

My rule of thumb is that anything expensive to get wrong goes in the harness, and the rest can live in `CLAUDE.md`.

## Setting up Remote Control

It takes two steps, and you only do them once:

1. In Claude Code, run `/config` and set "Enable Remote Control for all sessions". It's off by default.
2. Install the Claude app. Running `/mobile` in Claude Code shows a QR code that takes you to the right app store.

Nothing moves to your phone. Claude keeps running on your computer, with your files, and each device is a window onto it. A few things follow from that:

- Your computer has to stay on, with the session still running.
- If its network drops, an interactive session retries and reconnects when the network returns.
- `/clear`, `/compact` and `/usage` work from the phone. `/plugin` and `/resume` only work in the terminal.
- A `!` shell command sent from the app arrives as plain text and does nothing. I lost time to that one.

Push notifications tell me when a long task finishes or when Claude needs a decision. They're two separate settings, so check both are on.

Remote Control gets you to a session from any device. That session still has its usual limits and still ends when cleared, so the files are what carry a project from one session to the next.

### Keeping a MacBook awake with the lid shut

A MacBook normally goes to sleep when you close the lid, which stops your sessions working. I turn that off, so everything keeps running while the laptop is shut and I'm out with my phone:

```bash
sudo pmset -a disablesleep 1
```

The catch is that the laptop keeps running. It uses power with the lid shut, so the battery drains even though it looks asleep. It keeps producing heat too, so don't put it in a bag. Plug it in if you're leaving it for long.

To go back to normal:

```bash
sudo pmset -a disablesleep 0
```

## What a normal day looks like

Here is the loop.

1. Open a terminal window for each project I'm working on and start Claude Code.
2. Run `/status` in each one, and give it the next task from the plan.
3. Step away and manage all of them from the app, on whichever device is closest.
4. Run `/wrapup` in a session when its task or the day ends.
5. Clear that session ready for the next task, or leave it as it is if I'm busy and come back to it later.

Say I wrap up on the laptop in the evening and clear the session. Next morning I open the app on my phone, run `/status` in that same session, and I'm caught up, because the state of the project is in the folder.

Switching project is the same. I tap a different session in the list, and if I've lost track of it, `/status` tells me where it stands.

You can also run two sessions in one project, as long as they don't trip over each other. A git worktree helps: it's a second copy of the project on its own branch, so two sessions never edit the same files. I rarely need it, though it's there when I do. The safety net is that `/wrapup` stops if it sees changes it doesn't recognise, and commits only what its own session touched.

One caution. `git push` sends every commit on the branch, so a commit from another session goes too. The push question stops an accidental deploy, but you still need to look at what's going out.

## Where it went wrong

The size budget exists because of one busy project. Its `CLAUDE.md` reached about 215 KB. I pruned it to 110 KB, and two days later it was back near 200 KB. I had written a size limit into the file, but nothing ever checked it. That's why `/wrapup` measures on every run.

The budget still isn't a guarantee. That same project went into August at under 80 KB and passed 300 KB by the start of September, three times its 100 KB budget. The check only happens when `/wrapup` runs, and archiving needs a yes from you, so a file can keep growing if you skip the step or wave it through. Read the sizes it reports.

Adoption isn't total on my own projects either. On 30 October 2026, 20 of the 32 project folders on this machine had all three files. Older ones get converted the next time I touch them.

All of this comes from one person's setup. The minute is my own estimate, and I have no before-and-after figures for the time it saves.

## How to start

You don't need all of this on day one. Do these in order and stop when it stops helping.

1. Create a `CLAUDE.md` in one project. Ask Claude Code to draft it, then correct it.
2. Add a `PROJECT_PLAN.md` and ask Claude to log each day's work there, never in `CLAUDE.md`.
3. Write a `/wrapup` skill that does those updates and commits.
4. Write a `/status` skill that reads them back.
5. Turn on Remote Control, open a second terminal for a second project, and try running both from the app.

### Or let Claude set it up with you

If you haven't installed Claude Code yet, these two prompts take you through most of those steps. Each one checks your situation first, so they also work on an employer's computer or in a project that already has code. As with anything you copy from a web page, read them before you paste them.

Paste the first into the Claude app or claude.ai. That conversation can't touch your computer, so it tells you what to type and helps if something fails.

```text
I want to install Claude Code and use it in a terminal.
I have never used a terminal, so assume nothing.

First, look up the current install instructions at
code.claude.com/docs and use those instead of what you
remember. If you can't look them up, tell me.

Ask me these one at a time:
- What computer do I use: Mac, Windows, Linux or something else?
- Is it my own, or managed by an employer or school?
- Have I tried installing Claude Code before?
- Do I have a paid Claude plan?

Then change the steps to fit my answers:
- Phone, tablet or Chromebook only: tell me what my options
  are before we start, and stop if there isn't one.
- Managed computer: warn me that I may be blocked from
  installing software, and tell me what to ask IT for.
- Already installed: check it works and update it.
- No suitable plan: tell me which plan I need and its current
  price, then wait for me to decide.

Once we start:
1. Give me one step at a time. For each step, say what it
   does in a plain sentence and what I should see afterwards.
2. Wait for me to confirm before giving the next step.
3. If I paste an error, explain it and help me fix it.
4. If claude isn't recognised after installing, check whether
   I need to open a new terminal window before anything else.
5. If the same step fails twice, stop repeating it. Tell me
   what is probably wrong and what to try instead.
6. Before any command that needs my password, tell me why.

We're finished when I've opened a terminal in my project
folder, typed claude and seen it start. If I don't have a
project folder yet, help me make one first.
```

Once Claude Code is running in your project folder, paste the second prompt there. Claude Code can work on your files, so it does the setup itself and asks before each change.

```text
Set up this project so a new session can pick up where the
last one stopped. Ask me one question at a time, and show me
each file before you save it.

1. Check where we are. If this looks like my home, Desktop or
   Documents folder, stop and help me move to a project folder.
2. If the folder is empty, ask what I want to build, but don't
   build it yet. If it has code, read it first. Then ask what
   I want to get done.
3. Create CLAUDE.md: what the project is, the tech stack, the
   commands and any rules. Keep it short. If pushing this
   project publishes anything live, say so in the file.
4. Create PROJECT_PLAN.md: the task list, plus one dated entry
   for each day we work. Session history goes here and never
   in CLAUDE.md.
5. If either file already exists, read it and suggest changes.
   Never replace it without asking.
6. If this folder isn't a git repository, explain what that
   means and ask if I want one. If git isn't installed, help
   me install it or skip this step. If I say yes, make sure
   passwords and key files are never committed.
7. Download these two skills and tell me in plain English what
   each one does before saving it:
   https://hurricane.works/files/status-skill.md
   https://hurricane.works/files/wrapup-skill.md
   Save them as ~/.claude/skills/status/SKILL.md and
   ~/.claude/skills/wrapup/SKILL.md, where ~ means my home
   folder on any computer. If a skill with that name exists,
   show me the differences and ask before replacing it. If a
   download fails, tell me and carry on. Tell me if I need to
   restart Claude Code to use them.
8. Using the current docs at code.claude.com/docs, tell me how
   to turn on Remote Control and install the Claude app. If
   I'm on a laptop, explain what happens when it goes to sleep.
9. Tell me what to do for my next project. The skills are
   already installed, so only steps 1 to 6 need repeating.

Don't put passwords or API keys in any of these files.
Don't push or deploy anything.
```

I wrote up how I packaged this setup for a friend in the [starter kit post](/blog/claude-code-starter-kit/), which covers what carries over to another machine and what doesn't. Copies of my two skills are here: [status-SKILL.md](https://hurricane.works/files/status-skill.md) and [wrapup-SKILL.md](https://hurricane.works/files/wrapup-skill.md). Adapt the size budgets and the push wording to suit how you work.

Alastair Campbell, CEO, Hurricane Works

