From Idea to MVP: How I Use AI Agent Conversations to Build New Products

A Different Kind of Team Meeting with AI Agents

Sometimes I start a new product, I don't brainstorm alone. I open a chat and invite a few AI agents to talk. Each one plays a role — a product designer, a domain expert, an engineer, a UX expert — and I act as the human orchestrator, keeping the conversation focused and meaningful.

This is my working pattern for agentic AI — a lightweight form of AI orchestration where roles think out loud together.

This pattern started as an experiment but quickly became one of my favorite ways to move from idea to MVP when working on AI agents projects. Instead of trying to come up with every idea on my own and providing long prompts, I run multi-agent conversations that think out loud, debate ideas, and sketch solutions in real time. My latest example: ADHD Companion — a privacy-first, on-device coaching chatbot built on the foundation of my earlier CBT Companion project. These projects are experiments with on-device models.

I'll walk you through how I used these agent conversations to design and build the ADHD Companion, what happens when the same agent tries to play too many roles, and why I think the future of product development looks a lot more like a group chat than a sprint planning board.

Orchestrating AI Agent Conversations

When I talk about multi-agent collaboration, I'm really talking about what I call role-based reasoning — giving each agent a clear identity and focus, then letting them talk. Each role brings a different perspective: one focuses as a domain expert, for instance a mental health specialist and behavior, another on design and flow, another on feasibility and structure. Their conversations don't replace my thinking; they multiply it.

For the ADHD Companion, I started every session by defining four roles — ADHD Specialist, Product Designer, UI/UX Expert, and Engineer — and prompting them to discuss a single topic until they reached some form of consensus or tension. My role was to keep the discussion productive: jumping in when reasoning drifted, clarifying intent, and deciding when a conversation was ready to turn into action.

This process feels less like managing prompts and more like facilitating a creative meeting. Sometimes the dialogue leads somewhere unexpected; other times it needs steering. But what consistently works is how these AI roles challenge each other's assumptions in real time.

Case Study: ADHD Companion (an on-device model experiment with WebLLM)

The ADHD Companion project started as a follow-up to my earlier CBT Companion, which used on-device language models for privacy-preserving mental health coaching. The goal this time was to create a focused, ADHD-specific companion that helps users manage focus, task initiation, and motivation — all without sending any data to the cloud.

Technically, it runs entirely in the browser using WebLLM (@mlc-ai/web-llm v0.2.79) with the Phi 3.5 Mini model (800MB, q4f16_1). Sessions are saved as encrypted .adhd files stored locally on the user's device.

Rather than brainstorming features alone, I orchestrated the entire product through a multi-agent conversation inside Claude Code. In this setup, Claude played all roles — Product Designer, ADHD Specialist, UI/UX Expert, and Engineer — while I guided the flow, switching roles when the discussion naturally evolved. My job was to stay in the loop: reviewing reasoning, redirecting when it drifted, and grounding the dialogue in real design and user needs.

Here's a snapshot of how these conversations unfolded (not the full dialogue, but representative exchanges after providing initial context):

1Human (Me): "Claude, I want you to simulate a product team. You'll play multiple 
2roles — Product Designer, ADHD Specialist, UX Expert, and Engineer. I'll step in 
3to guide when needed. Let's start with PD and ADHD Specialist defining what this 
4app should feel like."
5
6Claude (Product Designer): "Understood. I'll start by asking the ADHD Specialist 
7what challenges users face."
8
9Claude (ADHD Specialist): "ADHD users struggle with executive function — starting, 
10planning, regulating emotions. The chatbot needs to give short, kind, single-focus 
11responses."

That first exchange defined the foundation: this isn't therapy, it's coaching — empathetic, actionable, and designed for how ADHD brains work.

As the discussion evolved, the conversation expanded to include engineering and UX. The same Claude instance switched roles fluidly, discussing design tradeoffs and implementation details:

1Claude (Product Designer): "Would saving progress motivate users, or feel like 
2pressure?"
3
4Claude (ADHD Specialist): "Too much persistence might backfire. Keep it optional."

What emerged from these orchestrated exchanges was a coherent, privacy-first MVP built around clarity, calm, and trust — a lightweight on-device companion that feels intentional, not mechanical.

The Limits and Biases

Here's the honest part: I used the same Claude Code agent for all of those roles. It worked well enough for small projects, but the quality dipped as conversations grew. Cognitive bias and role bleed are real — the model carries assumptions from one role into another.

This ties back to my earlier post on the Reflection Pattern: separating agents (different sessions or even different platforms) gives more reliable, diverse reasoning, but it's a heavier lift. For quick MVPs, a single-agent conversation works. For larger systems, independent agents or hybrid setups are worth the complexity. This is where role isolation in multi-agent systems helps — less bias propagation and clearer debate.

Human in the Loop: Stay Active

In my earlier post, Why Reading the Chain of Thought Matters More Than Code, I argued that the real value of working with AI isn't in what it outputs, but in how it thinks along the way. That same principle drives this workflow. When you can read and respond to the model's reasoning in real time, you stay in control of the direction and quality of the work.

Passive prompting doesn't cut it. The model can drift, fixate, or quietly make wrong assumptions. Staying active means watching how reasoning unfolds — when an agent's focus slips, when two roles start echoing each other, or when bias seeps in. That's when I interrupt, add context, or restate intent.

I treat these sessions less like automation and more like co-facilitation. The best results happen when I step into the flow — giving feedback, breaking long chains into checkpoints, and deciding when an idea is mature enough to move from conversation to implementation. Reading the chain of thought isn't micromanagement; it's what keeps the whole system honest.

Key Takeaways

Across all these experiments — from CBT Companion to ADHD Companion and beyond — what I've learned isn't just about the products themselves, but about the process of building them. When you start treating AI agents as collaborators, the creative work changes shape. It becomes a dialogue — fluid, iterative, and alive.

Orchestrating these agent conversations has shown me that the most valuable moments aren't in the outputs, but in the reasoning in between — when roles debate, tension surfaces, and ideas sharpen. The human role isn't to automate creativity but to stay present in it — steering, editing, and keeping the system honest.

For small, fast projects, one model can play multiple roles. For larger, more ambitious ones, separating agents brings richer reflection and better balance. Either way, the rhythm stays the same: human idea → agent conversation → human reflection → build.

The future of making things will look less like solo ideation and more like orchestration — a mix of human intention and AI reasoning, unfolding in conversation.