Running Four Projects Solo With Claude Code for One Month

Tomohiro Iida · Published April 23, 2026

Claude Code is an agentic AI coding environment from Anthropic, a U.S. AI company. This article is a field record from one engineer who, over 31 days from March 23 to April 23, 2026, ran four projects in parallel with Claude Code — a corporate website, an owned-media site, a restaurant website, and a Strapi CMS platform — producing 435 commits in total. It is organized around four questions: what this way of using Claude Code looks like, which features mattered in which situations, what broke, and how to keep parallel projects from spinning out of control. The goal is concrete operational detail rather than generalities.

The month in numbers

Simply lining up commit count, project count, and deploy count already shows the productivity difference between before and after adopting Claude Code.

• 435 commits — the one-month total
• 4 projects — run in parallel
• 60+ deployments — shipped to production via pull request
• 1 person — the actual hands-on work was done by a single owner

Beyond these four projects, internal tool operations — such as MoneyForward invoice processing and Google Workspace integration — ran in parallel as well. Direct hands-on coding by the human owner was minimal; implementation went through Claude Code almost entirely. Time spent on dialogue, decisions, and review is still required, but the time lost waiting on implementation dropped sharply.

Which features did what

No single feature is impressive on its own — combining several gets you something closer to one person running an entire department.

Sub-Agents: splitting explore, implement, and review

Claude Code's Agent tool avoids context contamination when roles are kept separate. Three layers were used in this operation:

• Explore-only agents: cross-codebase search that returns only the findings to the parent agent, so the large volume of files read during the search never fills up the parent's own context
• Implementation agents (general-purpose): implementing an independent task, isolated in a worktree so it does not block the parent's own work
• Review agents (code-reviewer): an independent review pass after implementation, surfacing points the parent missed

On top of these, custom role-based agents — designer, CTO, editor-in-chief, and similar — were also used. Fixing a system prompt and reference rules per role keeps review quality consistent.

The Task tool: tracking parallel work

TaskCreate and TaskUpdate were used as a cross-project backlog. Especially when touching several projects at once, tracking which task maps to which pull request in the task metadata keeps things from getting confused. Structuring work as a parent task with child tasks lets Claude Code check its own progress at a glance via TaskList, and because state persists across sessions, picking work back up is fast.

Memory: making the user profile and unwritten rules persistent

Claude Code's auto memory (stored under a per-project memory directory) is a mechanism for carrying the owner's preferences, past failures, and project context across sessions. This operation used five types of memory:

user

The owner's own role, skills, and working style — example: prioritizing requirements definition based on prior PM experience.

feedback

Past failures and unwritten rules that have since been written down — example: no poem-like phrasing, and no direct pushes to main; use pull requests.

project

Constraints, deadlines, and stakeholders specific to a given project — example: in Strapi v5, publishedAt is a system-managed field.

reference

Where to find IDs, URLs, and credentials for external services — example: the GA4 property and the GSC URL-prefix.

session

Progress carried over from the previous session — example: which pull request had gotten to what point.

It works something like handing an onboarding document to a new team member: Claude Code can be handed unwritten rules as a document, so the same caution does not need repeating every time.

Skills: turning your own workflow into commands

Placing a self-authored skill under the skills directory makes it callable with a slash command. Skills built for this operation include:

• Article writing format: a single check covering consistent polite-form writing, banning poem-like phrasing, and applying the structure template
• Pre-deploy checklist: build, type-check, issuing a preview URL, and posting to Discord, run in a fixed order
• SEO audit routine: a fixed pattern of pulling GSC data, surfacing indexing issues, then listing improvement candidates
• Strapi operating procedure: a fixed flow for adding a schema, revalidating, and wiring up Cloudinary

A skill effectively encodes as a prompt how you want Claude Code to behave. It saves writing "review it from this angle" every time, and keeps the whole workflow consistent.

MCP: connecting external services

MCP is a mechanism for adding tools Claude Code can use, after the fact. Servers used in this operation:

• Canva: editing design files and posting comments (no direct text-editing API currently exists)
• Google Workspace: automating Docs, Slides, Sheets, Gmail, and Drive
• Chrome DevTools: Lighthouse audits and network inspection on the live site
• Memory: managing entities and relations (long-term memory)

The Google Workspace MCP turned out to be surprisingly capable, reaching the point of auto-generating a weekly GA4 report in Docs and posting it straight to Discord.

Five concrete use cases from the month

These are not abstractions — they are five things that actually happened during the month.

01. A cross-site design audit, 14 items processed in one day

The audit was handed to a self-built "designer" role sub-agent, which listed the problems found. Fourteen items were registered via TaskCreate and fixed in priority order, with the human owner limited to setting direction and reviewing pull requests. Items such as unifying H2 prefixes, color-coding four R&D projects, distinguishing two CTA systems, and fixing hero H1 mobile line-wrapping are each minor on their own but add up to a large effect on overall site quality — and they were cleared in one pass.

