Skip to content

02 personas persona selection guide

Jump to bottom
Doug Beard edited this page Aug 21, 2025 · 3 revisions

Persona Selection Guide - Which Agent Should I Use?

This guide helps you choose the right Coherence APM Framework v4.2.0 agent for your current task. Each of the 11 specialized agents is designed for specific aspects of software development and project management.

🎯 Quick Decision Tree

What do you need to do?
│
├─ 💡 "I have an idea to explore"
│   └─ Use: /analyst
│
├─ 📄 "I need to document requirements"
│   └─ Use: /pm (Product Manager)
│
├─ 🏗️ "I need to design the system"
│   └─ Use: /architect
│
├─ 🎨 "I need to design the UI/UX"
│   └─ Use: /design-architect
│
├─ 📋 "I need to manage the backlog"
│   └─ Use: /po (Product Owner)
│
├─ 📝 "I need to create user stories"
│   └─ Use: /sm (Scrum Master)
│
├─ 💻 "I need to write code"
│   └─ Use: /dev (Developer) or /developer (Senior Developer)
│
├─ 🔍 "I need to test/validate"
│   └─ Use: /qa (Quality Assurance)
│
└─ 🎯 "I need coordination/guidance"
    └─ Use: /coherence (Coherence Orchestrator)

👥 Meet Your Agent Team

🎯 Coherence Orchestrator

Command: /coherence

When to Use:

  • Starting a new session
  • Need guidance on which agent to use
  • Coordinating multiple agents
  • Managing complex workflows
  • Getting project status updates
  • Unified context engineering

Specialties:

  • Unified context engineering
  • Native sub-agent coordination
  • Central workflow management
  • Agent delegation with seamless handoffs
  • Context preservation and session management
  • Project oversight with orchestrated intelligence

Voice Integration: Uses speakOrchestrator.sh with configurable TTS providers

Example Scenarios:

"Help me plan my project workflow"
"Which agent should I use for this task?"
"Show me the project status"
"Guide me through building an API"
"Initialize unified context engineering"

🔧 Coherence Orchestrator (Legacy)

Command: /coherence

When to Use:

  • Legacy system compatibility
  • Backward compatibility requirements

Note: Consider migrating to /coherence for enhanced capabilities

🔍 Analyst

Command: /analyst

When to Use:

  • Starting a new project
  • Exploring ideas
  • Gathering requirements
  • Researching solutions
  • Validating concepts

Specialties:

  • Brainstorming facilitation
  • Requirements gathering
  • Market research
  • Feasibility analysis
  • Problem definition

Voice Integration: Uses speakAnalyst.sh with TTS support

Example Scenarios:

"Help me brainstorm a fitness tracking app"
"Research authentication best practices"
"Analyze requirements for a payment system"
"Validate this business idea"

Parallel Alternative: /planning-brainstorming

📊 Product Manager (PM)

Command: /pm

When to Use:

  • Creating Product Requirements Documents (PRD)
  • Defining product vision
  • Planning features
  • Setting success metrics
  • Stakeholder communication prep

Specialties:

  • PRD creation
  • Feature prioritization
  • User story mapping
  • Success metrics definition
  • Roadmap planning

Voice Integration: Uses speakPm.sh with TTS support

Example Scenarios:

"Create a PRD for our todo application"
"Define success metrics for this feature"
"Prioritize these feature requests"
"Plan the product roadmap"

Parallel Alternative: /planning-prd (70% faster)

🏗️ System Architect

Command: /architect

When to Use:

  • Designing system architecture
  • Choosing technology stack
  • Planning integrations
  • Defining APIs
  • Solving technical challenges

Specialties:

  • System design
  • Technology selection
  • Architecture patterns
  • Scalability planning
  • Security architecture

Voice Integration: Uses speakArchitect.sh with TTS support

Example Scenarios:

"Design architecture for a chat application"
"Choose the tech stack for our project"
"Plan microservices architecture"
"Design the Coherence systemI structure"

Parallel Alternative: /planning-architecture (75% faster)

🎨 Design Architect

Command: /design-architect

When to Use:

  • Designing user interfaces
  • Creating UX specifications
  • Planning frontend architecture
  • Defining design systems
  • Creating UI component libraries

Specialties:

  • UI/UX design
  • Frontend architecture
  • Component design
  • Design systems
  • Responsive layouts

Voice Integration: Uses speakDesignArchitect.sh with TTS support

Example Scenarios:

"Design the UI for our dashboard"
"Create a design system"
"Plan the frontend architecture"
"Design mobile-responsive layouts"

Parallel Alternative: /planning-frontend-architecture

📋 Product Owner (PO)

Command: /po

When to Use:

  • Managing product backlog
  • Grooming user stories
  • Planning sprints
  • Prioritizing work
  • Defining acceptance criteria

Specialties:

  • Backlog management
  • Story grooming
  • Sprint planning
  • Prioritization
  • Stakeholder management

Voice Integration: Uses speakPo.sh with TTS support

Example Scenarios:

"Groom the backlog for next sprint"
"Create epics from the PRD"
"Prioritize these user stories"
"Define acceptance criteria"

Parallel Alternative: /planning-epic, /planning-stories

🏃 Scrum Master (SM)

Command: /sm

When to Use:

  • Creating user stories
  • Planning sprints
  • Facilitating ceremonies
  • Removing blockers
  • Process improvement

Specialties:

  • Story creation
  • Sprint facilitation
  • Process optimization
  • Team coordination
  • Agile coaching

Voice Integration: Uses speakSm.sh with TTS support

Example Scenarios:

"Create user stories for authentication"
"Plan the next sprint"
"Help resolve this blocker"
"Optimize our development process"

Parallel Alternative: /planning-next-story

