Vibe Coding Workflow and Prompt Writing Tips

The two most important things in vibe coding are "how you talk to AI" and "in what order you work." Even with the same tools, the quality of results varies dramatically depending on how you write prompts and what workflow you follow.

This article covers the basic structure of workflows for effective collaboration with AI, how to use Plan Mode for complex tasks, and specific tips for writing good prompts.

Basic Workflow

Vibe coding isn't about throwing a single request at AI and calling it done. You need to follow a structured workflow to get the results you want.

Plan → Review Plan & Feedback → Execute → Feedback → Revise → Final Review → Save

1. Plan - Have the AI create a plan first. "Don't modify anything yet — show me the plan first." Check the big picture of which files to change and how.

2. Review Plan & Feedback - Review the AI's proposed plan. Check if the direction is right and nothing is missing. Adjust as needed: "Let's use a different approach for this part," "This file needs to be modified too."

3. Execute - Once the plan is agreed upon, the AI modifies the actual code.

4. Feedback - Review the results and communicate any issues or improvements.

5. Revise - The AI revises based on your feedback. Steps 4-5 can repeat until you're satisfied.

6. Final Review - Review all changes. Final check that everything was modified as intended and nothing was missed.

7. Save - If everything looks good, commit or save.

The key is "plan first, execute later." If you tell AI to modify code directly, it's hard to recover when the direction goes wrong. Aligning the direction thoroughly in the planning stage and executing after agreement is much more efficient.

Controlling Task Size

When you ask for a large task all at once, the AI is more likely to go in the wrong direction or make mistakes. Breaking tasks into appropriate sizes is important.

Request that's too large:"Build the entire login feature. UI, API integration, error handling, and session management all at once."

Appropriately broken down:1. "First, create the login UI"
2. (After reviewing) "Now add the API integration"
3. (After reviewing) "Add error handling"
4. (After reviewing) "Add session management logic"

Since you verify results at each step, the chance of going off track decreases. And because the AI can see the code from previous steps, consistency is maintained.

What is a Prompt?

A prompt is the instruction you send to AI. Every text you type in the chat window is a prompt.

Even for the same purpose, the quality of AI's response varies significantly depending on how you write the prompt. Think of it like a recipe — the clearer you specify the ingredients and steps, the closer the result will be to what you want.

5 Principles of Good Prompts

1. Be Specific

Instead of vague expressions, specify concrete targets and actions.

❌ "Fix this"
✅ "In UserService.cs, the Login method throws a NullReferenceException when password is null. Add a null check."

❌ "Make it better"
✅ "This function has O(n²) time complexity. Improve it to O(n) using a hashmap."

The more specific you are about which file, which part, and what change, the more accurately the AI works.

2. Provide Context

At the start of a conversation, the AI knows nothing about your project. You need to provide the necessary background.

But you don't need to type context into every prompt. It's far more efficient to record recurring context in CLAUDE.md or AGENTS.md. Since the AI automatically reads these files when a session starts, you don't have to repeat instructions like "respond in Korean" or "don't touch this folder" every time.

