Create Next Story

Create Next Story Task

When to Use

• When ready to start the next development story
• After completing the current story (status: Done)
• When preparing stories for sprint planning
• When creating comprehensive context for Dev agents

Quick Start

1. Load core-config.yaml for project settings
2. Find highest story file and check completion status
3. Identify next sequential story/task number
4. Gather requirements and previous story context
5. Generate story file with full technical context

Purpose

To identify the next logical story based on project progress and task definitions, and then to prepare a comprehensive, self-contained, and actionable story file using the Story Template. This task ensures the story is enriched with all necessary technical context, requirements, and acceptance criteria, making it ready for efficient implementation by a Developer Agent with minimal need for additional research or finding its own context.

SEQUENTIAL Task Execution (Do not proceed until current Task is complete)

0. Load Core Configuration and Check Workflow

• Load ../core-config.yaml (relative to tasks folder)
• If the file does not exist, HALT and inform the user: "core-config.yaml not found. This file is required for story creation. You can either: 1) Copy it from GITHUB prism-devtools and configure it for your project OR 2) Run the Prism installer against your project to upgrade and add the file automatically. Please add and configure core-config.yaml before proceeding."
• Extract key configurations: devStoryLocation, prd.*, architecture.*, workflow.*

1. Identify Next Story for Preparation

1.1 Locate Task Files and Review Existing Stories

• Based on prdSharded from config, locate task files (sharded location/pattern or monolithic PRD sections)
• If devStoryLocation has story files, load the highest {storyNum}.{taskNum}.story.md file
• If highest story exists:
  • Verify status is 'Done'. If not, alert user: "ALERT: Found incomplete story! File: {lastStoryNum}.{lastTaskNum}.story.md Status: [current status] You should fix this story first, but would you like to accept risk & override to create the next story in draft?"
  • If proceeding, select next sequential task in the current story
  • If story is complete, prompt user: "Story {storyNum} Complete: All tasks in Story {storyNum} have been completed. Would you like to: 1) Begin Story {storyNum + 1} with task 1 2) Select a specific task to work on 3) Cancel story creation"
  • CRITICAL: NEVER automatically skip to another story. User MUST explicitly instruct which story to create.
• If no story files exist: The next story is ALWAYS 1.1 (first task of first story)
• Announce the identified story to the user: "Identified next story for preparation: {storyNum}.{taskNum} - {Story Title}"

2. Gather Story Requirements and Previous Story Context

• Extract story requirements from the identified task file
• If previous story exists, review Dev Agent Record sections for:
  • Completion Notes and Debug Log References
  • Implementation deviations and technical decisions
  • Challenges encountered and lessons learned
• Extract relevant insights that inform the current story's preparation

3. Gather Architecture Context

3.1 Determine Architecture Reading Strategy

• If architectureVersion: >= v4 and architectureSharded: true: Read {architectureShardedLocation}/index.md then follow structured reading order below
• Else: Use monolithic architectureFile for similar sections

3.2 Read Architecture Documents Based on Story Type

For ALL Stories: tech-stack.md, unified-project-structure.md, coding-standards.md, testing-strategy.md

For Backend/API Stories, additionally: data-models.md, database-schema.md, backend-architecture.md, rest-api-spec.md, external-apis.md

For Frontend/UI Stories, additionally: frontend-architecture.md, components.md, core-workflows.md, data-models.md

For Full-Stack Stories: Read both Backend and Frontend sections above

3.3 Extract Story-Specific Technical Details

Extract ONLY information directly relevant to implementing the current story. Do NOT invent new libraries, patterns, or standards not in the source documents.

Extract:

• Specific data models, schemas, or structures the story will use
• API endpoints the story must implement or consume
• Component specifications for UI elements in the story
• File paths and naming conventions for new code
• Testing requirements specific to the story's features
• Security or performance considerations affecting the story

ALWAYS cite source documents: [Source: architecture/{filename}.md#{section}]

4. Verify Project Structure Alignment

• Cross-reference story requirements with Project Structure Guide from docs/architecture/unified-project-structure.md
• Ensure file paths, component locations, or module names align with defined structures
• Document any structural conflicts in "Project Structure Notes" section within the story draft

5. Apply PROBE Estimation

• Execute the probe-estimation task to:
  • Analyze story complexity and assign size category
  • Find similar historical stories as proxies
  • Calculate time estimates using PROBE method
  • Generate estimation data for story file

6. Populate Story Template with Full Context

• Create new story file: {devStoryLocation}/{storyNum}.{storyNum}.story.md using Story Template
• Fill in basic story information: Title, Status (Draft), Story statement, Acceptance Criteria from Story
• PSP Estimation section:
  • Include PROBE estimation results from Step 5
  • Set tracking fields to null (to be filled during execution)
• Dev Notes section (CRITICAL):
  • CRITICAL: This section MUST contain ONLY information extracted from architecture documents. NEVER invent or assume technical details.
  • Include ALL relevant technical details from Steps 2-3, organized by category:
    • Previous Story Insights: Key learnings from previous story
    • Data Models: Specific schemas, validation rules, relationships [with source references]
    • API Specifications: Endpoint details, request/response formats, auth requirements [with source references]
    • Component Specifications: UI component details, props, state management [with source references]
    • File Locations: Exact paths where new code should be created based on project structure
    • Testing Requirements: Specific test cases or strategies from testing-strategy.md
    • Technical Constraints: Version requirements, performance considerations, security rules
  • Every technical detail MUST include its source reference: [Source: architecture/{filename}.md#{section}]
  • If information for a category is not found in the architecture docs, explicitly state: "No specific guidance found in architecture docs"
• Tasks / Subtasks section:
  • Generate detailed, sequential list of technical tasks based ONLY on: Story Requirements, Story AC, Reviewed Architecture Information
  • Each task must reference relevant architecture documentation
  • Include unit testing as explicit subtasks based on the Testing Strategy
  • Link tasks to ACs where applicable (e.g., Task 1 (AC: 1, 3))
• Add notes on project structure alignment or discrepancies found in Step 4

7. Story Draft Completion and Review

• Review all sections for completeness and accuracy
• Verify all source references are included for technical details
• Ensure tasks align with both story requirements and architecture constraints
• Update status to "Draft" and save the story file
• Execute execute-checklist task with ../checklists/story-draft-checklist
• Provide summary to user including:
  • Story created: {devStoryLocation}/{storyNum}.{storyNum}.story.md
  • Status: Draft
  • Key technical components included from architecture docs
  • Any deviations or conflicts noted between story and architecture
  • Checklist Results
  • Next steps: For Complex stories, suggest the user carefully review the story draft and also optionally have the PO run the validate-next-story task