Vibe Coding Philosophy: Programming with AI Like Mentoring an Intern

Recently, the term "Vibe Coding" has swept across the land, painting a dream blueprint for many. It seems that with AI, everyone can code, build products, and with just a few words, a beautiful interface will magically appear.

However, when you eagerly dive into practice and try Vibe Coding, have you encountered these frustrations?

• You ask it to optimize a page logic, and it "goes wild," messing up all the state logic and prop passing.
• You ask it to write a new page, and the code looks decent, but when you try to integrate it into the project, you find states flying everywhere, making it impossible to maintain. In the end, you still have to painstakingly refactor it yourself.
• Sometimes it gives you a seemingly clean piece of code, but when you run it, the screen is flooded with errors. An existing feature was accidentally broken by it! What follows is a long and painful "Vibe Debugging" process.

After all that, the excitement is gone, leaving only exhaustion. It feels like Vibe Coding looks beautiful but is tiring to use. Is AI programming just a facade?

After immersing myself in AI pair programming for a long time and oscillating between Vibe Coding and "traditional programming" multiple times, I finally realized that the problem isn't with the tool itself, but with how we use it and our mindset. The secret to AI programming is actually very simple:

We need to correctly position AI. You should view AI as a "super-intelligent intern," and you are the senior engineer guiding them.

AI is Insanely Intelligent, a Top-Tier University Graduate with Superb Knowledge

Why do I say AI is "super-intelligent"? It's mainly reflected in three points:

1. For clear algorithmic problems, it can instantly solve them. Ask it to implement a complex algorithm from scratch, whether it's quicksort or a red-black tree, and it won't bat an eye. The code it provides might even be more elegant than what you find online. Its pure logic and algorithmic capabilities are unmatched.

2. Its breadth of knowledge is unparalleled. From ancient programming language design to the latest development frameworks, and even an obscure API, if you ask it, it generally knows. A human would probably need 50 years of study at top universities to achieve this breadth of knowledge.

3. It has superb imitation skills. This is the most powerful aspect. Just give it a piece of code, whether it's an ancestral business process from your project or a complex component you just wrote, and it can mimic it, writing code in a consistent style that perfectly integrates.

However, precisely because it's so capable, we are more easily misled and tend to trust it too much. AI's powerful imitation ability is a double-edged sword: feed it good examples, and it's a god-tier teammate; feed it bad code, and it becomes a legacy code builder; if you don't feed it any examples at all, it will freely improvise based on its imagination, producing code that seems correct but deviates from the project's actual context, with unimaginable consequences.

Please don't forget, beneath the guise of a genius, AI is still just an "intern." Why do I say this? Because it possesses the following intern-like qualities.

First, It Has No Project Experience

Don't let AI's superior intelligence and vast knowledge fool you; that's all just what it learned in "school." Don't forget it has zero work experience. It knows nothing about your project's background. What language does the project use? What framework? What's the development process? What are the coding standards? You need to teach it all, one by one.

Even more seriously, this intern is extremely forgetful, acting like it's their first day on the job every morning. This is essentially the "statelessness" of LLMs; each time you start a new conversation, its memory is cleared.

Since it can't remember, we'll tell it every time! So the best approach is to write down the project background and development standards in a document, and then feed that document into the AI's context every time you work.

We can save a "Project Background Document" in Markdown format and use it to "onboard" the AI intern quickly before each task.

# Project Background Document

## 1. Project Overview
We are developing a data visualization platform named "PixelPerfect Dashboard".

## 2. Technology Stack
- **Framework**: Next.js 13 (App Router)
- **Language**: TypeScript
- **State Management**: Zustand
- **UI/Styling**: Tailwind CSS

## 3. Core Development Standards and Conventions
- **Design Pattern**: Components follow the Atomic Design principle.
- **Directory Structure**: Reusable components are stored in `src/components`, page-level components in `src/app`.
- **Naming Conventions**: Components use PascalCase (e.g., `DataCard.tsx`), Hooks use `use` prefix (e.g., `useUserData.ts`).
- **Data Fetching**: Must be implemented via custom Hooks encapsulating TanStack Query.
- **State Management**: Global state (e.g., user info) is managed by Zustand; component internal state uses React Hooks.
- **Prohibitions**: Direct DOM manipulation is forbidden. Direct `fetch` requests within components are forbidden.