Good things to record in MD:• Tech stack (Unity + C# + Firebase, etc.)
• Project structure and work scope
• Code conventions and naming rules
• Prohibitions (no auto-commit, no modifying certain files, etc.)
• Language and tone settings

Things to provide directly in prompts:• Current task specifics: "I'm adding login functionality. The basic UI is done, but API integration isn't yet."
• Connection to previous work: "Following up on the AuthManager we built earlier, I want to add token refresh logic."
• Special requirements unique to this task

The project settings file guide is covered in detail in the CLAUDE.md and AGENTS.md settings guide in this series.

3. Break It Down

When you ask for multiple things at once, the AI may skip some or go in the wrong direction.

❌ "Design the database schema, create API endpoints, and connect the frontend."

✅ Step 1: "First, design the user data schema"
✅ Step 2: "Create CRUD APIs for this schema"
✅ Step 3: "Write the frontend code to call these APIs"

Reviewing results at each step reduces the cost of corrections.

4. Include Examples

Showing examples of the desired output helps the AI understand your intent more accurately.

"Format the API response like this:"

{
  "status": "success",
  "data": {
    "userId": "abc123",
    "nickname": "player1"
  },
  "error": null
}

"Write commit messages in this format: '2026-02-05 14:30 Add login feature'"

"Format logs like this: [INFO] 2026-02-05 14:30:00 - message"

A single example is often more effective than a lengthy explanation.

5. State Constraints

Clearly tell the AI what it should and shouldn't do.

Constraints to provide in prompts (per-task):"Don't change the existing API interface. Backward compatibility must be maintained."
"Only modify this file. Don't touch other files."
"Don't modify anything yet — just show me the plan."

Constraints to record in MD (recurring ones):• Always get approval before modifying code
• No auto-commit/push
• Certain folders off-limits (build outputs, environment variables, etc.)
• Don't add external libraries without permission
• Error message language settings

If you find yourself repeating the same constraints, record them in CLAUDE.md or AGENTS.md. They'll be applied automatically every session, which also helps prevent mistakes.

Bad Prompts vs Good Prompts

Let's compare with real examples.

Bug Fix:❌ "Fix the bug"
✅ "There's a double-jump bug in PlayerController.cs's Jump() method. Pressing the jump key while already in the air triggers another jump. Check and fix the isGrounded logic."

Feature Addition:❌ "Add dark mode"
✅ "I want to add a dark mode toggle to the settings screen. Add a toggle button to the existing SettingsUI.cs and implement saving the selected theme to PlayerPrefs. Color palettes are defined in ThemeColors.cs."

Refactoring:❌ "Clean up the code"
✅ "AuthManager.cs is over 500 lines and I want to split it by responsibility. First, analyze what responsibilities this file handles and suggest how to separate them. Don't modify anything yet — just show me the plan."

Code Understanding:❌ "What is this code"
✅ "Explain how the HandleDisconnect method in NetworkManager.cs works. I especially want to know under what conditions the reconnection logic is triggered."

Using Images and Screenshots

Both Claude Code and Codex can analyze images. Use screenshots when situations are hard to describe with text.

Error Messages:Capture the error message from your terminal or editor and send it with "Help me fix this error." It's more accurate and faster than typing out the error.

UI Design:Show design mockups and request "Implement the UI according to this design." The AI can directly see and understand the layout, colors, and spacing.

Current State:Showing the current screen with "This is how it looks now, I want to change this part" makes communication much clearer.

How to send images:• CLI: Paste an image from clipboard into the prompt
• Desktop/IDE: Drag and drop or paste
• File path: "Refer to this image: ./screenshots/error.png"

Tips for Continuing Conversations

Vibe coding isn't about a single prompt — it's about refining results through ongoing dialogue.

Refining with follow-ups:"Good, but change just this part differently"
"Add error handling too"
"Rename the variables to be more descriptive"

Reverting:"Undo the last change"
"The previous approach was better. Go back to that."

Verification requests:"Check if there are any issues with this code"
"Review if I missed any edge cases"

Changing direction:"Is there another approach besides this?"
"Performance matters more, so redo it with optimization in mind"

When to Start a New Session

If a single session gets too long, the AI's response quality may degrade. As context becomes complex, it may conflict with earlier information or get confused by irrelevant context.

Good times to start a new session:• When starting a completely different task from the current one
• When the conversation has gotten so long that the AI confuses earlier context
• When you've gone too deep in the wrong direction

Use the /new command to start a new session. If you want to return to a previous session, use /resume. These concepts are covered in detail in the Basic Concepts and Settings article in this series.

Using Plan Mode

Sometimes you want to plan before jumping into a complex task. You want to see the big picture of "which files to change and how" before any code is actually modified. That's when you use Plan Mode.

In Plan Mode, the AI only reads code and doesn't modify anything. It analyzes files, understands the structure, creates an implementation plan, and presents it. Actual code modifications only begin after the user reviews and approves the plan.

How to Enter Plan Mode

Claude Code:

# Method 1: Switch mode during a session
Shift+Tab  # Cycles: Normal → Auto-Accept → Plan Mode

# Method 2: Start directly in Plan Mode
claude --permission-mode plan

Codex:

# Method 1: Slash command
/plan
/plan "Create a refactoring plan for the auth system"

# Method 2: Mode switch
Shift+Tab

How Plan Mode Works

In Plan Mode, the AI follows these steps:

Phase 1 - Explore: Reads code and understands the structure
Phase 2 - Design: Designs the implementation approach
Phase 3 - Review: Asks the user about unclear parts
Phase 4 - Write Plan: Documents the final plan

Claude Code:• Plans are automatically saved as markdown files in the .claude/plans/ folder
• You can edit the plan file directly in your editor with Ctrl+G
• When satisfied, switch to Normal Mode with Shift+Tab to start implementation

Codex:• Plans are streamed in real-time to the terminal view
• After reviewing, switch modes to proceed with execution

When to Use Plan Mode

Good situations for Plan Mode:• Tasks that modify multiple files simultaneously
• Large refactoring or architecture changes
• When you're unsure about which approach to take
• Changes that are hard to reverse if done wrong

When it's unnecessary:• Simple tasks like fixing typos or adding a log line
• Changes to just a few lines in a single file
• Tasks where the direction is already clear

Using Plan Mode for complex tasks helps prevent the "I made changes but the direction was wrong" situation.

Summary

Workflow:• Plan → Review Plan & Feedback → Execute → Feedback → Revise → Final Review → Save
• The key is "plan first, execute later"
• Break large tasks into smaller steps
• Use Plan Mode for complex tasks

Prompt Writing:• Be specific, provide context, break it down, include examples, and state constraints
• Record recurring context and constraints in CLAUDE.md / AGENTS.md
• Make good use of images
• Refine results through ongoing conversation

Writing prompts may feel awkward at first. But after a few iterations, you'll develop a sense for what and how to communicate with AI to get good results. Rather than agonizing over the perfect prompt, just start the conversation and refine as you go.