Orchestrates Product Manager, UX Designer, and Claude Code agents to build production systems from domain requirements. Implements multi-agent workflows for requirements, design, and implementation.
A complete toolkit for orchestrating AI-powered Product Managers, UX Designers, and Claude Code to build production systems from domain requirements.
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.
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/
```
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?
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`
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
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
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
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
**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
```
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.
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.
Leave a review
No reviews yet. Be the first to review this skill!
# Download SKILL.md from killerskills.ai/api/skills/3-ai-amigos-orchestrator/raw