Skip to content
Search

Vibe coding

lastmod 2026-03-05created 2025-03-2414 edits

Vibe coding is an AI-based programming technique that solves problems by entering prompts into a large language model (LLM).

As LLMs generate software, the programmer's role is shifting from coding directly toward testing, modifying, and guiding the source code generated by AI.

Its proponents claim that Vibe Coding lets even beginners who know little about development produce software without training or skills in software engineering.

The term was introduced by Andrej Karpathy in February 2025 and was listed in the Merriam-Webster dictionary the following month as a "slang & trending" noun.

Categories

Vibe Coding manual

Vibe Coding is a software development approach in which humans collaborate with AI models to build projects efficiently

  • Consists of three core pillars:
    • Specification: define the goal (e.g., "build a Twitter clone with login")
    • Rules: set explicit constraints (e.g., "use Python, avoid complexity")
    • Oversight: monitor the process and ensure consistency
  • This manual provides a comprehensive framework for developers of all levels
    • Organizes four files (or sections) in .cursor/rules , .windsurfrules
  • Core rules
    • 1. Coding preferences – "Write code like this": defines code style and quality standards
    • 2. Tech stack – "Use these tools": specifies tools and technologies
    • 3. Workflow preferences – "Work like this": governs the AI's process and execution
    • 4. Communication preferences – "Talk like this": sets expectations for AI-human interaction
  • Advanced rules - extensions for complex projects
  • Practical example: how it works
  • Advanced tips: getting the most out of the framework

Practical tips for improving programming efficiency and quality with AI

Wants to use AI coding tools to cut conversion work that takes a person 1–2 hours down to a 15–20 minute review. But currently the quality of AI-generated code doesn't even reach 90% of hand-written code, so it doesn't seem to be of real help. Wonders how to use AI to raise productivity and code quality at the same time.

  1. Focus AI only on repeatable tasks
    • AI is most effective when similar tasks are repeated many times
    • Implement it once yourself at the highest quality and use it as the reference example
    • Then hand off work with the same pattern to AI for bulk processing
    • Expected efficiency drops sharply for tasks that require thinking and judgment
  2. Always make a plan before coding
    • Don't generate code right away; write a solution plan first
    • Have all ambiguities and questions surface during the planning stage
    • Don't move on to execution if the plan isn't satisfactory
    • Output quality depends more on the clarity of the plan document than on the prompt
  3. Break work into extremely small units
    • Request in units of one file, one component, or a few functions
    • Requests like "refactor everything" or "make it more idiomatic" have a high failure rate
    • People do the structural design; leave only repetitive implementation to AI
  4. Don't accumulate context; reset it often
    • The longer the conversation, the more rule compliance and quality drop sharply
    • One session handles only one task
    • If the direction changes, start over in a new session
    • For long-running work, preserve state in documents (plan.md, etc.) and reinject it
  5. Keep rule documents short and mechanical
    • Keep CLAUDE.md / AGENTS.md within 500–1000 tokens
    • Write concrete, verifiable rules rather than declarative guidelines
    • Record only what it frequently gets wrong, minimally
    • Enforce the rest with code and automated checks
  6. Use tests, linters, and builds as a feedback loop
    • Instead of "make it good," clearly state the pass conditions
    • Set goals of passing tests, a successful build, and zero linter errors
    • AI converges on its own only when there is a feedback loop
    • Tests that verify existing behavior greatly lower the difficulty of refactoring
  7. Don't fix things mid-execution; fix the plan and run again
    • If you don't like the result, don't keep repeating code-change requests
    • Edit the plan document and run again in a new session
    • Changing direction during execution quickly degrades quality
  8. Teach style through examples
    • Abstract "good code" instructions have almost no effect
    • Provide Before / After examples together
    • Clearly distinguish good and bad examples
    • Expand rules around the examples
  9. Don't give up on understanding; make the boundaries of responsibility clear
    • A person must understand and review AI-generated code
    • No unreviewed use except for prototypes and low-risk code
    • For security, operations, and long-term maintenance code, understanding is the prerequisite for quality
  10. First check whether the task suits AI
    • Tasks with no right answer and heavy aesthetic/structural judgment are unfavorable for AI
    • UI refactoring, whose visual results are hard to verify automatically, is especially tricky
    • If needed:
      • Step 1: mechanical conversion aimed at preserving behavior
      • Step 2: a person performs quality refactoring
  11. Start expectations at "10% improvement"
    • Don't expect 10x from the start
    • A strategy of accumulating small improvements is more effective in the long run
    • The key is not giving up on design and quality standards

Problems and limitations of vibe coding

