vibe-coding-prompt-template

Implements a linear, sequential document generation pipeline that transforms application ideas into MVP code through five distinct stages (Research → PRD → Tech Design → Agent Config → Build). Each stage consumes outputs from previous stages and produces structured artifacts that feed into the next stage, with platform-agnostic AI provider selection at each step. The architecture separates documentation phases (Stages 1-4 using conversational AI) from implementation phases (Stage 5 using specialized coding agents), enabling iterative refinement and quality gates between stages.

Implements a layered information architecture that decomposes comprehensive project documentation into progressively detailed files (.cursorrules, CLAUDE.md, agent_docs/ subdirectories) to manage AI context window limitations. The system uses a hierarchical disclosure pattern where tool config files serve as entry points with essential context, while detailed specifications are stored in separate files that agents can selectively load based on task requirements. This prevents context overflow while maintaining information accessibility for multi-file, multi-step implementation tasks.

Implements visual verification workflows where AI agents generate test cases and verification steps that can be manually executed or automated, with self-healing test patterns that automatically adapt to minor implementation changes. The system generates test specifications and visual verification steps (UI screenshots, API response validation, data model verification) that enable non-technical stakeholders to validate implementation without code review. Self-healing tests use pattern matching and semantic comparison rather than brittle exact matching, allowing tests to adapt to minor code changes.

Implements a Prompt-Execution-Refinement (PER) architecture that enables iterative improvement of AI-generated artifacts through structured feedback loops. The system captures execution results (code output, specification clarity, implementation success) and uses them to refine prompts and instructions for subsequent iterations. This creates a feedback mechanism where each stage's output informs improvements to that stage's prompt template, enabling continuous optimization of the workflow without manual intervention.

Enables users to select different AI providers (Gemini 3 Pro, Claude Sonnet, ChatGPT) at each pipeline stage based on provider strengths, cost, or availability, without modifying the underlying workflow structure. The system maintains platform-agnostic prompt templates that can be executed on any conversational AI platform, allowing Stage 1 to use Gemini for research, Stage 2-3 to use Claude for specification writing, and Stage 5 to use specialized coding agents. This decouples the workflow logic from specific AI provider implementations.

Generates product requirement documents (PRDs) that explicitly define MVP scope, feature prioritization, and user stories through a guided prompt template (part2-prd-mvp.md) that consumes research artifacts from Stage 1. The system produces PRD-YourApp-MVP.md with structured sections for product vision, user personas, feature requirements, acceptance criteria, and MVP boundaries, enabling downstream technical design to focus on implementable scope rather than aspirational features. This prevents scope creep by explicitly documenting what is and is not included in the MVP.

Generates technical design documents (TechDesign-YourApp-MVP.md) that specify system architecture, technology stack, implementation approach, and technical constraints through a guided prompt template (part3-tech-design-mvp.md) that consumes PRD and research artifacts. The system produces structured technical designs with sections for architecture diagrams (as ASCII or descriptions), technology choices with justifications, data models, API specifications, and implementation roadmap, enabling AI coding agents to understand the intended technical approach before implementation. This bridges the gap between product requirements and code generation.

Transforms human-readable documentation (PRD, technical design) into machine-actionable agent instructions through a guided prompt template (part4-notes-for-agent.md) that generates AGENTS.md, agent_docs/ directory structure, and tool-specific configuration files (.cursorrules, CLAUDE.md, etc.). The system decomposes comprehensive specifications into modular instruction files organized by feature or component, enabling AI coding agents to understand project context, implementation approach, and tool-specific requirements without exceeding context windows. This stage acts as a transformation hub that converts documentation into agent-consumable format.

Implements a quality assurance mechanism where AI agents verify their understanding of specifications by echoing back key requirements, constraints, and implementation decisions before proceeding with code generation. The verification echo pattern uses structured prompts that ask agents to summarize their understanding of the project scope, technical approach, and acceptance criteria, enabling human review to catch specification misunderstandings before implementation begins. This creates a feedback loop that validates specification clarity without requiring formal testing infrastructure.

Implements three distinct user type paths (Vibe-Coder, Developer, In-Between) that customize the workflow complexity and documentation depth based on user expertise and project needs. The system uses progressive disclosure to show different levels of detail: Vibe-Coders see simplified prompts and high-level guidance, Developers see technical depth and architecture details, and In-Between users see balanced documentation. Each path maintains the same five-stage pipeline but adjusts prompt complexity, output verbosity, and technical depth to match user capabilities and project requirements.

Enforces a set of quality standards and anti-patterns (Anti-Vibe Engineering Rules) that prevent common pitfalls in AI-assisted development, such as over-engineering, premature optimization, and scope creep. The system includes meta-cognition rules that prompt AI agents and users to reflect on their decision-making process, validate assumptions, and identify potential issues before implementation. These rules are embedded in prompts and verification steps to ensure the workflow produces pragmatic, implementable solutions rather than over-engineered designs.

Supports integration with Model Context Protocol (MCP) for extending AI agent capabilities with custom tools, databases, and external services. The system enables agents to access specialized tools (code search, database queries, API calls) through standardized MCP interfaces, allowing agents to gather additional context or perform actions beyond text generation. This enables more sophisticated agent behaviors like querying existing codebases, accessing documentation systems, or integrating with external APIs during implementation.