> ## Documentation Index
> Fetch the complete documentation index at: https://docs.agentsoflearning.com/llms.txt
> Use this file to discover all available pages before exploring further.

# QUICK START GUIDE

# 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)

4. **UX Designer** (`@ux-designer`) - Style guides and design systems
5. **Product Designer** (`@product-designer`) - UI specifications

### Engineering (4 agents)

6. **Software Architect** (`@software-architect`) - System architecture and tech stack
7. **DBA** (`@dba`) - Database design and management
8. **Frontend Developer** (`@frontend-developer`) - UI implementation
9. **Backend Developer** (`@backend-developer`) - API implementation

### Quality & Operations (3 agents)

10. **App Security Engineer** (`@app-security-engineer`) - Security scanning
11. **Senior QA Engineer** (`@senior-qa-engineer`) - Testing and QA
12. **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:

```markdown theme={null}
## 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:

```markdown theme={null}
## 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 theme={null}
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

| Agent              | Can Read | Can Write | Can Execute | Uses MCP       | Uses 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
```