Stop Letting Your AI Wing It: Why Structured Planning Beats Autonomous Chaos

You've probably had this experience: you ask an AI coding assistant to build something, it confidently generates a mountain of code, and within an hour you're staring at a tangled mess you can't debug. The problem isn't the AI—it's that you handed it the wheel without a map. That's exactly the pain point this guide addresses.

The vibe-coding repository, maintained by Nicolas Zullo, isn't a library or a framework. It's a practical, opinionated workflow for using AI coding tools like Claude Code and Codex CLI to build real projects—specifically games—without letting the AI turn your codebase into an unmanageable pile of spaghetti. The core philosophy is simple, and it's stated right in the README: Planning is everything. Do NOT let the AI plan autonomously.

What It Does

This project is a living document—currently at version 1.2.2—that walks you through a structured setup process for AI-assisted development. It's built around two specific tools: Claude Opus 4.7 (used within Claude Code) and Codex 5.5 (used within Codex CLI or the Codex App, which runs about $20/month for the Plus tier). Both have terminal and VSCode extension versions, and the guide notes that the Codex App is currently gaining popularity.

The workflow itself is a three-stage process:

1. Create a Game Design Document (GDD) or Product Requirements Document (PRD) in Markdown. You ask the AI to draft it based on your idea, then you review and refine it to match your vision.

2. Define your tech stack and generate an AGENTS.md file using the /init command in your CLI tool. This creates a set of rules that guide the AI's behavior. The guide stresses that you must manually review these rules and set critical ones to "Always" trigger—things like always reading the architecture doc or GDD before writing code.

3. Generate an implementation plan by feeding the GDD and tech stack document back to the AI, which produces a step-by-step Markdown plan for building the project.

The key architectural insight is modularity. The guide explicitly tells you to ensure your rules discourage a monolith (one giant file) and encourage multiple files, which helps maintain context and keeps the codebase clean as it grows.

Why It's Cool

What makes this guide genuinely useful is that it treats AI coding as a discipline, not a magic trick. Here's what stands out:

• It's brutally practical about failure modes. The README doesn't pretend AI is flawless. It acknowledges that without structure, you'll end up with an unmanageable mess. That honesty is refreshing in a space full of hype.

• The "Always" rules concept is clever. By forcing the AI to re-read your architecture and design documents before every code generation, you're essentially giving it a persistent memory. This is a simple workaround for one of the biggest limitations of LLM context windows—and it costs nothing to implement.

• It's opinionated, and that's a feature. The guide doesn't try to cover every tool. It picks Claude Opus 4.7 and Codex 5.5, says Cursor is less powerful (with a link to an older version if you insist), and moves on. This saves you from analysis paralysis.

• The iterative approach is realistic. The GDD doesn't need to be perfect upfront. The guide says "it's fine if it's basic" because you'll iterate later. That aligns with how development actually works.

• It's versioned like software. The fact that this is at v1.2.2 with notes about how the recommended models have changed (Grok 3, then Gemini 2.5 Pro, now Claude Opus 4.7) shows the author is actively maintaining it and adapting to the fast-moving AI landscape.

How to Try It

Getting started is straightforward. First, clone or bookmark the repository at github.com/EnzeD/vibe-coding. Then follow the setup:

1. Install the basics: Download Visual Studio Code, create a new folder, and open it in the editor.

2. Install your AI tool via terminal:

   npm i -g @openai/codex
   # or
   npm i -g @anthropic-ai/claude-code
   

   (Or download the Codex app if you prefer a GUI.)

3. Draft your GDD: Ask Codex 5.5 to create a game-design-document.md based on your idea. Review and refine it.

4. Define your stack: Ask for a tech-stack.md recommendation. The guide suggests challenging the AI to propose the simplest yet most robust stack possible—for example, Vite + ThreeJS with WebSocket for multiplayer 3D.

5. Generate your rules: In your terminal, run /init in Claude Code or Codex CLI. It will use your two .md files to create an AGENTS.md. Then—and this is crucial—review those rules and manually add "Always" directives like:

   # Always read memory-bank/@architecture.md before writing any code.
   # Always read memory-bank/@game-design-document.md before writing any code.
   

6. Create your implementation plan: Feed the GDD and tech stack docs to Codex 5.5 and ask for a detailed, step-by-step implementation plan in Markdown.

Final Thoughts

This guide is best for developers who want to use AI coding assistants seriously—not for quick one-off scripts, but for building actual games or apps with clean, maintainable codebases. It requires a bit of upfront discipline (reviewing and tweaking rules isn't the most glamorous task), but that investment pays off when you're not drowning in unmaintainable generated code. The author's willingness to update the guide as tools evolve suggests it'll stay relevant, and the core principle—that structure and planning matter even when AI is doing the heavy lifting—isn't going to age poorly. If you've been frustrated by AI-generated code that falls apart at the first feature addition, this workflow is worth trying.

Follow @githubprojects for more developer tools and open source projects.