/spdd-generate

Generate implementation code from a structured SPDD (Structured Prompt-Driven Development) prompt file, strictly following the Operations sequence and coding norms defined in the prompt.

Input: The argument after /spdd-generate is the path to the structured prompt file (e.g., @spdd/prompt/GGQPA-XXX-202602271430-[Feat]-api-create-agent-endpoint.md).

Steps

1. If no input provided, ask for the prompt file

   Use the AskUserQuestion tool to ask:

   "Please provide the path to the structured prompt file (e.g., @spdd/prompt/xxx.md)."

   IMPORTANT: Do NOT proceed without a valid prompt file path.

2. Read and parse the structured prompt file

   Read the prompt file and extract the REASONS Canvas sections:

   Section	Purpose	Usage
   R - Requirements	Overall goal and DoD	Understand the business context
   E - Entities	Domain model and relationships	Reference for class design
   A - Approach	Implementation strategy	Guide architectural decisions
   S - Structure	Components and dependencies	Verify layering and relationships
   O - Operations	Concrete implementation tasks	Execute in defined order
   N - Norms	Engineering standards	Apply to all generated code
   S - Safeguards	Non-negotiable constraints	Enforce strictly

   IMPORTANT: Read the ENTIRE file carefully. Each section provides critical guidance.

3. Analyze project context

   Before generating code:

   • Identify the project's technology stack (e.g., Spring Boot, Java version)
   • Locate existing similar patterns in the codebase for reference
   • Identify the correct package structure and directory layout
   • Check for existing base classes, utilities, or configurations to reuse

   IMPORTANT: Generated code MUST align with existing project conventions.

4. Validate the Operations sequence

   Review the Operations section to verify:

   a. Dependency order is correct:

   • Classes with no dependencies come first (enums, constants)
   • Classes depend only on previously defined classes
   • No circular dependencies exist

   b. Task decomposition is complete:

   • Each operation is atomic and testable
   • No logical gaps between operations
   • All components mentioned in Structure are covered

   c. Consistency with Structure section:

   • Inheritance relationships match
   • Dependencies match
   • Layered architecture is respected

   If issues are found: Report to user and suggest prompt modifications before proceeding.

   IMPORTANT: Do NOT re-plan the sequence. The Operations order is the designed execution order from the Abstraction phase.

5. Generate code following Operations sequence

   For each operation in the Operations section (in order):

   a. Read the operation specification:

   • Responsibility: What the component does
   • Attributes/Methods: Exact fields and signatures
   • Annotations: Required annotations
   • Validation rules: Bean validation or custom logic
   • Business logic: Step-by-step implementation details

   b. Apply Norms:

   • Annotation standards (e.g., @RestController, @Service)
   • Dependency injection style (constructor injection)
   • Exception handling patterns
   • Logging conventions
   • Response format standards

   c. Enforce Safeguards:

   • Field validation constraints
   • HTTP status code requirements
   • Exact error messages (do not modify)
   • Security constraints
   • Data integrity rules

   d. Generate the code:

   • Use correct package path based on project structure
   • Include all required imports
   • Implement exact method signatures as specified
   • Follow the exact validation messages from Safeguards