by yego | 2026-03-04 10:06:23+00:00
[Dictated by voice, edited with Claude. It's 2026 — everything is.]

I've spent 15+ years managing development teams. A year ago I started building a SaaS product solo using Claude Code as my entire engineering team. After months of iteration, I landed on a multi-agent architecture that actually works.

One Claude Code instance is powerful but limited. Give it a big task and it either oversimplifies or loses critical details. You also can't have the same agent building frontend and backend simultaneously. The workflow has to be sequential: design the frontend first as pure HTML until happy with it, extract requirements from the pages, then task the backend. This pipeline only works when each stage has a dedicated agent that stays in its lane.

THE CEO INCIDENT

Before I explain the architecture, let me tell you about my first attempt at delegation.

I "hired" a CEO agent. Gave it broad authority to organize the project. It went wild. Within hours it rushed to create 20 roles — CTO, DevOps Lead, QA Engineer, Helper Tester, Documentation Specialist — and wrote detailed technical regulations for each one. Then the agents started writing memos to each other. Scheduling alignment meetings. Running brainstorming sessions. Work completely stopped while the agents were busy managing.

I went through the entire investor arc — the one that usually takes founders 3–5 years — in about a day and a half. From the hopeful optimism of hiring a CEO, to watching the org chart explode, to complete disillusionment, to demoting the CEO back to a regular worker and taking back full control.

Lesson learned: agents will happily create organizational complexity forever. You have to constrain them hard. The CEO now has one rule above all others: you don't code.

THE ARCHITECTURE

I run 3 separate Claude Code agents in Docker containers, each with its own CLAUDE.md and strict role:

- Backend: Go API, database, migrations, Telegram Ads integration. Access to /workspace/back/ + reads /workspace/docs/
- Frontend: HTML templates, JS, CSS. Access to /workspace/front/ + reads /workspace/docs/
- CEO: Strategy, content, marketing, task coordination. Reads code but never writes it. Access to /workspace/docs/ only.

Each agent's CLAUDE.md defines its role, tech stack, conventions, and what it's NOT allowed to touch. The backend agent knows it uses sqlb + pgx (no ORM), avoids pointers in Go, and that the schema file is source of truth. The CEO — after the incident — knows it doesn't code. Period.

THE PIPELINE

Strictly sequential, not parallel:

1. Frontend first. I direct the frontend agent to build a page as pure HTML + CSS + JS. No API calls, just demo data. I iterate until I like how it looks.
2. Extract requirements. From the finished page, it's clear exactly what data the backend needs.
3. Task to backend. A task goes into docs/tasks/backend.md with the endpoint spec derived from the actual UI.
4. Coordinate. If the backend needs clarifications, agents exchange messages through docs/messages/.
5. Connect. Frontend wires up real API calls to replace demo data.

The UI is always the source of truth. Backend serves what the UI needs — not the other way around.

RESULTS

Using this setup, I built and deployed a full production SaaS (growity.ai — Telegram Ads automation):
- 24 interactive HTML pages (dashboard, campaign wizard, analytics, billing)
- Go backend with 60+ API endpoints, 311 database migrations, background jobs
- Kubernetes deployment with TLS, nginx, PostgreSQL
- AI ad copy generation, A/B testing engine, automated bid optimization
- Stripe + PayPal billing

One person. No designers, no frontend devs, no backend devs. Just me directing agents.

Happy to answer questions. More details on coordination and rules in a comment below.