Skip to main content

​
Agent System Quick Start Guide

​
Overview

You now have a complete agent-based development team with 12 specialized agents that work together to take a product from vision to production.

​
The Team

​
Product & Strategy (3 agents)

  1. Chief Product Officer (@chief-product-officer) - Product vision and roadmaps
  2. Senior Product Manager (@senior-product-manager) - PRDs and requirements
  3. Marketer (@marketer) - Brand identity and design tokens

​
Design (2 agents)

  1. UX Designer (@ux-designer) - Style guides and design systems
  2. Product Designer (@product-designer) - UI specifications

​
Engineering (4 agents)

  1. Software Architect (@software-architect) - System architecture and tech stack
  2. DBA (@dba) - Database design and management
  3. Frontend Developer (@frontend-developer) - UI implementation
  4. Backend Developer (@backend-developer) - API implementation

​
Quality & Operations (3 agents)

  1. App Security Engineer (@app-security-engineer) - Security scanning
  2. Senior QA Engineer (@senior-qa-engineer) - Testing and QA
  3. DevOps Engineer (@devops-engineer) - Infrastructure and deployment

​
How to Use

​
Starting a New Product

Follow this workflow from vision to production: 
1. @chief-product-officer
   ↓ Creates product vision and roadmap

2. @senior-product-manager
   ↓ Writes comprehensive PRD

3. @marketer (parallel)
   @ux-designer (parallel)
   ↓ Create brand guidelines and style guide

4. @product-designer
   ↓ Creates UI designs

5. @software-architect
   ↓ Designs architecture and tech stack

6. @dba (parallel)
   @frontend-developer (parallel)
   @backend-developer (parallel)
   ↓ Implement database, frontend, and backend

7. @app-security-engineer
   ↓ Runs security scans

8. @senior-qa-engineer
   ↓ Tests application

9. @devops-engineer
   ↓ Deploys to production

​
Example: Building a New Feature

User: “I want to build a task management app” Step 1 - Define Vision: 
@chief-product-officer
The CPO will:
  • Research the market
  • Propose product vision
  • Create roadmap
  • Ask for your approval
  • Hand off to Sr PM
Step 2 - Write Requirements: 
@senior-product-manager
The Sr PM will:
  • Read the vision
  • Propose PRD structure
  • Write user stories
  • Define acceptance criteria
  • Hand off to UX Designer and Architect
Step 3 - Design Brand & UX (Parallel): 
@marketer
The Marketer will:
  • Create brand identity
  • Define color palettes
  • Create design tokens
@ux-designer
The UX Designer will:
  • Build style guide
  • Create design system
  • Define components
Step 4 - Design UI: 
@product-designer
The Product Designer will:
  • Create UI specifications
  • Design screens and components
  • Provide developer specs
Step 5 - Plan Architecture: 
@software-architect
The Architect will:
  • Design system architecture
  • Choose tech stack
  • Create API contracts
  • Plan implementation
Step 6 - Build System (Parallel): 
@dba
The DBA will:
  • Design database schema
  • Create migrations
  • Use MCP tools to set up database
@frontend-developer
The Frontend Dev will:
  • Implement UI components
  • Integrate with APIs
  • Ensure accessibility
@backend-developer
The Backend Dev will:
  • Implement APIs
  • Build business logic
  • Integrate with database
Step 7 - Security Scan: 
@app-security-engineer
The Security Engineer will:
  • Run secure-push skill
  • Scan for secrets and vulnerabilities
  • Report findings
  • Approve or block
Step 8 - Test Application: 
@senior-qa-engineer
The QA Engineer will:
  • Create test plan
  • Run Playwright E2E tests
  • Execute integration tests
  • Report results
Step 9 - Deploy: 
@devops-engineer
The DevOps Engineer will:
  • Set up infrastructure
  • Configure CI/CD
  • Deploy to production
  • Monitor

​
Key Principles

​
1. User Confirmation Required

Every agent MUST ask for user approval before creating artifacts. Example: 
## Proposed Changes

