3 AI Amigos Orchestrator

A complete toolkit for orchestrating AI-powered Product Managers, UX Designers, and Claude Code to build production systems from domain requirements.

What This Skill Does

This skill implements the 3 AI Amigos methodology - a multi-agent orchestration pattern that transforms domain expertise into working systems through sequential collaboration between:

1. **Product Manager Agent** - Creates requirements, user stories, and technical architecture

2. **UX Designer Agent** - Designs interfaces, experiences, and visual systems

3. **Claude Code** - Implements the complete production-ready system

The skill provides agent configurations, technical patterns, and workflow orchestration for building complex systems through AI agent collaboration.

Repository Structure

The skill references the following structure from the source repository:

```

agents/ # Agent configurations

pm-agent/ # Product Manager Agent setup

config/ # PM instructions

example-prompts/ # Example PM prompts

ux-agent/ # UX Designer Agent setup

config/ # UX instructions

example-prompts/ # Example UX prompts

code-agent/ # Code Agent setup

config/ # CLAUDE.md template

technical-guides/ # Domain-agnostic patterns

implementation-guide.md

multi-agent-patterns.md

multi-agent-implementation-architecture.md

streaming-patterns.md

use-cases/ # Example implementations

multi-agent-health-insight-system/

docs/ # Guides and documentation

demo-setup-guide.md

po-document-checklist.md

images/

```

Instructions

Phase 1: Initial Setup and Context

When a user wants to implement 3 AI Amigos:

1. **Verify repository structure** - Check that the working directory contains the expected folders (agents/, technical-guides/, use-cases/, docs/)

2. **Provide orientation** - Explain the three-agent architecture:

- PM Agent creates specifications and architecture

- UX Agent creates designs and interface guidelines

- Claude Code implements the system

3. **Identify user's goal** - Ask:

- Are they exploring the methodology?

- Do they want to set up agents?

- Are they ready to build a system?

- Do they have domain documentation ready?

Phase 2: Agent Configuration

If setting up agents:

1. **Read agent configurations** from:

- `agents/pm-agent/config/pm-agent-instructions.md`

- `agents/ux-agent/config/ux-designer-agent-instructions.md`

- `agents/code-agent/config/minimal-claude-md-template.md`

2. **Guide user to configure agents** in Claude Desktop or Claude.ai Projects:

- Create PM Agent project with PM instructions

- Create UX Agent project with UX instructions

- Create Code workspace with CLAUDE.md template

3. **Show example prompts** from:

- `agents/pm-agent/example/prompts/po-prompt-for-pm-agent.md`

- `agents/ux-agent/example/prompts/po-prompt-for-ux-agent.md`

Phase 3: Domain Documentation Preparation

Help user prepare required documents:

1. **Review checklist** - Read `docs/po-document-checklist.md` to understand required documents

2. **Show examples** - Reference health system example in `use-cases/multi-agent-health-insight-system/` as templates

3. **Guide document creation** - Help user prepare:

- Domain requirements and constraints

- Business rules and logic

- User personas and workflows

- Brand guidelines (if applicable)

- Technical constraints

Phase 4: Multi-Agent Workflow Orchestration

When user is ready to build:

1. **PM Agent Phase**:

- Guide user to submit domain docs to PM Agent

- PM creates: requirements, user stories, architecture, data models

- Validate outputs are comprehensive

2. **UX Agent Phase**:

- Guide user to submit PM outputs + domain docs to UX Agent

- UX creates: wireframes, component specs, interaction patterns, design system

- Validate designs align with requirements

3. **Code Agent Phase** (Claude Code):

- Import all outputs into code workspace

- Create CLAUDE.md with complete context

- Implement system following architecture and designs

- Validate against requirements

Phase 5: Technical Patterns and Implementation

Reference technical guides for implementation:

1. **Multi-agent patterns** - Read `technical-guides/multi-agent-patterns.md` for:

- Orchestrator-worker architecture

- Context handoff patterns

- Error handling strategies

2. **Implementation architecture** - Read `technical-guides/multi-agent-implementation-architecture.md` for:

- Backend structure patterns

- Service layer organization

- Data flow patterns

3. **Streaming patterns** - Read `technical-guides/streaming-patterns.md` for:

- Real-time updates

- Progressive rendering

- WebSocket patterns

Phase 6: Example Reference

Use the health system example for guidance:

1. **Read domain docs** from `use-cases/multi-agent-health-insight-system/`:

- Domain requirements

- User stories

- Brand guidelines

- Architecture decisions

2. **Show visual examples** - Reference `health-user-stories.pdf` for UI/UX patterns

3. **Extract patterns** - Help user adapt health system patterns to their domain

Usage Examples

**Example 1: Setting Up Agents**

```

User: "I want to set up the 3 AI Amigos"

Assistant:

1. Read agent configuration files

2. Explain setup in Claude Desktop/Projects

3. Provide configuration instructions for each agent

4. Show example prompts

```

**Example 2: Preparing Domain Docs**

```

User: "What documents do I need for my e-commerce system?"

Assistant:

1. Read po-document-checklist.md

2. Review health example as template

3. Guide creation of e-commerce domain docs

4. Validate completeness

```

**Example 3: Orchestrating Workflow**

```

User: "I'm ready to build my system"

Assistant:

1. Verify domain docs are ready

2. Guide PM Agent phase - requirements creation

3. Guide UX Agent phase - design creation

4. Guide Code Agent phase - implementation

5. Reference technical patterns as needed

```

Important Constraints

1. **Sequential Process** - Agents must be executed in order: PM → UX → Code. Each builds on previous outputs.

2. **Domain Documentation Required** - User must provide domain expertise. Agents implement, but don't define the domain.

3. **Context Handoff** - Each phase must pass complete context to next phase. Read outputs from previous agents before starting next phase.

4. **Domain-Agnostic Core** - Technical patterns in `technical-guides/` work for any domain. Use-cases are examples only.

5. **File Reading Priority** - Always read configuration files and technical guides before providing guidance. Don't rely on summaries.

6. **User is Product Owner** - User provides domain knowledge, validates outputs, and guides agents. Agents are tools, not decision-makers.

Key Files Reference

Success Criteria

This methodology revolutionizes software development by orchestrating specialized AI agents into a collaborative development team, with the human as product owner providing domain expertise and strategic direction.