Skip to content

Quick Start Guide

Get up and running with CMS Planner in minutes. This guide walks you through generating your first Functional Requirements Document.

Basic Usage

1. Run the Command

In your project directory, run:

/functional-requirements

2. Answer Discovery Questions

Claude will guide you through project discovery by asking about:

Business & Users - What are your business objectives? - Who are your target users? - What success metrics matter?

Technical - What platform/framework? (Drupal, WordPress, custom) - Any technical constraints or preferences? - Architecture patterns? (recipe-based, microservices, monolithic) - Required integrations?

Team & Timeline - How many developers? - Estimated sprint velocity? - Target launch date? - Budget considerations?

Scope - What features are must-have vs nice-to-have? - MVP vs future phases? - Compliance or regulatory requirements?

3. Review Generated Files

CMS Planner creates two files:

1. Functional Requirements Document (docs/functional-requirements.md) 

# Functional Requirements Document: [Project Name]

## Executive Summary
- Vision, objectives, scope
- Business value, target launch

## Technical Requirements
- Platform & architecture
- Tech stack with justifications
- Dependencies, integrations

## Functional Requirements
- FR-001: Feature Name [PRIORITY]
  - User stories
  - Acceptance criteria
  - Story point estimates

## Implementation Plan
- Phase 1: [Name] [X points]
  - Epic 1: [Name] [X points]
    - Story 1: [Name] [X points]
...

2. Teamwork CSV Backlog ([project-name]-backlog-teamwork.csv) 

Tasklist,Task,Description,Priority,Tags,Status
"Phase 1","[EPIC] Setup [21 points]","...",high,"SP-21,Phase-1",Active
"Phase 1","- [STORY] Repository [5 points]","...",high,"SP-5,Phase-1",Active
...

Example: Drupal Healthcare Site

Command

/functional-requirements

Inline Answers

I need to build a healthcare website for a hospital system.

**Platform**: Drupal CMS 2.0+ with recipe-based architecture
**Target**: DrupalCon Chicago launch (Feb 2026)
**Features**: Provider directory, services, locations, events, news, alerts
**Team**: 3 developers, ~28 points/sprint velocity
**Compliance**: WCAG 2.2 Level AA, HIPAA-aware (no PHI)
**Architecture**: Recipe-based using Saplings collection + Vital site template

Generated Output

FRD Structure: - Executive Summary with DrupalCon target - Technical Requirements (Drupal CMS 2.0+, recipe architecture) - 8 Functional Requirements (FR-001 through FR-008 for each recipe) - Recipe dependency diagram in appendix - Shared field storage matrix in appendix - 8 implementation phases totaling 720 story points - Risk assessment for recipe dependencies - Success criteria (functional, technical, business)

CSV Backlog: - 31 epics organized by 8 phases - Phase tags (Phase-1, Phase-2, etc.) - Story point tags (SP-21, SP-34, etc.) - Complete descriptions with acceptance criteria - Ready for Teamwork import

Example: WordPress Theme

Command

/functional-requirements

Inline Answers

Building a custom WordPress block theme for a marketing agency.

**Platform**: WordPress 6.8+ with Full Site Editing (FSE)
**Theme**: Block theme with theme.json v3
**Features**:
- Homepage hero pattern (Cover + Heading + Button)
- Feature grid pattern (Columns + Images)
- Team member directory (ACF block with repeating fields)
- Portfolio showcase (Query Loop + custom post type)
- Blog with custom categories
- Contact form (Gravity Forms)
- Performance optimization (Core Web Vitals < 2.5s LCP)

**Team**: 2 developers, part-time (~15 points/sprint)
**Timeline**: 3 months
**Design**: Figma designs provided
**Performance**: Core Web Vitals targets mandatory (LCP < 2.5s, INP < 200ms, CLS < 0.1)
**Plugins**: < 15 plugins with documented justifications

Generated Output

FRD includes:

Block/Pattern Inventory Analysis: 

| Component | Core Blocks | Pattern | ACF | Custom | Justification | Points |
|-----------|-------------|---------|-----|--------|---------------|--------|
| Hero      | ✓           | ✓       | -   | -      | Core sufficient| 2      |
| Features  | ✓           | ✓       | -   | -      | Core sufficient| 2      |
| Team      | -           | -       | ✓   | -      | Repeating fields| 5     |
| Portfolio | Query Loop  | ✓       | -   | -      | Core + CPT     | 3      |

theme.json Configuration: 

- Colors: 6 colors (primary, secondary, accent, dark, light, white)
- Typography: 2 font families (sans, heading), 5 sizes (small-xlarge)
- Spacing: 8 presets (0.5rem - 4rem)
- Layout: contentSize 720px, wideSize 1200px
Story Points: 5 points (12-16 hours)

Plugin Ecosystem: 

1. WP Rocket ($59/year) - Performance (caching, critical CSS, lazy load)
2. Imagify ($10/month) - Image optimization (WebP, compression)
3. Yoast SEO (Free) - SEO (meta tags, schema markup)
4. Wordfence (Free) - Security (firewall, malware scanner)
5. Gravity Forms ($59/year) - Contact form
6. ACF PRO ($49/year) - Team member block
7. UpdraftPlus (Free) - Backups

Total: 7 plugins, $177/year + $120/year = $297/year

Performance Budget: 

