Vibe Coding at Scale: How AI Agent Fleets Changed My Workflow

What happens when you stop coding one task at a time and start thinking in fleets.

The first time someone called me a "vibe coder" I wasn't sure if it was a compliment. Vibe coding — the practice of describing what you want in natural language and letting an AI generate the implementation — sounded imprecise, unprofessional. Then I tried it with 20 agents running in parallel, and I understood.

What Vibe Coding Actually Means

Vibe coding isn't about being imprecise. It's about operating at a higher level of abstraction. Instead of thinking in functions and loops, you think in outcomes and interfaces. Instead of writing the implementation, you describe the behavior and review the result.

This is how senior engineers have always wanted to work: at the architectural level, with implementation as a detail. AI agents make it real. But one agent is still too slow. The real shift happens at scale.

The Fleet Model

Here's what changed for me: I stopped assigning one task to one agent and started decomposing problems into parallel workstreams. A feature that used to take me 2 days now looks like this:

• Agent 1: Data model + migrations
• Agent 2: API endpoints + validation
• Agent 3: Frontend components
• Agent 4: Tests (unit + integration)
• Agent 5: Documentation + types

I describe each workstream at a high level, assign them to agents on the amux board, and step back. An hour later I have 5 branches to review, merge, and assemble into a feature. The assembly and review is where my actual judgment is spent — not the implementation.

The Skill Shift

Vibe coding at scale requires a different skillset than traditional coding. You need to be good at:

• Decomposition: Breaking a problem into independent workstreams that agents can pursue in parallel without stepping on each other.
• Specification: Writing clear task descriptions that give agents enough context to succeed without constant clarification.
• Review: Reading agent-generated code critically — catching logic errors, security issues, and missed edge cases in code you didn't write.
• Integration: Assembling parallel workstreams into a coherent whole, resolving conflicts, and maintaining consistency.

What I Stopped Doing

I no longer write boilerplate. I no longer look up API docs for common patterns. I no longer manually write tests for code I've already mentally verified. These tasks take time but require minimal judgment. Agents handle them. My time goes to the parts that require genuine thought.

The Honest Tradeoffs

Vibe coding at scale isn't free of friction. Agent output needs review. Parallel branches sometimes conflict. Agents occasionally go in the wrong direction and need course-correction. The management overhead of a fleet is real.

But the net result is clear: I ship more, faster, with higher test coverage than I did coding solo. The fleet is doing work I would have delegated to junior developers — except it's available at midnight, never takes a sick day, and costs $30/day in API tokens.

git clone https://github.com/mixpeek/amux && cd amux && ./install.sh
amux register myproject --dir ~/Dev/myproject --yolo
amux start myproject
amux serve  # → https://localhost:8822