Eight projects in parallel — my agentic coding workflow for one person

TL;DR

Eight active projects in parallel as a solo founder. Possible because of three patterns: Conductor as a context layer, the knowhow plugin for re-entry, and a hard slot rule (max 90 minutes per project at a stretch). This post shows the real daily routine, the telemetry from a typical week, the context-switching bottleneck (the under-reported third of every “X parallel projects” post), and under which conditions the model works for others. Spoiler: not without agentic coding tools.

Featured image placeholder: stylized daily routine with 8 project slots. Asset pending — prompt at end.

Table of Contents

• The eight active projects (May 2026)
• A typical day in slot form
• Telemetry from a typical week
• The three patterns that make it sustainable
• The under-reported third: context switching
• When it works for others (and when not)
• FAQ

The eight active projects (May 2026)

Plus 2-4 side repos on average in reality-check stage (see 424-repos post). But those are not active projects — they are options still inside the 7-day reality-check window.

A typical day in slot form

Date: Thursday, May 8, 2026. Representative, not cherry-picked.

Observations:

• 90-minute rule: no project slot exceeds 90 minutes. Output drops measurably after 90 min (per Conductor telemetry — auto-test needs about 2× more retries for the same code output in the 91-120-min window).
• Switching buffer: 15-min break between dissimilar domains (Flutter/Dart → Python → Go). Not laziness — context reset for both brain and Conductor’s knowhow plugin.
• 8 projects ≠ 8 slots/day: I do not touch all 8 every day. Average is 4-5 slots per day. 2-3 projects run on light maintenance across the week (1 commit per week is enough).

Inline image placeholder: daily routine visualization with 8-slot distribution. Asset pending.

Telemetry from a typical week

Week 19 (May 5-11, 2026), measured via Conductor’s knowhow plugin.

Those 12,400 lines across 8 parallel projects are not the result of “type faster.” They are agentic coding multiplied by 8 — I describe, Claude Code via Conductor implements, I review and commit.

Comparison: Pieter Levels regularly reports on X about his workflows. His magnitude of parallel projects is ~10-12, but revenue-active. My setup is similar in count but different in phase (pre-revenue for most projects).

The three patterns that make it sustainable

Without these three, 8 in parallel is a direct path to burnout.

Pattern 1: Conductor as context layer

Conductor is my agentic coding stack (detailed here). In context of this post, what matters: the 13 plugins allow project-scoped contexts. When I am in slot 2 (Bonblick), Conductor only loads Bonblick-relevant context. When I switch to slot 4 (Conductor itself), all of it is gone.

Without this scoping mechanism, my Claude Code context would get poisoned after 3 slots — cross-pollution between projects is real and subtle (Anthropic documents this in their engineering blog on context engineering).

Pattern 2: knowhow plugin for re-entry

The single plugin with the biggest productivity lever. knowhow project-status gives a 30-second overview on switch-in:

• Last commit + content
• Open TODOs from CLAUDE.md
• Pending PRs
• Open issues, sorted by priority
• One-paragraph quick-resume brief

That saves 15-20 minutes of re-entry per slot switch. At 6-7 switches per day = 90-140 minutes recovered.

Pattern 3: 90-minute slot hard-cut

Every slot is maximum 90 minutes. Even when the flow state is pleasant. This rule is non-negotiable.

Why: error rate rises after 90 min, the willingness to switch (= the will to start the next project) drops, and the ADHD hyperfocus risk (see my ADHD experience) becomes real. Hyperfocus on one project eats the whole day — and with it, the other 7.

I learned this rule the hard way. v1.0 of my workflow had no slot limit. Effect: 3 projects active, 5 lingering under the “I’ll-get-back-to-it-soon” excuse. Slot hard-cut fixed it.

The under-reported third: context switching

The honest part most “X parallel projects” posts on Medium and Indie Hackers leave out: context switching is the most expensive operation in this setup, not the coding itself.

Per switch, the following costs apply:

1. Mental reset (~5-10 min, biologically hardcoded — no tool shortens this)
2. Conductor context reload (~30 sec)
3. Knowhow overview (~30 sec)
4. Quick-resume read (~2-3 min)
5. Drift correction if the project moved in a different direction since the last session (~5-15 min, depending on the gap)

Sum: 13-29 min per switch. At 6-7 switches per day: ~90-180 min just for switching.

That is why 8 parallel projects is not “8× the productivity of 1.” It is more like 4-5× — and only with Conductor as multiplier.

Anyone trying this model without agentic coding tools probably ends up at 1.5-2× productivity — and a massive stress level.

Inline image placeholder: bar chart switch costs vs slot costs. Asset pending.

When it works for others (and when not)

Four conditions, all must apply simultaneously:

1. Agentic coding stack in daily use. Without Claude Code, Cursor, or similar, 8 parallel projects is not possible — writing speed only supports 2-3 active projects.
2. Self-directed over your daypart. With fixed meeting times or office hours, the 90-min slot rule does not hold. The system breaks.
3. Pre-revenue tolerance. 8 in parallel means most are pre-revenue for a long time. If you need monthly cashflow, focus on 2-3 revenue projects, not 8.
4. Hyperfocus-tolerant temperament. Not everyone enjoys switching every 90 min. Some people function better with 4-6h deep-work blocks and one project per day. That is a different setup, not worse, just different.

If even one is missing: less is better. Cal Newport’s deep work model deliberately targets the opposite end — 1 big project, long blocks, minimal switching. Both models work, depending on person.

Where this goes next

Three pain points I am currently working on:

1. Cross-project refactoring. When Conductor itself changes, 8 repos have to adapt their Conductor integration. The knowhow plugin does not catch that — it is a separate cross-repo tool I am planning for v9.
2. Slot auto-tracking. I currently track slots manually in a markdown file. A small side tool that auto-records via Cursor or Claude Code telemetry would help.
3. Burnout early-warning. I know my body-crash pattern, but a tool that warns objectively when I run 4 weeks above average would be insurance.

If you run a similar setup or want to test the 90-min rule: reach me on LinkedIn or GitHub.

FAQ

How many projects should a solo founder run in parallel at most?

Depends on tooling. With an agentic coding stack: 5-10. Without: 2-3. More than 10 is unproductive even with tooling — beyond that, switching cost dominates the switching benefit.

What do 8 parallel projects cost in tooling per month?

Claude Code subscription (~$200/mo Max tier for intensive use), Cloudflare Pages free, GitHub Pro $4, ~10 domains ~€10/mo, Vercel free or Pro $20. Total: **€240-280/month**. Plus electricity and office space share.

How do I avoid burnout with 8 parallel projects?

90-minute slot rule, hard cutoff at 21:00 (or your equivalent), one day per week deliberately offline (for me: Sunday walks), and every 4-6 weeks a reduce-week with only 4 instead of 8 active slots.

What is the best tool for context re-entry between projects?

For me: the knowhow plugin in Conductor. Alternatives: CLAUDE.md/AGENTS.md with a “where we left off” section (per Anthropic’s recommendation), or a commercial tool like Linear for issue-based re-entry. Never work without a dedicated re-entry tool — otherwise 20+ minutes go missing per switch.

Do I have to touch all 8 projects daily?

No. 4-5 per day, the other 2-4 run across the week in maintenance mode. The system tolerates a project being untouched for 3-4 days — as long as the monthly frequency stays high enough for the 30-day silence sweep pattern from the 424-repos post.

Written on May 17, 2026 in Hamburg. Telemetry is real, from a single week. If you find this post useful, link to it.