- LCP: < 2.5s (3G), < 1.5s (4G)
- INP: < 200ms
- CLS: < 0.1
- Assets: JS < 300KB, CSS < 100KB
- Images: WebP, < 200KB each, lazy loaded
Story Points: 8 points (24-32 hours) for optimization

Implementation Phases: - Phase 1: Theme Foundation (13 points) - theme.json configuration: 5 points - Basic templates: 3 points - Header/footer parts: 2 points - Style setup: 3 points

  • Phase 2: Block Patterns (12 points)
  • Hero pattern: 2 points
  • Feature grid: 2 points
  • Portfolio grid: 3 points

  • Team directory (ACF): 5 points

  • Phase 3: Performance & Launch (13 points)

  • Core Web Vitals optimization: 8 points
  • Plugin setup: 3 points
  • Testing & QA: 2 points

Total: 38 points (~76 hours, ~5 sprints at 15 points/sprint = 12-13 weeks for part-time team)

CSV Backlog with Estimated Hours: 

Tasklist,Task,Priority,Estimated time,Tags
"Phase 1","[EPIC] Theme Foundation [13 points]",high,"3-4 days","SP-13,Phase-1"
"Phase 1","- [TASK] theme.json configuration [5 points]",high,"2 days","SP-5,Phase-1"
"Phase 1","- [TASK] Basic templates [3 points]",medium,"1 day","SP-3,Phase-1"
"Phase 2","[EPIC] Block Patterns [12 points]",high,"3-4 days","SP-12,Phase-2"
"Phase 2","- [PATTERN] Hero section [2 points]",high,"4h","SP-2,Phase-2"
"Phase 2","- [ACF] Team directory [5 points]",high,"2 days","SP-5,Phase-2"

Risk Assessment: - Performance degradation risk (High) - Mitigation: Lighthouse audits every sprint - Custom block scope creep (Medium) - Mitigation: Pattern-first framework enforced - Editor training gap (Medium) - Mitigation: Pattern library with screenshots

Success Criteria: - ✅ Core Web Vitals pass (LCP < 2.5s, INP < 200ms, CLS < 0.1) - ✅ Lighthouse Performance > 90 (desktop), > 70 (mobile) - ✅ Theme Check plugin passes with zero errors - ✅ WCAG 2.1 Level AA compliant - ✅ Plugin count ≤ 15 with documented justifications

Pro Tips

Provide Context Upfront

Instead of answering questions one-by-one, provide comprehensive context:

/functional-requirements

I'm building [project type] with these details:
- Platform: [specific versions]
- Features: [bulleted list]
- Team: [size and velocity]
- Timeline: [target date]
- Architecture: [pattern]
- Integrations: [list]

Claude will acknowledge what you've provided and only ask about missing information.

Use Existing Documentation

If your project has existing docs:

/functional-requirements

Please review:
- README.md for project overview
- docs/architecture.md for technical decisions
- docs/content-model.md for data structures

Then generate FRD based on these + my answers to your questions.

Specify Output Location

/functional-requirements

Save FRD to docs/requirements/functional-requirements.md
Save CSV to planning/backlog-import.csv

Request Specific Focus

/functional-requirements

Focus on recipe-based architecture with:
- Detailed shared field storage documentation
- Recipe dependency diagram
- Installation order requirements
- Demo content integration

Common Workflows

New Project Planning

  1. Run /functional-requirements
  2. Answer discovery questions
  3. Review and refine FRD
  4. Import CSV to Teamwork
  5. Review backlog with team
  6. Begin sprint planning

Existing Project Documentation

  1. Gather existing docs (README, architecture, etc.)
  2. Run /functional-requirements with context
  3. Claude analyzes existing work
  4. Generates FRD documenting current state + future plans
  5. Export backlog for remaining work

Client Proposal

  1. Run /functional-requirements with high-level requirements
  2. Focus on executive summary and business value
  3. Include MVE (Minimum Viable Experience) vs full feature set
  4. Use story points to estimate timeline and budget
  5. Present FRD to client for feedback

Understanding Output

Story Points

Points represent complexity, not time directly:

  • 1-3 points: Can be completed within a day
  • 5-8 points: Multi-day tasks requiring integration
  • 13 points: Week-long epic, should be broken down
  • 21+ points: Multi-week epic, must be decomposed

Phases

Implementation organized into logical phases:

  • Phase 1: Usually foundation/setup (environment, dependencies)
  • Phase 2-N: Feature development phases
  • Final Phase: Often polish, testing, launch prep

CSV Import

To import CSV into Teamwork:

  1. Open Teamwork project
  2. Navigate to Tasks
  3. Click Import
  4. Upload CSV file
  5. Map columns (usually auto-detected)
  6. Review and confirm import

See Teamwork CSV Import Guide for details.

Next Steps

Troubleshooting

FRD Too Generic

Provide more specific details: - Exact platform versions - Specific architecture patterns - Technical constraints - Integration requirements

Story Points Seem Off

Calibrate with your team: - Review velocity history - Adjust multiplier in sprint calculation - Consider team experience level - Account for part-time resources

CSV Format Issues

Verify format matches Teamwork requirements: - Column headers must match exactly - Use proper hierarchy prefixes (-, --, ---) - Tags format: SP-X,Phase-X (comma-separated) - Status must be "Active"

Getting Help