Was amazed while handing off bigger and bigger tasks to AI coding tools, but found that the output lacked consistency and structural completeness

  • Even with detailed specs, AI agents can't maintain long-term context or evolve the design, and eventually the whole codebase turns into a collection of heterogeneous pieces
  • Each code piece looks complete on its own, but overall there is structural disorder (sloppy) and context collapse
  • After this experience, the author concluded that AI-written code cannot guarantee user trust or data protection, and returned to writing code directly
  • AI coding is still useful, but it can lead to technical debt and loss of developer control, so it needs to be used carefully

A real developer's practical workflow

The key is not letting Claude write code until the developer has personally reviewed and approved the written plan By separating planning from coding, this reduces unnecessary trial and error, keeps the developer in charge of architectural decisions, and helps get better results with more efficient token use.

Step-by-step workflow:

  1. Research:
    • Every task starts with reading the codebase deeply.
    • Have Claude thoroughly understand the relevant parts and write its findings in a markdown file (research.md).
    • Use words like 'deeply', 'in great detail', and 'specifics' here so Claude doesn't just skim. This step is important for preventing 'silent failures' that damage the system.
  2. Plan:
    • Have it write a detailed implementation plan in a separate markdown file (plan.md).
    • The plan includes the approach, code snippets, paths of files to be modified, considerations, trade-offs, and so on.
    • It's important to use your own Markdown file instead of Claude Code's built-in plan mode. This has advantages such as direct editing, adding inline notes, and storing a permanent artifact.
  3. Review & Annotation:
    • The developer opens the plan.md Claude wrote directly in an editor, adds notes, and reviews it.
    • Notes are used in many ways: correcting wrong assumptions, rejecting an approach, adding constraints, or providing domain knowledge.
    • After adding notes, explicitly instruct Claude "don't implement yet" and have it update the plan, repeating this process until you're satisfied.
  4. Implementation:
    • When the plan is fully ready, give Claude the command to implement.
    • At this stage, all decisions have already been made and verified, so implementation proceeds mechanically and uncreatively.
    • At this point the developer acts as a supervisor, checking that Claude writes code according to the plan.
    • If it's going in the wrong direction, it's important to revert with Git and reset the scope.

Additional tips:

  • Keep your hands on the wheel: leave execution to Claude, but never hand over the decision about what to build.
  • One long session: don't split research, planning, and implementation into separate sessions; carry them through within one long session. This helps Claude keep building up context.

In conclusion, this workflow emphasizes a disciplined pipeline that separates thinking from typing.

The point is not to make Claude write code well, but to be certain about what should be written before any code is written.

My personal tip

Ask for an explanation of anything you don't fully understand (demand that it make you understand, and move on only once you're convinced)

Cognitive debt: when velocity exceeds comprehension

  • Cognitive debt: when velocity exceeds comprehension | GeekNews
  • AI-assisted development makes code production faster than human comprehension, creating 'cognitive debt'
  • Even when code works and passes tests, a state accumulates in which developers themselves don't understand the code's structure and reasons
  • Reviewers' limited capacity, loss of organizational tacit knowledge, and lack of learning among junior developers accelerate this debt
  • Organizations measure only velocity-centric metrics (DORA, story points, etc.) and fail to catch the comprehension gap
  • As the gap between productivity and comprehension widens, there's a high risk of long-term maintenance failures, knowledge discontinuity, and stagnation in engineer growth

See also

Favorite site

Article

  • What I learned earning $18,500 with vibe coding | GeekNews - 10 key principles learned through vibe coding
    • Set rules: give the AI clear project rules and constraints to maintain consistent code quality.
    • Provide official documentation: when using a new tech stack, always provide links to the official documentation.
    • Write it yourself when the code goes wrong: when errors repeat, provide correct example code directly instead of long explanations.
    • Use chat history: reuse previously successful prompts and markdown guide files for repetitive tasks.
    • Write specific prompts: clearly state the tech stack, feature requirements, constraints, and exception handling.
    • Improve with iterative feedback: improve the output gradually through specific, objective feedback.
    • Work file by file: split large projects into small file units to make finding and fixing errors easier.
    • Don't gloss over things: don't miss details, and when a problem occurs, point out exactly what went wrong.
    • Take a test-first approach: write test cases before implementation code to set clear goals.
    • Ideation and commercialization: the core idea and business model, more than the technical implementation, are the keys to success.
  • If you're going to vibe code, why not do it in C? | GeekNews
    • Every programming language is a tool designed for human convenience, not for machines, and benefits like safety, abstraction, and readability are ultimately structures for human thinking
    • So does AI-written code really need a human-friendly language? Proposes VOPL (Vibe-Oriented Programming Language), a new machine-friendly, AI-centric language

Guide

author Zer0 sitemap