Running 3 Projects at Once: My Multitasking System With Claude Code

Context-switching is not free.

Every time you move from Project A to Project B, you spend 20–30 minutes reloading the mental model of what you were doing, where you left off, and what the next step is. Do this five times in a day and you have spent 2.5 hours recovering context that you had built up the previous day.

For a solo developer running three simultaneous projects, unmanaged context-switching is a productivity trap. Here is the system I developed over the 25-day sprint.

The Core Problem

Code has context. The context is not just the file you have open — it is: what problem are you solving, what approach did you decide on and why, what have you tried that did not work, what are the open questions, and what is the next concrete step.

This context exists clearly in your head while you are working in the project. It degrades overnight and collapses when you switch projects. Re-reading code rebuilds some of it. But re-reading code is not the same as having built the context through active work.

The goal is to preserve as much of this context as possible across sessions and across projects.

The Three-Part System

Part 1: The End-of-Session Note

Before closing a project at the end of a work session, I write a one-paragraph note in a scratch file at the project root (NOTES.md or _session.md):

Session: 2026-06-15

Working on: The wallet transaction audit log view in the admin panel.
Current state: The table renders correctly. The date range filter works.
The CSV export is returning all rows instead of the filtered subset — the
filter params are not being passed to the export API route.
Next step: Debug the export route. The issue is likely in how the query
params are read — check `req.url` vs `req.nextUrl`.
Open question: Should the export include pending transactions or only completed?

This note takes 3 minutes to write. It saves 20 minutes of re-orientation the next morning.

Part 2: The Daily Time Block Structure

Projects are assigned to time blocks, not to tasks. The assignment is fixed for the week:

• —8am–10am: Project A (the most critical project or the most momentum-dependent task)
• —10am–12pm: Project B
• —1pm–3pm: Project C
• —3pm–5pm: Project A or B continuation (based on what is most urgent)

The block boundaries are hard. When the block ends, the current task pauses. This prevents one project from consuming the full day while another stagnates.

Part 3: Claude Code Skill Files

Each project has a skill file — a markdown document that gives Claude Code the specific context of that project: the tech stack, the conventions, the patterns, the things to never do. At the start of a session, Claude Code reads the skill file and the session note.

You are working on TheWestNepal.live, a Next.js news site with Supabase.
- Stack: Next.js 15, Supabase, Vercel, Tailwind
- All articles are stored in the `articles` table
- Image handling uses Next.js Image component — never use raw <img> tags
- No API routes for reads — use server components with direct Supabase queries
- The session note from last time: [NOTES.md content]

This means Claude Code does not apply santoshpaudel.me conventions to TheWestNepal.live. The skill file is the project-specific context that prevents cross-project pollution.

The Antigravity Layer

Antigravity preserves IDE state across sessions — which files are open, where the cursor is, what is in the terminal. Combined with the session note and the skill file, it means the start of a session looks like: open the project, Claude Code reads the context, and you are back where you left off.

Without this, you spend the first 15 minutes of every session reconstructing state. With it, you spend 2 minutes reading the session note and you are in motion.

What the System Does Not Solve

Deep debugging sessions need uninterrupted time. A bug that requires understanding the interaction between three systems cannot be debugged across 2-hour blocks. When a complex bug appears, I break the block structure and give it the full day.

Client projects with external deadlines sometimes override the block structure. When a client deliverable is due, that project gets prioritized regardless of the schedule.

The system is an optimization for steady-state multi-project work. It bends when something is genuinely urgent.

---

Resources

• —Claude Code documentation — how skill files and session context work in Claude Code; the tool at the core of this workflow
• —Conventional Commits — a session-note-friendly commit message format that makes context reconstruction faster the next morning

Related Posts

• —My Claude Code and Antigravity Workflow for Running 3 Projects at Once — the tool-level detail behind the context management described here
• —Skill Files Explained: How I Customized Claude Code for My Own Projects — the skill files that give Claude Code project-specific context at the start of each session
• —Commit, Push, Deploy — All From One Prompt — the end-of-session step that closes out each project block

---

Drowning in context-switching between client projects? I help developers and consultants build workflows that keep multiple projects moving. Get in touch to talk about what you are working on.