The 3-Project Sweet Spot: How AI Enables Impossible Productivity
The 3-Project Sweet Spot: How AI Enables Impossible Productivity
Date: December 19, 2025 Author: Jamie Watters
The Myth of Multitasking
Humans can't multitask. Every productivity study confirms it. When we try to do two things at once, we do both poorly.
But here's what I've discovered: AI doesn't enable multitasking - it enables hyper-efficient task switching.
Over the past 3 days, I shipped:
- Trader-7 v5.0: 11 sprints, complete risk architecture overhaul (~2,500 lines, 300+ tests)
- AImpactScanner.com: LLMs.txt API, support for rendered sites
- LLMTxtMastery.com: API redesign + Landing page redesign
All three required intellectual input. Design decisions. Architecture assessment. Strategic thinking.
Total time on Trader-7? Under 8 hours.
The Workflow That Changed Everything
Here's the pattern:
- Kick off work on Project A - Give Claude the context, the objective, the constraints
- While Claude works, switch to Project B - Review what the agent delivered, make decisions, kick off next task
- Switch to Project C - Same process
- Return to Project A - Agent has finished, review the output, iterate
I rarely wait for AI.
The key insight: Claude Code agents take 2-10 minutes to complete substantial tasks. That's not "waiting time" - that's time to context switch to another project where an agent just finished.
Why 3 Projects is the Sweet Spot
I've experimented with this pattern for months. Here's what I've learned:
| Projects | Result |
|---|---|
| 1 | Not productive enough - waiting for agents |
| 2 | Better, but still some idle time |
| 3 | Sweet spot - always something ready to review |
| 4+ | Start losing track, context switching overhead kills gains |
Three projects keeps me in flow. There's always something to assess, decide, or kick off. The cognitive load stays manageable because I'm not truly "multitasking" - I'm sequentially focusing on one thing at a time, with AI filling the gaps.
What This Actually Looked Like
Trader-7 v5.0 (11 Sprints in ~8 hours)
While AImpactScanner's API was being refactored and LLMTxtMastery's landing page was being redesigned, I was:
- Reviewing Sprint 38's Risk Monitor Loop implementation
- Approving Sprint 40's 4-Tier Regime Architecture
- Catching a typo in Sprint 39's correlation manager (
trade.directionshould betrade.side) - Deploying Sprint 47's staleness threshold fix
Each interaction was focused: review the output, make a decision, kick off the next task, switch projects.
The Sprint Breakdown
| Sprint | What Was Built | My Input |
|---|---|---|
| 37 | StateManager (4 trading states, auto-recovery) | Define the states and recovery logic |
| 38 | 5-min Risk Monitor Loop | Specify thresholds (15% drawdown, 5% crash) |
| 39 | Correlation-aware position limits | Define cluster groupings (BTC/ETH/SOL) |
| 40 | 4-Tier Regime Architecture | Specify regime thresholds (200MA distance) |
| 41 | Asset-specific risk profiles | Define SOL = 50% of BTC position size |
| 42 | Funding rate optimization | Explain the funding rate edge |
| 43 | SOL/XRP special handling | Identify unique risks per asset |
| 44 | Mean-reversion strategy config | Define RSI levels, max hold time |
| 45 | Cross-asset confirmation | Specify +10% when BTC/ETH align |
| 46 | Documentation update | Review and approve |
| 47 | Mode-aware staleness thresholds | Specify 15s live, 15min paper |
My job: domain expertise and decisions. Claude's job: implementation and testing.
The Mental Model Shift
Old way: "I need to finish Project A before starting Project B"
New way: "I'll give Project A direction, then use the execution time productively on Project B"
This isn't about working faster. It's about eliminating idle time while maintaining focus.
When Claude is writing 500 lines of code and 20 unit tests for the Risk Monitor Loop, that's 5-10 minutes where my brain would otherwise be waiting. Instead, I'm reviewing the API redesign on AImpactScanner, making decisions about error handling and rate limiting.
Practical Tips for Builders
1. Choose Complementary Projects
My three projects were:
- Trader-7: Backend Python, risk systems, trading logic
- AImpactScanner: API design, web scraping, infrastructure
- LLMTxtMastery: Landing pages, marketing copy, user experience
Different mental contexts. Switching between them felt refreshing, not exhausting.
2. Write Clear Kick-Off Prompts
Bad: "Add risk monitoring"
Good: "Implement a 5-minute Risk Monitor Loop that checks: (1) portfolio drawdown with 15% emergency threshold, (2) intraday crashes of 5% in 15-minute window, (3) data staleness beyond 60 seconds. Create entry point for Railway cron. Include tests."
Clear prompts = less back-and-forth = more parallel execution time.
3. Trust the Tests
Every sprint had comprehensive tests. This meant I could review quickly:
- Tests pass? Implementation is likely correct.
- Tests fail? Clear signal where to focus.
Testing isn't overhead - it's what enables confident parallel development.
4. Use Log Review as Quality Control
Two bugs in Trader-7 v5.0 were caught during overnight log review:
AttributeError: 'PositionSize' object has no attribute 'base_size'AttributeError: 'Trade' object has no attribute 'direction'
Paper trading + log review = catch bugs before they cost money.
5. Know Your Limit
For me, it's 3 projects. For you, it might be 2 or 4. Pay attention to when you start losing track of what's happening where. That's your signal you've exceeded your capacity.
The Results
In under 8 hours of actual Trader-7 focus time (spread across 3 days while running 2 other major projects):
- 11 sprints completed (37-47)
- ~2,500 lines of production code
- 300+ unit tests (all passing)
- 12 new Python modules
- Zero production incidents
- Complete v5.0 risk architecture:
- Two-loop architecture (Decision + Risk)
- 4-tier market regime detection
- Correlation-aware position limits
- Asset-specific risk sizing
- Mean-reversion strategy
- Cross-asset signal confirmation
Claude's original estimate for v5.0: 68-88 hours.
Conclusion
AI doesn't make you a multitasker. It makes you a hyper-efficient task switcher.
The 3-project pattern works because:
- You're always sequentially focused (humans are good at this)
- AI fills the execution gaps (no waiting)
- Context switching becomes a feature, not a bug (mental refresh)
If you're building with AI and only working on one project at a time, you're leaving productivity on the table. Find your sweet spot. For most people, it's 2-4 parallel projects.
The future of solo building isn't about AI doing everything. It's about AI enabling impossible throughput while you stay in the driver's seat.
Jamie Watters is a solo founder building Trader-7 (LLM-powered crypto trading), AImpactScanner.com (AI impact assessment), and LLMTxtMastery.com (llms.txt tooling). All three projects use Claude Code with the AGENT-11 development framework.