Running Four Projects Solo With Claude Code for One Month

Tomohiro Iida · Published: April 23, 2026Last updated: October 14, 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 — reporting 435 commits in the contemporaneous article. A later default-branch recount found 432. The three-entry difference can be reproduced between the fixed corporate-site history immediately before article creation and the post-merge history; the original counting command remains unrecovered. 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.

This is an early field measurement covering March 23 to April 23, 2026. The 435-commit record remains part of the historical evidence, but the operating setup from that period is not presented as Netsujo's current recommended architecture. Our later practice puts state, authority, evidence, and independent QC ahead of raw parallelism.

The month in numbers

The commit, project, and deployment counts describe activity during 31 days, not a measured productivity gain. We did not establish a comparable pre-adoption baseline for human time, accepted deliverables, defect rates, or operating costs.

• 435 commits — the original one-month reported 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

Evidence audit, October 13, 2026: the original figures total 435. Recounting current default-branch histories with the UTC window March 23 through April 23, 2026 gives corporate site 197, owned media 182, restaurant site 43 and CMS 10, totaling 432. At the fixed parent commit immediately before article creation, the corporate site has 200 commits in the same UTC window; the fixed post-merge revision has 197. This history difference reproduces the three-count gap without changing the time window. The original counting command remains unrecovered, so the chart retains the historical 435 total and does not claim productivity or quality gains.

Alongside the four projects, we also handled internal tooling such as invoicing and Google Workspace integration. Much of the implementation was carried out through Claude Code, but total human time for decisions, prompts, reviews and recovery was not measured against a control period. The record does not quantify time saved.

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. Role-specific prompts and reference rules were intended to make review criteria more consistent; this article does not quantify their effect on defects or review quality.

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 examined via MCP, and 17 proposed SEO items were applied in one pull request. The changes included work on discovered-not-indexed pages, structured-data warnings, redirects and Open Graph metadata. Some measures were later retracted as incorrect, including using the Google Indexing API for ordinary pages; the initial count is therefore not a count of validated successes. No controlled human-versus-AI completion-time comparison was performed.

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

The contemporaneous account reported 435 commits across four projects and one owner; our scoped default-branch recount returns 432, with the three-entry difference reproduced across fixed corporate-site histories, while the original counting command remains unrecovered. Neither total establishes what would have happened without Claude Code or measures accepted output quality or productivity improvement.

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.