How I used a team of 15 agents with 4 prompts

I keep seeing people ask about how to use coding agents for more complex products that involve:

• Algorithms (ML, scoring, reputation, graphs…)
• Databases, APIs, or scheduled jobs
• Multi-component systems (backend + frontend + SDKs + MCPs)
• Low-level or infrastructure-focused tools

👉 This is exactly what we're getting into now.

(Other topics like release pipelines, security, testing, auth, and compliance are coming soon.)

So here it is: a real product, built from scratch, using only multi-agent prompts — including real data fetching, a working DB, backend and frontend logic, and UI.

🤖 The Multi-Agent Framework, Step by Step

Each agent has awareness of the broader process — not just its own task.

Learning from how different teams work together, there's value in differentiating roles and ensuring they orchestrate well.

The Product Manager doesn't just define a spec — it also adds instructions for the Architect, Designer, and Dev Lead.

The Dev Lead decides how many developers it needs for the task, what their execution order should be, and where their task boundaries lie.

Each agent works with context, not just instructions:

• Its role and responsibility in the overall flow
• Which agents worked before, and what they produced
• Who it's collaborating with next, and what they'll need
• What model it's running on, and how to tailor its output accordingly
• How to share context continuously, like teams syncing in daily standups

This isn't just chaining prompts — it's about shared knowledge

The agents are aware of each other, collaborate asynchronously, and build on one another's work like a team that's always in sync.

It's very basic, but works surprisingly well.

The flow can also be extended into branching paths, feedback loops, and fully autonomous systems.

🧠 The Methodology

Here's how the flow works:

1. Executive → Product Manager
   I wrote a short business goal. That was the only input needed. The rest was already inside the prompt template.
2. Product Manager → Architect
   The agent read the spec and defined the architecture, tech stack, and main components.
3. Product Manager & Architect → Designer
   Created a design system and flow description in markdown — no Figma needed (yes, I know the product designers are doing much more than that, I just simplified it here for our example).
4. Designer & Architect & Designer → Dev Team Lead
   Broke the implementation into tasks, each with full context, test instructions, and checklist.
5. Dev Team Lead → Executors
   Each task was executed by Claude 3.7 or 3.5 Sonnet, which read the spec, implemented the logic, tested it, and logged results.

All of this was done in Cursor. Each output was saved to a markdown file in a dedicated directory.

📂 You can check out the prompt templates here:
👉 github.com/omrilahav/vibe-coding

🛠 The Demo: MCP Registry & Reputation Explorer

To showcase the process (I'm working on a much larger-scale product that will be released soon using the multi-agent framework), I picked a realistic project — something that usually breaks in no-code environments:

• Reputation algorithm
• Real API access
• Fetching + storing real data
• Scheduling
• Clean UI
• Design system
• A working backend + database

The MCP Registry app scans for real MCP servers, pulls metadata, calculates a reputation score, and displays it in a dynamic UI — to help teams select trustable sources.

📏 It Took Just a Short Evening

From empty repo to working product — the whole process took less than a few hours.

Some tasks didn't work on the first try. I copied the error message back into the task prompt, ran it again, and it worked. The agents handled most things really well.

To keep it simple, I only used the Glama MCP API as a source. The pagination didn't work properly, so the app only shows part of the results — but for the scope of the demo, that was fine.

Future versions could include:

• More sources (GitHub scraping, enrichment)
• Feedback scoring and reputation signals
• More polished frontend interactions

But the goal here was to show the process clearly.

🧭 Want to Try It Yourself?

1. Clone the framework repo:
   👉 github.com/omrilahav/vibe-coding
2. Pick a project or feature idea you want to try.
3. Go to 1-product-manager.md, and write your business goal in the placeholder.
   • You can see the example input I used here
4. Run the prompt in Claude 3.7 Sonnet (Cursor is what I used)
5. Save the output in product/, then move on to the next prompt (it already happens automatically for you)
6. Repeat the process — each agent reads the previous output and generates the next
7. When the Dev Lead creates tasks, give each one to a new agent and run them in order

You'll end up with a full set of outputs — specs, architecture, design, code, and tests — all created by AI agents, connected by context.

📁 What's in the Demo Repo

You can explore all of this in the demo repo.
Each folder contains actual agent output:

• product/ — product spec, user stories, value props
• architecture/ — stack choices, component diagrams, data flow
• design/ — design system, screens, layout instructions
• tasks/ — implementation plan + task-by-task execution logs
• demo-methodology-files/ — prompt files + initial input

The product works, even with limited data sources. More importantly, it shows how the agents collaborated to build it.

🚀 What's Next

This is just one possible direction.
The same methodology can support:

• Feature requests and product growth
• CI/CD flows
• Secure development and SSDLC
• Agent-led QA and testing
• Monitoring and incident workflows

The long-term goal is to create clear, open flows that allow agents to collaborate like systems — with shared knowledge, scoped decisions, and well-defined responsibilities.