Why I Built an Agent Swarm to Analyze 111 Projects

The Problem

After 10 years of building software, I had accumulated 111 projects across my development directories. Some were production apps, some were experiments, some were abandoned prototypes. I had no idea what I actually had.

Manually reviewing each project would take days. Reading every README, scanning every package.json, understanding each architecture — it's the kind of tedious work that kills momentum. So I did what any engineer would do: I automated it.

The Architecture

I used Claude Code's built-in Agent tool to dispatch 8 parallel explorer sub-agents, each responsible for ~14 projects. Each agent independently:

• Read manifest files (package.json, Cargo.toml, requirements.txt)
• Scanned directory structures for architecture patterns
• Identified tech stacks, maturity levels, and potential
• Produced structured analysis with digital product assessments

// 8 agents launched in parallel — one message, 8 tool calls
Agent({ subagent_type: "Explore", prompt: "Analyze batch 1..." })
Agent({ subagent_type: "Explore", prompt: "Analyze batch 2..." })
// ... all 8 dispatched simultaneously

Once all 8 returned, a 9th consolidator agent processed every finding and synthesized 5 concrete product opportunities with revenue models, tech stacks, and go-to-market strategies.

What I Learned

1. Parallelism is the killer feature. Eight agents completed in ~2 minutes what would have taken me 2 days. The key insight: Claude Code agents share nothing. Each gets its own context window, its own file access, its own reasoning. This makes them embarrassingly parallel.

2. Batch size matters. I tried 4 agents with ~28 projects each first. The context windows got too crowded and analysis quality dropped. 14 projects per agent was the sweet spot — enough context to compare, not so much that details got lost.

3. The consolidator is where magic happens. Individual project analysis is table stakes. The real value was the consolidator agent finding combinations across projects — like combining my Rust trading engine with my agent orchestration platform to propose an autonomous trading system.

The best product ideas weren't in any single project. They were in the intersections between projects I'd never mentally connected.

The Results

The swarm identified 5 product opportunities, ranked by market size, existing code maturity, and founder-market fit. The top recommendation — a gamified interview prep platform — already had an existing codebase with Monaco Editor integration, Auth.js, and a 28-week product roadmap I'd written months ago and forgotten about.

The entire process — from "I wonder what's in these folders" to "here are 5 products ranked by revenue potential" — took under 10 minutes.

When to Use Agent Swarms

This pattern works whenever you have:

• Embarrassingly parallel work — tasks that don't depend on each other
• Volume that exceeds one context window — too many files/projects for one pass
• A synthesis step — where combining findings produces insight greater than the sum

Other use cases I've since applied it to: auditing test coverage across a monorepo, reviewing dependencies for security vulnerabilities across multiple services, and generating migration plans for legacy codebases.

The agent swarm isn't a novelty. It's a practical pattern for any developer with a Claude Code subscription and work that scales horizontally.