gspec 1.6.0 → 1.10.0

package/dist/cursor/gspec-epic.mdc

@@ -1,231 +0,0 @@
----
-description: Break down a large epic into multiple focused feature PRDs with dependency mapping
----
-
-You are a senior Product Manager at a high-performing software company.
-
-Generate multiple Product Requirements Documents (PRDs) from a high-level epic description.
-
-## Task
-
-Take the provided epic description (a large body of work) and break it down into **multiple focused Product Requirements Documents (PRDs)**, each representing a distinct feature or component that can be built independently.
-
-## Important: Agent-Oriented Documentation
-
-**These epics and PRDs are designed for automated agent consumption** (via `gspec-implement`), with humans validating the content for accuracy and completeness. Write documents that are:
-
-- **Implementation-ready blueprints**, not project plans
-- Focused on **what** to build and **why**, not **when** or **how long**
-- Clear on technical and functional requirements an agent needs to execute
-
-**AVOID project management details:**
-- ❌ Sprint planning, week numbers, or timeline estimates
-- ❌ Team assignments or resource allocation
-- ❌ Velocity or story point estimates
-- ❌ Delivery schedules or milestone dates
-- ❌ "Phase 1 ships in Q2" or similar calendar commitments
-
-**DO include implementation guidance:**
-- ✅ Clear functional requirements and acceptance criteria
-- ✅ Dependencies between features (technical, not temporal)
-- ✅ Priority levels (P0, P1, P2) for scope decisions
-- ✅ Build order recommendations based on technical dependencies
-- ✅ Minimum viable epic (MVE) scope definition
-- ✅ Feature sequencing based on what must be built first
-
-## Guidelines
-
-- **Read existing feature PRDs and epics** in `gspec/features/` and `gspec/epics/` to understand already-specified work and avoid overlap
-- Identify distinct features that make up the epic
-- **Ask all clarifying questions in the chat before writing specs** — never embed unresolved questions in the generated documents
-- When asking questions, offer 2-3 specific suggestions to guide the discussion
-- Ensure features can be built incrementally and independently when possible
-- Consider dependencies between features
-- Focus on user value, scope, and outcomes
-- Write for automated implementation with human validation
-- Be concise, structured, and decisive
-
----
-
-## Portability
-
-Epic summaries and the feature PRDs they produce are designed to be **portable across projects**. A feature spec written for one project should be reusable in a different project with a different profile, design system, tech stack, and development practices. Project-specific context is resolved at implementation time by `gspec-implement`, which reads all gspec documents (profile, style, stack, practices) alongside the feature PRDs.
-
-**To maintain portability, DO NOT read or incorporate context from:**
-- `gspec/profile.md` — Do not reference project-specific personas, competitive landscape, or positioning
-- `gspec/style.md` — Do not reference a specific design system or component library
-- `gspec/stack.md` — Do not reference specific technologies (already covered by Technology Agnosticism)
-- `gspec/practices.md` — Do not reference project-specific development standards
-
-**DO read existing feature PRDs and epics** in `gspec/features/` and `gspec/epics/` to:
-- Avoid duplicating or contradicting already-specified features
-- Identify cross-feature and cross-epic dependencies
-- Ensure consistent scope boundaries and terminology
-
-**Write in generic, portable terms:**
-- Use relative role descriptions ("primary users", "administrators", "content creators") not project-specific persona names
-- Justify priorities based on intrinsic user value and technical dependencies, not competitive landscape
-- Describe desired UX behavior generically ("clear error feedback", "responsive layout") without referencing a specific design system
-- Define success metrics in terms of each feature's own outcomes, not project-level KPIs
-- Sequence features based on logical dependencies, not project-specific stack constraints
-
-## Output Rules
-
-- Output **multiple** Markdown documents (one per feature)
-- Save each file to the `gspec/features/` folder in the root of the project (create if it doesn't exist)
-- Name each file based on the feature (e.g., `user-authentication.md`, `dashboard-analytics.md`)
-- Begin every output file (both epic summary and individual feature PRDs) with YAML frontmatter containing the gspec version:
-  ```
-  ---
-  gspec-version: 1.6.0
-  ---
-  ```
-  The frontmatter must be the very first content in the file, before the main heading.
-- **Before generating the documents, you MUST resolve ambiguities through conversation.** Ask clarifying questions in the chat if:
-  - The target users are unclear
-  - The scope or boundaries of the epic are ambiguous
-  - The breakdown into features is not obvious
-  - Success criteria cannot be determined from the description
-  - Priority or sequencing is unclear
-  - Any assumption would materially change the shape of the specs
-- **When asking questions**, offer 2-3 specific suggestions to guide the discussion
-- **Do NOT embed unresolved questions in the generated specs.** All questions about scope, users, priorities, capabilities, feature boundaries, and sequencing must be resolved through conversation before writing the documents. The specs should reflect decisions, not open debates.
-- Create an epic summary document at `gspec/epics/[epic-name].md` that:
-  - Lists all features in the epic
-  - Shows dependencies between features
-  - Provides a high-level roadmap or phasing suggestion
-  - Links to each individual feature PRD
-- Avoid deep system architecture or low-level implementation
-- No code blocks except where examples add clarity
-- Clear acceptance criteria are required for each capability
-- Make tradeoffs and scope explicit
-
-### Technology Agnosticism
-
-**IMPORTANT**: Epic and feature PRDs must remain technology-agnostic to enable implementation with different technology stacks. The `gspec/stack.md` file is the single source of truth for technology choices.
-
-**DO use generic architectural terms:**
-- ✅ "database", "data store", "persistent storage"
-- ✅ "authentication service", "IAM", "identity provider"
-- ✅ "API", "backend service", "server"
-- ✅ "frontend", "client application", "user interface"
-- ✅ "message queue", "event system", "pub/sub"
-- ✅ "object storage", "file storage"
-- ✅ "cache", "caching layer"
-- ✅ "search index", "full-text search"
-
-**DO NOT reference specific technologies:**
-- ❌ React, Vue, Angular, Svelte
-- ❌ PostgreSQL, MySQL, MongoDB, DynamoDB
-- ❌ AWS Lambda, Google Cloud Functions, Azure Functions
-- ❌ Redis, Memcached
-- ❌ Elasticsearch, Algolia, Solr
-- ❌ S3, GCS, Azure Blob Storage
-- ❌ Kafka, RabbitMQ, SQS
-
-This separation — combined with the portability principles above — allows the same epic and feature specs to be reused across projects with different technology stacks, design systems, and product contexts.
-
-## Epic Summary Document Structure
-
-**IMPORTANT**: Only include the sections listed below. Do NOT add additional sections such as "Technology Notes", "Implementation Details", "Technical Architecture", or any other custom sections. Stick strictly to this structure.
-
-Create a file at `gspec/epics/[epic-name].md` with:
-
-### 1. Epic Overview
-- Epic name
-- Executive summary
-- Strategic objective
-
-### 2. Features Breakdown
-- List of all features with links to their PRDs, **using unchecked markdown checkboxes** (e.g., `- [ ] **P0**: [Feature Name](../features/feature-name.md) — Brief description`). The `gspec-implement` command will check these off (`- [x]`) as features are fully implemented, allowing incremental runs.
-- Brief description of each feature
-- Priority level (P0, P1, P2)
-- Estimated sequencing/dependencies
-
-### 3. Success Metrics
-- Overall epic success criteria
-- Key performance indicators
-- How features collectively deliver value
-
-### 4. Dependencies & Risks
-- Inter-feature dependencies
-- Technical dependencies
-- Business risks
-- Mitigation strategies
-
-### 5. Phasing Recommendation
-- Suggested build order
-- Rationale for sequencing
-- Minimum viable epic (MVE) scope
-
-## Individual Feature PRD Structure
-
-**IMPORTANT**: Only include the sections listed below. Do NOT add additional sections such as "Technology Notes", "Implementation Details", "Technical Architecture", or any other custom sections. Stick strictly to this structure.
-
-For each feature, create a separate file in `gspec/features/[feature-name].md` with:
-
-### 1. Overview
-- Feature name
-- Summary (1-2 sentences)
-- Problem being solved and why it matters now
-- **Parent Epic** (link to epic summary)
-
-### 2. Users & Use Cases
-- Primary users (use generic role descriptions like "end users", "administrators", "content managers" — not project-specific persona names)
-- Key use cases (3-4 scenarios showing how users benefit)
-
-### 3. Scope
-- In-scope goals
-- Out-of-scope items (things this feature explicitly won't do)
-- Deferred ideas (things we may do later, but not now)
-
-### 4. Capabilities
-- What the feature provides to users, written in user-focused language
-- **Priority level** for each capability (P0 = must-have, P1 = should-have, P2 = nice-to-have)
-- Focus on *what* users can do, not *how* they do it — include UX expectations (empty states, error handling, key flows) as acceptance criteria on the relevant capabilities
-- **Use unchecked markdown checkboxes** for each capability to enable implementation tracking (e.g., `- [ ] **P0**: User can create an account`). The `gspec-implement` command will check these off (`- [x]`) as capabilities are implemented, allowing incremental runs.
-- **Each capability MUST include brief acceptance criteria** — 2-4 testable conditions that define "done" for that capability. These tell the implementing agent exactly when a capability is complete and give test writers concrete assertions. Format as a sub-list under each capability:
-  ```
-  - [ ] **P0**: User can create an account
-    - Valid email + strong password → account is created and confirmation is sent
-    - Duplicate email → error message explains email is taken
-    - Weak password → inline validation shows password requirements
-  ```
-
-### 5. Dependencies
-- Dependencies on other features in this epic
-- External dependencies
-- If none, state "None"
-
-### 6. Assumptions & Risks
-- Assumptions (what we're taking as true)
-- Open questions — **only** unknowns that genuinely cannot be answered until implementation or real-world usage begins (e.g., performance thresholds pending benchmarking, exact rate limits pending load testing). Questions about scope, users, priorities, or feature design must be asked and resolved in the chat before the specs are written. If there are no open questions, omit this sub-section.
-- Key risks and mitigations (brief bullet points — focus on risks that could affect implementation scope or approach)
-
-### 7. Success Metrics
-- 2-4 measurable outcomes that define whether this feature is working
-
-### 8. Implementation Context
-- Include the following standard note verbatim:
-  > This feature PRD is portable and project-agnostic. During implementation, consult the project's `gspec/profile.md` (target users, positioning), `gspec/style.md` (design system), `gspec/stack.md` (technology choices), and `gspec/practices.md` (development standards) to resolve project-specific context.
-
-## Workflow
-
-1. **Analyze the epic description** and identify logical feature boundaries
-2. **Ask clarifying questions in the chat** and wait for answers before proceeding — do not generate specs with embedded questions
-3. **Break down into features** that:
-   - Can be built and shipped incrementally
-   - Deliver independent user value (when possible)
-   - Have clear boundaries and responsibilities
-   - Consider technical and business dependencies
-4. **Create the epic summary** document first
-5. **Generate individual feature PRDs** for each feature
-6. **Ensure consistency** across all documents (terminology, user personas, metrics)
-
-## Tone & Style
-
-- Clear, neutral, product-led
-- No fluff, no jargon
-- Designed to be skimmed
-- Consistent across all generated documents
-