02. A batch of 17 SEO fixes

GSC and GA4 data was pulled via MCP, improvement items were listed by priority, and 17 items were applied in a single pull request. This covered fixing 53 pages stuck at "discovered, not indexed," a codemod-based bulk fix for five structured-data warnings, redirecting 30 old URLs, and optimizing og:type and og:image across every article. Work that would take a human three days fixing items one by one was completed in an hour, freeing time to work on articles for another site in parallel.

03. Extending multiple CMS schemas (Strapi v5)

New Strapi collections (case-study and trust-signal) were added. Claude Code was handed a YAML schema spec and generated the schema JSON, the TypeScript types, and the frontend fetcher functions together in one pass. Deployment on Railway, Cloudinary integration, and revalidation on the Vercel side were all carried out end to end. Recording pitfalls — such as publishedAt being a system-managed field — in memory means the same mistake is not repeated the next time.

04. Business automation (using Claude Code without writing code)

Claude Code's MCP can also connect to business SaaS tools. Auto-generating a weekly GA4 report in Docs and posting it to Discord, handling MoneyForward invoice payments via Playwright, and batch-updating every slide of a company overview deck in Google Slides are all run through the same operating setup as code generation. The line between "Claude Code that writes code" and "Claude Code that runs operations" turns out to be blurrier than expected.

05. Running multiple design directions in parallel

When deciding the direction for a design refresh, instead of the usual grind of exhausting yourself on a single draft, Claude Code can generate separate branches in parallel using worktrees. Several styles — Scandinavian, organic, academic, multicolor — can be run side by side and compared within a single day. It is not an A/B test; it is an A-through-F test.

Governance: quality gates and pull-request workflow

Making explicit what Claude Code is not allowed to do is what lets speed and avoiding incidents coexist.

A three-layer review gate

Every code change had to pass through these gates before merging.

• 1. Designer review: every change touching UI
• 2. CTO review: anything involving database sync gaps, deploy mistakes, or infrastructure
• 3. CEO review: the final gate before reporting to the owner

Basic mistakes that the owner would otherwise have to catch are filtered out through mutual review between Claude Code instances, which saves owner time while still maintaining quality.

No direct pushes to main; pull-request workflow

Because the number of deploys to Vercel and Railway feeds directly into billing, the target was at most one production deploy per day: work on a feature branch, commit and push, open a pull request, share the preview URL on Discord, get the owner's visual sign-off, get an explicit "go ahead and merge," then squash-merge.

The important part is that "go ahead" means keep working and share the preview — it does not mean merge. Without writing that distinction down in memory, Claude Code will merge on its own by mistake.

Discord notifications tying every output together

Every completed task, error, and research finding was sent to a Discord webhook as a color-coded embed (green for success, orange for a fix, red for an error, blue for information), which sped up visual triage. Being able to check status from a phone meant decisions could be made while away from the desk.

Failures and fixes

Success stories alone don't tell you how to reproduce the result. Here are the pitfalls hit during the month, and how they were addressed.

No direct text-editing API in the Canva MCP

Updating the company overview deck got stuck here. Generating a diff-based guide and posting comments both work, but direct text editing does not. The workaround was switching to Google Slides and batch-updating every slide with batch_update_presentation.

Vercel Preview Protection returned a 401 to Claude Code

Claude Code could not access preview URLs because Vercel authentication blocked it. Automated screenshot verification was dropped in favor of the owner checking visually, with Claude Code responsible for build logs and lint, and the owner responsible for reviewing the preview.

Forgot to reissue a Strapi API token

After an environment-variable change on Railway, the token expired and writes to production data stopped working, halting progress. The fix was writing the token-retrieval procedure (via vercel env pull) into memory as a fixed step, and always reconfirming it before any token-related work.

An approval-flow design mistake led to an unintended production merge

Ambiguity in an instruction word ("go ahead") was read inconsistently, sometimes as continue working and sometimes as go ahead and merge, and this led to a production merge at an unintended time. The fix was to only allow production merges on an explicit keyword ("merge it"), and that rule was written into memory. Leaving the line for approval fuzzy trades away safety for speed.

What's next

• Extending self-built agents with the Claude Agent SDK
• Building custom MCP servers for internal tool integration
• Fully automating recurring batch jobs with cron plus Claude Code
• Running multiple machines in parallel (an M1 Mac plus a cloud VM)

Summary

A month of 435 commits across 4 projects run by 1 person would not have been possible without Claude Code.

No single feature is what makes this work — combining Sub-Agents, Task, Memory, Skill, and MCP together is what does. Memory and Skill in particular are what make running several projects in parallel sustainable, on two counts: not repeating the same caution every time, and keeping a role consistent.

What matters most is designing what Claude Code is not allowed to do. Without turning merge approval, deploy frequency, and the review layers into explicit rules, speed comes at the cost of incidents.

Claude Code reads less like a subordinate and more like an organization. For one person running several projects at once, the operating design itself is what determines the outcome.