If you use Claude Code, you can put this content into a CLAUDE.md file. If you use Cursor, you can put it into .cursorrule. This way, it will be automatically loaded into the AI's context for each task.

Second, It Doesn't Understand Vague Tasks

No matter how smart an intern is, they can't understand industry jargon and the project's long-standing business logic. To assign them a task, you need to give them complete context so they can understand.

Treat AI like an intern: give clear, specific, and decomposed instructions.

Bad instruction 👎:

"Help me write a login form."

Clear instruction 👍:

"Please create a React login form component LoginForm.tsx for our 'PixelPerfect' project.

1. Use TypeScript and define clear types for props.
2. Include email and password input fields, managing their state with useState.
3. Use Tailwind CSS for layout and styling.
4. When the form is submitted, call the onSubmit prop function, passing email and password.
5. Add an isLoading prop; when true, the submit button should be disabled and show a loading state."

This intern has another advantage: they are diligent and never complain. When you're not satisfied with their first version of the code, don't hesitate; tell them directly what needs to be changed. For example:

• "There's too much hardcoding in the code; extract the colors from CSS into theme variables."
• "The API you used doesn't comply with our standards; use our project's useCustomFetch instead."

Third, You Must Be Responsible for the Intern's Work

In a company, interns are allowed to make mistakes, and the person supervising them needs to have the ability to backstop and be responsible for the product's functionality.

So, when AI does Vibe Coding, do you have the ability to be responsible for the code's outcome?

Be aware that AI can be even more confident, even arrogant, than a human intern. A human intern might ask you for help if they don't know something, but AI can confidently fabricate an answer, which is what we commonly call a "hallucination."

This is a hard-learned lesson: Never blindly trust AI-generated code!

Whether it's performing Code Review or conducting every test, you need to use various methods to check if the AI-generated code is correct.

Whether it's Code Review or thorough testing, you need to use your experience and professional knowledge to ensure the quality of these outputs. During Code Review, just like checking an intern's code, pay special attention to the following pitfalls AI tends to dig for you:

• Clever shortcuts: You ask it to fix a bug and require all tests to pass. It might directly modify the test case's assertions just to make the tests pass. On the surface, the tests indeed pass, betting you won't review it carefully.
• Wants to change everything: Sometimes AI can be exceptionally diligent (especially Claude models). While modifying one file, it might also "conveniently" change other code it thinks can be optimized. This can easily introduce unexpected bugs, and if you don't look closely, the next run might give you a surprise.
• Reinventing the wheel: AI might not know that your codebase already has a perfect utility function, so it writes another one with similar functionality. This leads to code redundancy and increases maintenance costs. You need to guide it to reuse existing common functions in the project.

AI is responsible for rapid output, and you are responsible for using your experience and professional knowledge to ensure the final quality.

Finally: Treat AI as Your Co-pilot, and Grow Together with It

Whether they believe Vibe Coding is invincible and can replace everything, or they throw out the baby with the bathwater and think AI can't write serious code, neither group can truly master AI programming. The former will lose control of projects due to blind trust, while the latter will miss out on a huge opportunity to boost productivity.

Those who can truly leverage AI programming deeply understand: AI is here to assist you, not to replace you. It's an ability amplifier, not an autopilot.

This smart intern's arrival can free you from tedious, repetitive "manual labor"—such as writing boilerplate code for components, implementing utility functions for known logic, or generating unit tests. This way, you can dedicate your valuable energy to areas that require more human intelligence: untangling complex requirements, designing flexible system architectures, discussing the best technical solutions with the team, and planning the long-term evolution of the product. Your role is shifting from an executor to a thinker and decision-maker.

And you, too, will continuously grow on this journey of "supervising an intern." To give AI clear instructions, you must first decompose the problem more thoroughly in your mind; to review AI's output, you must have a deeper understanding of the project's coding standards and best practices. The more powerful the tool, the higher the demands on the helmsman.

So, have you thought about how you'll guide this smart "intern"?