Why You Need Vibe-Planning, Not Vibe-Coding: The Smarter Way to Build with AI

Continuing from last week's post on why vibe coding is dangerous, this week I'll share what you should do instead. My colleagues often ask me: "If vibe coding is bad, should I stop using AI tools entirely?" Absolutely not. The answer isn't less AI—it's smarter AI. And that means vibe-planning. This is part of my weekly AI series where I take you progressively through the fundamentals, and today we're moving from what NOT to do to what you SHOULD do. After 17+ years in product management and building AI tools myself, I've found that the teams who succeed with AI aren't avoiding it—they're using it at the right phase of development. ## So What Is Vibe-Planning? You may wonder, what exactly is vibe-planning, or how is it different from vibe coding? That is because while vibe coding means accepting AI-generated code you don't understand, vibe-planning means using AI to explore, plan, and understand BEFORE you write a single line of code. As one industry analysis perfectly captures it: "AI can build, not design. It's a productivity engine—not an architectural brain." And here's the critical warning from Gartner: by 2028, prompt-to-app approaches adopted without proper planning "will increase software defects by 2,500%, triggering a software quality and reliability crisis." In a nutshell, vibe-planning channels AI's incredible speed into the exploration phase—where understanding is built—rather than the coding phase—where understanding is required. ## The Data: Why Planning Matters The research is compelling—and contradictory in revealing ways. **When AI works (with planning):** - MIT Sloan, Microsoft Research, and GitHub found that AI coding tools can **cut programming time by 56%** (Harvard Business Review, March 2025) - McKinsey reports that companies with **80-100% developer adoption saw gains exceeding 110%** - Across 600+ organizations tracked by Jellyfish, **60%+ see at least 25% productivity improvement** **When AI fails (without planning):** - A Fortune study found AI actually **increased task time by 19%** when developers expected 24% savings - Only **41% of engineers even tried** AI coding assistants 12 months after deployment (HBR) - AI-generated code is "highly functional but **systematically lacking in architectural judgment**" (Ox Security) - **45% of AI-generated code failed security tests**, introducing OWASP Top 10 vulnerabilities (Veracode) The difference? Planning. ## The Frameworks: How to Vibe-Plan Three frameworks have emerged as leaders in structured AI-assisted development. Each offers a different approach to the same core principle: plan before you code. ### Framework 1: BMAD Method (Breakthrough Method for Agile AI-Driven Development) BMAD is an open-source framework created specifically to address vibe coding's failures at scale. As its documentation states: "Early AI-assisted development patterns, dubbed 'vibe coding,' often collapse when faced with enterprise applications, complex system architectures, and long-term maintenance needs." **Core Philosophy:** BMAD positions AI agents as "expert collaborators who guide you through structured workflows to bring out your best thinking," rather than tools that "do the thinking for you, producing average results." **The Four Phases:** 1. **Analysis**: Captures the problem and constraints in a one-page PRD 2. **Planning**: Breaks the PRD into user stories with acceptance criteria 3. **Architecture**: Designs system structure before implementation 4. **Implementation**: Iterative development with human oversight **The Agent System:** BMAD deploys 21+ specialized agents—product managers, architects, developers, UX designers, Scrum masters—that operate collaboratively. Each agent embodies a specific role within the software development lifecycle. **Scale-Adaptive Intelligence:** The system automatically adjusts planning depth across complexity levels 0-4, scaling from simple bug fixes to enterprise systems. A bug fix gets minimal planning; a new platform gets comprehensive architecture review. **Key Insight—Documentation as Source of Truth:** "In the BMAD framework, source code is no longer the sole source of truth—documentation (PRDs, architecture designs, user stories) is." Every artifact is treated as a versioned asset in Git, ensuring traceability for both human and AI changes. **Getting Started:** ``` Quick Flow: /quick-spec → /dev-story → /code-review Full Method: Product brief → PRD → Architecture → Epics → Sprint planning → Development ``` BMAD is free and open-source, integrating with VS Code, Cursor, and Claude Code. ### Framework 2: PRP Framework (Product Requirements Prompt) PRP was developed by Rasmus Widing, a product manager frustrated by watching AI assistants "build random, useless things instead of what was actually needed." **What Makes PRP Different:** A PRP combines three elements that traditional PRDs lack: 1. **The PRD itself**: What and why you're building 2. **Curated codebase context**: File paths, library versions, existing patterns 3. **Executable validation commands**: Tests the AI can run to verify its work The goal: "Ship production-ready code on the first pass" by providing the minimum viable context an AI needs. **The Three Core Goals:** 1. **The Value**: Why are you building this? 2. **The Scope**: What exactly are you building? 3. **Success Criteria**: How do you measure success? **The Workflow:** 1. **Load the PRP**: AI gathers all context 2. **Plan**: Creates comprehensive task breakdown 3. **Execute**: Carries out the plan 4. **Validate**: Runs validation loops 5. **Complete**: Finalizes with PRP reference **The Ralph Loop (Autonomous Execution):** An innovative feature where the AI repeatedly implements, validates, fixes failures, and re-validates until all checks pass—essentially debugging itself across iterations. **Critical Best Practice:** "Between the creation of the PRP and the execution, you should use a new instance of your AI assistant or at least clear the context. If you do planning and execution in the same context window, you will run out of context quickly, and it can lead to hallucinations." **Why PRP Dominates Traditional Prompting:** "A simple prompt gets you a generic, buggy app. A PRP gets you a production-ready application that works, often on the first try, because you did the thinking and planning upfront." ### Framework 3: Spec-Driven Development (SDD) ThoughtWorks calls spec-driven development "one of the most important practices to emerge in 2025." It may not have the visibility of vibe coding, but it's fundamentally reshaping how AI-assisted development works. **Core Paradigm:** Spec-driven development uses well-crafted software requirement specifications as prompts, aided by AI coding agents, to generate executable code. As one practitioner notes: "We're moving from 'code is the source of truth' to 'intent is the source of truth.'" **The Key Principle:** "This step is important: you're not asking the AI agent to start coding yet. You're asking it to think first." **What Makes a Good Specification:** - Uses domain-oriented ubiquitous language (not tech-specific implementations) - Employs clear Given/When/Then structure for scenarios - Balances completeness with conciseness - Maintains clarity and determinism to reduce hallucinations - Incorporates semi-structured inputs/outputs alongside natural language **The Goal:** "Think 95% or higher accuracy in implementing specs on the first go, with code that's error-free and unit tested." **Tools Supporting SDD:** - **GitHub Spec-Kit**: Works with Copilot, Claude Code, Gemini CLI - **Anthropic's Claude Plan phase**: Formalizes exploration into versioned specifications - **SPARC and Claude-Flow frameworks**: Intent → Plan → Implementation pipelines **Important Distinction—Not Waterfall:** SDD differs from traditional waterfall by maintaining short feedback cycles through AI-assisted code generation rather than extended planning phases followed by lengthy implementation periods. ## The Tools: Plan Modes in Modern AI Assistants Every major AI coding assistant now has a dedicated planning mode. This isn't coincidence—it's recognition that planning is essential. ### GitHub Copilot Plan Mode Released in public preview November 2025 for JetBrains, Eclipse, and Xcode. **What It Does:** - Analyzes your codebase and generates detailed execution plans - Validates that requirements are covered BEFORE coding starts - Does not make any code changes until the plan is reviewed and approved **Key Feature:** "Planning in Visual Studio represents a visible step toward agentic AI workflows. Instead of responding to isolated prompts, Copilot now generates a transparent, traceable plan that outlines what it will do before making changes." **Copilot Workspace Architecture:** Start from a task → Generate specification → Turn into detailed plan → Implement → Review. Every step is exposed for human approval. ### Cursor AI Plan Mode Available since October 2025. **Key Innovation—Separation of Planning and Execution:** "Cursor 2.0 separates planning from execution. Developers can assign one model to create a plan and a different model to build it." **Parallel Agent Architecture:** "You can have multiple agents working in parallel on the same project (e.g., one refactoring, one fixing tests, one doing UI polish) and hop between them like you'd switch terminals or branches." **Background Agents:** Cursor's Background Agent lets you spawn remote, asynchronous coding agents that work in parallel on medium-sized tasks while you keep coding. The agent clones your repo on a separate branch, runs builds/tests, and can open PRs. ### Claude Code Plan Mode Activated with Shift+Tab twice—creates a read-only research environment. **What Happens in Plan Mode:** Claude has access only to read-only tools: Read, LS, Glob, Grep, Task (research agents), TodoRead/TodoWrite. It can explore and plan but cannot modify files. **Why This Matters:** "With plan mode, Claude Code first builds a comprehensive understanding of your entire system architecture. It reads your documentation, understands your patterns, and formulates an approach that aligns with your existing codebase." **The Result:** "Instead of fixing architectural mismatches after the fact, you get implementations that feel intentional and cohesive from the start." ## Enterprise Adoption: The McKinsey Perspective McKinsey's State of AI 2025 (1,993 respondents, 105 countries) reveals how enterprises are approaching AI-assisted development: - **88%** now use AI in at least one business function (up from 78%) - **23%** are scaling agentic AI systems; **39%** are experimenting - High performers are **3x more likely** to have fundamentally redesigned workflows - The role of developers shifts from **implementation to orchestration**, focusing on problem-solving and system design **Architecture Requirements:** "Supporting agentic AI at scale involves more than plugging in an LLM. It requires retooling foundational infrastructure across five components: data layer, governance, security, developer tool chains, and agent operations." **Agent Architecture Patterns:** - **Orchestration agents** for coordinating tasks across multiple agents - **Communicator agents** that share messages throughout a workflow - **Planner agents** that determine what steps are needed to complete requests ## The 80% Problem: Why Architecture Matters An engineer at Anthropic recently made a bold claim: "Claude Code wrote 80% of its own code." This sparked debate—but the nuance matters. **What 80% Actually Means:** "The 80% figure likely refers to how much of the written code was generated by Claude Code after getting clear directions from human engineers. It doesn't mean the AI designed itself from scratch. The big-picture thinking, the planning, and the decision-making still came from people." **The Architecture Gap:** As Ox Security found: "AI-generated code is highly functional but systematically lacking in architectural judgment." **Why This Matters:** "AI doesn't know your architecture. It doesn't understand your design patterns, team conventions, or scaling goals. It simply generates what looks contextually 'correct,' often solving the surface-level problem." **The Consequence:** "Unchecked, this leads to fragmented designs, duplicated logic, and growing architectural drift—all classic signs of technical debt. What once took years to accumulate can now happen in a few sprints." ## Practical Vibe-Planning: A Step-by-Step Guide Here's how to apply vibe-planning regardless of which framework you choose: ### Step 1: Explore the Problem Space Before asking AI to solve anything, ask it to help you understand: ``` "What are the key considerations when building [X]?" "What questions should I be asking about [Y]?" "What are common mistakes teams make when implementing [Z]?" ``` ### Step 2: Generate and Compare Options Don't ask for THE solution. Ask for OPTIONS: ``` "What are 3-5 different approaches to [problem]?" "Compare the tradeoffs between [approach A] and [approach B]" "What would a senior architect consider when choosing between these?" ``` **Pro tip**: Ask AI to argue AGAINST each option to surface hidden issues. ### Step 3: Add Your Context Now bring in what AI doesn't know: ``` "Given that our team has experience with [X] but not [Y]..." "Considering we need to scale to [N] users in [timeframe]..." "Since our main constraint is [budget/time/complexity]..." ``` ### Step 4: Create the Specification Use one of the frameworks: - **BMAD**: Create a Product Brief, then PRD, then Architecture doc - **PRP**: Write a Product Requirements Prompt with context and validation - **SDD**: Create Given/When/Then specifications with clear acceptance criteria ### Step 5: Validate Before Implementing Ask AI to review the plan: ``` "Review this specification. What edge cases are missing?" "What could go wrong with this architecture?" "How would you test that this implementation is correct?" ``` ### Step 6: Execute with Plan Mode Use your AI assistant's plan mode: - **GitHub Copilot**: Enable planning in agent mode - **Cursor**: Use Plan Mode to separate planning from execution - **Claude Code**: Shift+Tab twice for read-only exploration ### Step 7: Implement Incrementally Break implementation into small, verifiable chunks. Run tests after each integration. Commit frequently. ## Why This Matters for You As a PM who has led teams building AI-powered products at AT&T, I've seen this pattern repeatedly: **Teams that vibe-code:** - Ship the first version fast - Spend 3x longer on bug fixes - Can't explain their own systems - Hit the "19% slower" trap **Teams that vibe-plan:** - Spend slightly more time upfront - Ship with fewer critical bugs - Hit the "56% faster" benchmark - Evolve their systems sustainably **The Gartner Warning:** Gartner predicts that by 2030, AI-native development platforms will result in 80% of organizations evolving large software engineering teams into smaller, more nimble teams augmented by AI. But this only works if those teams master planning. As Gartner notes: "In the AI-native era, software engineers will adopt an 'AI-first' mindset, where they primarily focus on steering AI agents toward the most relevant context and constraints for a given task." That's vibe-planning. ## Connecting to Our AI Fundamentals This is exactly why I've been taking you through AI fundamentals in this series: | Previous Topic | Connection to Vibe-Planning | |----------------|----------------------------| | **Embeddings** | Understanding how AI retrieves relevant context for planning | | **Vector Databases** | Storing architectural decisions and patterns for retrieval | | **Neural Networks** | Understanding AI's limitations in architectural judgment | | **Prompting Techniques** | CoT and Few-Shot ARE planning techniques | The prompting techniques we covered aren't just for getting better code—they're for getting better thinking. When you ask AI to "think step by step" about your architecture, you're vibe-planning. ## What's Next And the best part? Each of these frameworks deserves a deep-dive. In my next posts, I'll explore each one in detail—starting with BMAD Method, then PRP Framework, then Spec-Driven Development—before we get to Context Engineering and RAG. Excited to delve deeper? In next week's post, I will explain BMAD Method in detail—the enterprise solution with 21 specialized agents that addresses vibe coding's failures at scale. Stay tuned!! ## Key Takeaways - **Vibe-planning** = Using AI to explore, plan, and understand BEFORE coding - **The data**: AI cuts time by 56% WITH planning; increases time by 19% WITHOUT it - **Gartner warning**: Prompt-to-app without planning will increase defects by 2,500% by 2028 - **BMAD Method**: 21 agents, 4 phases, documentation as source of truth - **PRP Framework**: PRD + codebase context + validation = production-ready on first pass - **Spec-Driven Development**: "Intent is the source of truth"—95%+ accuracy goal - **All major tools now have Plan Modes**: GitHub Copilot, Cursor, Claude Code - **McKinsey insight**: High performers are 3x more likely to redesign workflows ## Additional Documents to Read on This - [BMAD Method - GitHub](https://github.com/bmad-code-org/BMAD-METHOD) - Open-source framework with 21 specialized agents - [PRP Framework - GitHub](https://github.com/Wirasm/PRPs-agentic-eng) - Product Requirements Prompt templates - [Spec-Driven Development - ThoughtWorks](https://www.thoughtworks.com/en-us/insights/blog/agile-engineering-practices/spec-driven-development-unpacking-2025-new-engineering-practices) - "One of the most important practices of 2025" - [Spec-Driven Development - GitHub Blog](https://github.blog/ai-and-ml/generative-ai/spec-driven-development-with-ai-get-started-with-a-new-open-source-toolkit/) - GitHub's Spec-Kit toolkit - [Cursor Plan Mode Documentation](https://cursor.com/docs/agent/planning) - Official docs - [Claude Code Plan Mode](https://code.claude.com/docs/en/common-workflows) - Anthropic's approach - [State of AI 2025 - McKinsey](https://www.mckinsey.com/capabilities/quantumblack/our-insights/the-state-of-ai) - Enterprise adoption data --- *This is part of my weekly AI series taking you progressively from fundamentals to practical applications. Previous posts covered embeddings, vector databases, neural networks, prompting techniques, and vibe coding dangers. Next week: BMAD Method deep-dive.*