💻 Developer

Command: /dev

When to Use:

  • Writing code
  • Implementing features
  • Debugging issues
  • Basic code refactoring
  • Standard technical implementation

Specialties:

  • Code implementation
  • Basic algorithm design
  • Debugging
  • Unit testing
  • Code review

Voice Integration: Uses speakDeveloper.sh with TTS support

Example Scenarios:

"Implement user authentication"
"Debug this error"
"Write unit tests"
"Implement this feature"

💻 Senior Developer

Command: /developer

When to Use:

  • Complex code architecture
  • Advanced debugging
  • Performance optimization
  • Code refactoring for scalability
  • Technical leadership tasks

Specialties:

  • Advanced architecture patterns
  • Performance optimization
  • Complex algorithm design
  • Code refactoring
  • Technical mentoring

Voice Integration: Uses speakDeveloper.sh with TTS support

Example Scenarios:

"Optimize this algorithm for performance"
"Refactor this code for better architecture"
"Design a complex data structure"
"Lead technical implementation"

Note: Both developer personas can spawn multiple instances for parallel development

🔍 Quality Assurance (QA)

Command: /qa

When to Use:

  • Creating test plans
  • Writing test cases
  • Performing testing
  • Quality validation
  • Bug tracking

Specialties:

  • Test strategy
  • Test automation
  • Quality metrics
  • Bug detection (92-
  • Performance testing

Voice Integration: Uses speakQa.sh with TTS support

Example Scenarios:

"Create test plan for this feature"
"Write test cases for authentication"
"Perform security testing"
"Validate the implementation"

Parallel Alternative: /qa-framework (comprehensive testing)

🔄 Typical Workflow Sequences

New Project Workflow

1. /coherence → Initialize Coherence Orchestrator
2. /analyst → Explore and research
3. /pm → Create PRD
4. /architect → Design system
5. /po → Create backlog
6. /sm → Generate stories
7. /dev or /developer → Implement
8. /qa → Test and validate

Feature Development Workflow

1. /analyst → Research requirements
2. /architect → Technical design
3. /sm → Create stories
4. /dev → Implementation
5. /qa → Testing

Quick Prototype Workflow

1. /analyst → Quick ideation
2. /design-architect → UI mockup
3. /dev → Rapid prototype

Bug Fix Workflow

1. /qa → Identify issue
2. /dev → Fix implementation
3. /qa → Validate fix

⚡ Parallel Execution Guide

When to Use Parallel Commands

Use parallel commands when you need:

  • Multiple analyses simultaneously
  • Faster document generation
  • Batch processing of similar tasks
  • Comprehensive coverage quickly

Parallel Command Mapping

Sequential Parallel Speed Gain
/analyst /planning-brainstorming 4x
/pm /planning-prd 70% faster
/architect /planning-architecture 75% faster
/po + /sm /planning-stories 4x
/qa /qa-framework 4x

💡 Best Practices

1. Start with the Coherence Orchestrator

Always begin with /coherence to initialize the unified context engineering system and get guidance.

2. Follow the Natural Flow

Idea → Research → Requirements → Design → Implementation → Testing

3. Use Specialists for Depth

Each agent is an expert - use them for their specialty.

4. Leverage Parallel for Speed

When time matters, use parallel commands.

5. Maintain Context

Agents share session notes - no need to repeat information.

🎯 Decision Matrix

I Need To... Best Agent Alternative Parallel Option
Explore ideas Analyst PM /planning-brainstorming
Write requirements PM Analyst /planning-prd
Design system Architect Design Arch /planning-architecture
Design UI Design Arch Architect /planning-frontend-architecture
Manage backlog PO SM /planning-stories
Create stories SM PO /planning-next-story
Write code Developer/Senior Dev - Multiple developers
Test code QA Developer /qa-framework
Coordinate Coherence Orchestrator Coherence Orchestrator (legacy) -

📊 Agent Collaboration Patterns

Sequential Handoff

Analyst → PM → Architect → Developer → QA

Each agent completes their work before handing off.

Parallel Coordination

        ┌→ Developer 1
Architect → Developer 2
        └→ Developer 3

Multiple agents work simultaneously.

Iterative Refinement

PM ↔ Architect ↔ Developer

Agents collaborate back and forth.

Hub and Spoke

    Analyst
       ↓
  Orchestrator → PM
       ↓       ↘ Architect
   Developer    ↘ QA

Orchestrator coordinates multiple specialists.

🚨 Common Mistakes to Avoid

❌ Using the Wrong Agent

  • Wrong: Using Developer for requirements gathering
  • Right: Use Analyst or PM for requirements

❌ Skipping Planning Phases

  • Wrong: Jumping straight to development
  • Right: Research → Plan → Design → Develop

❌ Not Using Parallel Commands

  • Wrong: Sequential execution for everything
  • Right: Use parallel for appropriate tasks

❌ Forgetting Context

  • Wrong: Repeating information to each agent
  • Right: Agents share context automatically

🎪 Pro Tips

Rapid Prototyping

/planning-brainstorming  # Quick ideation
/design-architect        # Fast UI design
/dev                     # Immediate implementation

Comprehensive Documentation

/planning-prd            # Complete PRD
/planning-architecture   # Full system design
/planning-stories        # All user stories

Quality-First Development

/qa-framework           # Set quality standards first
/dev                    # Develop with quality in mind
/parallel-test          # Comprehensive testing

📚 Learn More

🆘 Need Help?

  • Can't decide? Use /coherence and ask for guidance
  • Want details? Read the specific agent guide
  • Need examples? Check the examples directory
  • Still stuck? See troubleshooting guide

Remember: Each agent is a specialist. Use the right expert for the right job!

Clone this wiki locally