---
name: scorpio-project-artifacts
description: Generate PRD, MVP scope, and implementation plan documents from structured requirements. Use after completing a requirements interview or when the user has roles, stories, flows, and decisions defined and wants formal planning documents.
---

# Project Plan Artifacts (alias: PM Artifacts Generation)

Convert structured requirements (roles, stories, flows, decisions) into formal planning documents. This skill produces three artifacts:

1. **PRD** (Product Requirements Document) - Complete product specification
2. **MVP Scope** - Minimal viable version for first release
3. **Implementation Plan** - Technical approach and phases

## Prerequisites

Before generating artifacts, you need structured requirements with:
- At least 1 role defined
- At least 3 user stories
- At least 1 process flow
- At least 1 technical decision

If requirements are incomplete, use the **scorpio-project-intake** (`scorpio-project-intake`) skill first.

## Input

**Read structured requirements from `{docs.planning}/REQUIREMENTS-SUMMARY.md`** — this file is produced by scorpio-project-intake (`scorpio-project-intake`) and contains the roles, stories, flows, and decisions gathered from the user. This is your primary input. If this file doesn't exist, check the conversation context for requirements data. If neither source has structured requirements, stop and report that the interview output is missing — do NOT infer or fabricate requirements.

## Artifact 1: PRD (Product Requirements Document)

```markdown
# [Product Name] - Product Requirements Document

## Overview
[1-2 paragraph description of what the product does and why it matters]

## Goals
- [Primary goal]
- [Secondary goal]
- [Success metric if known]

## Target Users

### [Role 1]
- **Description**: [Who they are]
- **Needs**: [What they need from the product]
- **Pain points**: [What problems they have today]

### [Role 2]
...

## User Stories

### [Epic/Category Name]
| ID | Story | Priority |
|----|-------|----------|
| US-1 | As a [role], I want to [action] so that [benefit] | High |
| US-2 | As a [role], I want to [action] so that [benefit] | Medium |
...

## Process Flows

### [Flow 1 Name]
```
[Step 1] → [Step 2] → [Step 3] → [Outcome]
```

**Details:**
- Step 1: [Description]
- Step 2: [Description]
...

### [Flow 2 Name]
...

## Technical Decisions

| Decision | Choice | Rationale |
|----------|--------|-----------|
| Frontend | [Tech] | [Why] |
| Backend | [Tech] | [Why] |
| Database | [Tech] | [Why] |
...

## Constraints & Assumptions
- [Constraint 1]
- [Assumption 1]

## Out of Scope
- [Feature explicitly excluded]
- [Feature deferred to future]
```

## Artifact 2: MVP Scope

```markdown
# [Product Name] - MVP Scope

## MVP Definition
[1 paragraph defining what "minimum viable" means for this product]

## Core Value Proposition
[Single sentence: The ONE thing this MVP must do well]

## In Scope for MVP

### Must Have (P0)
- [ ] [Feature/Story] - [Why it's essential]
- [ ] [Feature/Story] - [Why it's essential]
- [ ] [Feature/Story] - [Why it's essential]

### Should Have (P1) - Include if time permits
- [ ] [Feature/Story]
- [ ] [Feature/Story]

## Explicitly Out of Scope
- [Feature] → Deferred to v1.1
- [Feature] → Deferred to v2
- [Feature] → May never build

## MVP Success Criteria
- [ ] [Criterion 1]: [Measurable outcome]
- [ ] [Criterion 2]: [Measurable outcome]

## Technical MVP Constraints
- [Constraint]: [Impact on scope]
```

## Artifact 3: Implementation Plan

```markdown
# [Product Name] - Implementation Plan

## Architecture Overview
[Brief description of the technical approach]

```
[ASCII diagram if helpful]
┌─────────┐     ┌─────────┐     ┌─────────┐
│ Frontend│ ──► │   API   │ ──► │   DB    │
└─────────┘     └─────────┘     └─────────┘
```

## Technology Stack

| Layer | Technology | Purpose |
|-------|------------|---------|
| Frontend | [Tech] | [Purpose] |
| Backend | [Tech] | [Purpose] |
| Database | [Tech] | [Purpose] |
| Hosting | [Tech] | [Purpose] |

## Implementation Phases

### Phase 1: Foundation
**Goal**: [What this phase achieves]
**Duration**: [Estimated effort, not calendar time]

- [ ] [Task 1]: [Description]
- [ ] [Task 2]: [Description]
- [ ] [Task 3]: [Description]

**Exit Criteria**: [How to know phase is complete]

### Phase 2: Core Features
**Goal**: [What this phase achieves]

- [ ] [Task 1]: [Description]
- [ ] [Task 2]: [Description]
...

### Phase 3: Polish & Launch
**Goal**: [What this phase achieves]

- [ ] [Task 1]: [Description]
- [ ] [Task 2]: [Description]
...

## Technical Risks

| Risk | Impact | Mitigation |
|------|--------|------------|
| [Risk 1] | [High/Med/Low] | [How to address] |
...

## Dependencies
- [External dependency 1]
- [External dependency 2]

## Open Questions
- [ ] [Question needing resolution before/during build]
```

## Generation Guidelines

### 1. Derive, Don't Invent
Generate artifacts from the requirements provided. Don't add features, roles, or decisions the user didn't mention. If something is missing, note it as an open question.

### 2. Prioritize Based on Signals
If the user emphasized something ("the most important thing is..."), make it P0. If they mentioned it casually, it's P1 or out of scope.

### 3. Keep It Actionable
Every item should be something someone can act on. Avoid vague statements like "make it user-friendly."

### 4. Flag Gaps
If requirements are thin in an area, call it out:
```markdown
> ⚠️ **Gap**: No error handling flows defined. Consider: What happens when [X] fails?
```

### 5. Right-Size the Documents
- Small project (personal tool): 1-2 pages per artifact
- Medium project (team app): 2-4 pages per artifact
- Large project (enterprise): 4+ pages, consider splitting

## Quick Generation Mode

For simple projects, generate a combined mini-spec instead of three full documents:

```markdown
# [Product Name] - Planning Summary

## What We're Building
[2-3 sentences]

## For Whom
- [Role]: [One line description]

## Core Features (MVP)
1. [Feature]: [One line description]
2. [Feature]: [One line description]
3. [Feature]: [One line description]

## Tech Stack
- [Layer]: [Choice]

## First Steps
1. [Task]
2. [Task]
3. [Task]
```

## Next Steps

After generating artifacts, use the **scorpio-task-plan** (`scorpio-task-plan`) skill to convert the implementation plan into detailed, assignable development tasks.