[Agent describes what they'll do]

**Do you approve? (Y/n)**
Only after user confirms can the agent proceed.

​
2. Clear Handoffs

Agents explicitly hand off to the next agent: 
## Work Complete ✓

### Deliverables:
- [List of files created]

### Next Steps:
**Ready for handoff to: [Next Agent Name]**

To invoke: `@next-agent-name`

### Notes for next agent:
- [Important context]

​
3. Read Before Write

Agents always read relevant documentation before proposing changes:
  • Product vision
  • PRDs
  • Design specifications
  • Architecture documents

​
4. Standardized Outputs

All agents follow standard directory structures:
  • docs/product/ - Product documentation
  • docs/design/ - Design assets
  • docs/architecture/ - Technical architecture
  • docs/database/ - Database schemas
  • src/ - Source code
  • tests/ - Test files
  • infra/ - Infrastructure code

​
Tips for Success

​
Parallel Work

Some agents can work simultaneously:
  • Marketer + UX Designer (design phase)
  • DBA + Frontend + Backend (implementation)
  • Security + QA (validation)

​
Sequential Dependencies

Some agents must work in order:
  • CPO → Sr PM (vision before requirements)
  • UX Designer → Product Designer (system before UI)
  • Developers → Security → QA → DevOps (build → secure → test → deploy)

​
Getting Help

Each agent is an expert in their domain. You can:
  • Ask clarifying questions
  • Request changes to proposals
  • Skip agents if their work isn’t needed
  • Go back to previous agents if requirements change

​
Integration with Tools

Secure-Push Skill: The App Security Engineer uses the secure-push skill: 
bash .claude/skills/secure-push/scripts/pre-push-scan.sh
MCP Tools:
  • DBA uses MongoDB/Supabase MCP servers
  • QA Engineer uses Playwright MCP server

​
Common Workflows

​
Workflow 1: New Product Launch

1. CPO: Define vision
2. Sr PM: Write PRD
3. Marketer + UX Designer: Design system
4. Product Designer: UI designs
5. Architect: Technical planning
6. DBA + Frontend + Backend: Implementation
7. Security + QA: Validation
8. DevOps: Deployment

​
Workflow 2: New Feature Addition

1. Sr PM: Update PRD with feature
2. Product Designer: Design UI for feature
3. Architect: Update architecture if needed
4. Developers: Implement feature
5. Security + QA: Validate
6. DevOps: Deploy

​
Workflow 3: Design Refresh

1. Marketer: New brand guidelines
2. UX Designer: Updated style guide
3. Product Designer: New UI designs
4. Frontend Dev: Implement changes
5. QA: Visual regression testing
6. DevOps: Deploy

​
Agent Capabilities

AgentCan ReadCan WriteCan ExecuteUses MCPUses Skills
CPO✓✓---
Sr PM✓✓---
Marketer✓✓---
UX Designer✓✓---
Product Designer✓✓---
Software Architect✓✓✓--
DBA✓✓✓✓ (DB)-
Frontend Dev✓✓✓--
Backend Dev✓✓✓--
App Security✓-✓-✓ (secure-push)
Sr QA✓✓✓✓ (Playwright)-
DevOps✓✓✓--

​
File Locations

All agent files are located at: 
.claude/agents/
├── product/
│   ├── chief-product-officer.md
│   ├── senior-product-manager.md
│   └── marketer.md
├── design/
│   ├── ux-designer.md
│   └── product-designer.md
├── engineering/
│   ├── software-architect.md
│   ├── dba.md
│   ├── frontend-developer.md
│   └── backend-developer.md
├── quality/
│   ├── app-security-engineer.md
│   └── senior-qa-engineer.md
└── operations/
    └── devops-engineer.md

​
Getting Started

  1. Start with vision: @chief-product-officer
  2. Follow the workflow: Each agent will tell you who to invoke next
  3. Confirm all changes: Review and approve each agent’s proposals
  4. Trust the process: The agents work together as a team

​
Support

For detailed information about the agent system:
  • Read: docs/agents/AGENT_SYSTEM_PLAN.md (comprehensive plan)
  • Review: Each agent’s .md file for specific capabilities
You now have a complete software development team at your fingertips. Let’s build something amazing! 🚀 To get started, simply invoke the first agent: 
@chief-product-officer