# Vibe Coding Hallucination and Infinite Loop Handling

> How to Bring an Out-of-Control AI Back on Track

Hello, I'm Yupi.

In previous articles, we discussed how to have efficient conversations with AI and manage context. However, even if you do everything right, you may still encounter situations where the AI "goes on strike" — it starts talking nonsense, gets stuck in an infinite loop, or stubbornly insists on incorrect solutions.

This is quite common in Vibe Coding, and we call it AI Hallucination. Below, I'll teach you how to identify and fix these issues, bringing the out-of-control AI back on track.

## 1. What is AI Hallucination?

Before diving into solutions, let's first understand what AI Hallucination is.

### Definition of AI Hallucination

AI Hallucination refers to content generated by the AI that appears reasonable but is actually incorrect, non-existent, or inconsistent with facts.

For example, in the following dialogue, my real name is definitely not this...

![](https://pic.yupi.icu/1/image-20260104184328898.png)

In programming scenarios, AI Hallucination typically manifests as:

- Fabricating non-existent APIs or functions
- Providing seemingly reasonable but non-functional code
- Persisting with solutions that have already been proven wrong
- Confusing the usage of different tech stacks

For instance, if you ask the AI: "How to get a component's DOM node in React?"

The AI might suggest using `this.getDOMNode()`.

This method sounds reasonable, but it doesn't exist in modern React. The correct approach is to use `useRef`.

### Why Does Hallucination Occur?

There are several reasons why AI hallucinates:

1. Limitations of training data: The AI's knowledge comes from its training data. If the data contains errors or outdated information, the AI will learn incorrect knowledge.

2. Context confusion: When the conversation is too long or the information is too cluttered, the AI may confuse different contexts.

3. Overconfidence: The AI is trained to provide "certain" answers, even when it's unsure, leading it to appear overly confident.

4. Pattern matching errors: The AI might mix up similar but different concepts.

Understanding these reasons helps us better address hallucination issues.

### Extended Knowledge - Common Types of AI Hallucination

In Vibe Coding, AI Hallucination mainly falls into these categories:

1. API Hallucination: Fabricating non-existent functions, methods, or properties

2. Syntax Hallucination: Confusing the syntax of different languages or frameworks

3. Logic Hallucination: Code logic appears correct but is actually flawed

4. Version Hallucination: Using deprecated APIs or outdated practices

5. Dependency Hallucination: Referencing non-existent libraries or incorrect package names

Knowing these types helps you quickly identify issues.

## 2. AI Getting Stuck in an Infinite Loop

Besides hallucinations, another common issue is the AI getting stuck in an infinite loop.

### What is an Infinite Loop?

An infinite loop occurs when the AI repeatedly attempts the same incorrect solution and can't break out of it.

Typical manifestations include:

- First attempt: The AI provides a piece of code, but it has a bug.
- Second attempt: You point out the issue, it makes a slight modification, but the same problem persists.
- Third attempt: You point out the issue again, it tweaks the code again, but remains stuck in the same place.
- Fourth attempt: You start questioning your life...

This is an infinite loop. The AI is trapped in a flawed thought process and can't escape on its own. It not only wastes time but also consumes a lot of tokens unnecessarily.

![](https://pic.yupi.icu/1/aideadloop%E5%A4%A7.jpeg)

### Common Scenarios for Infinite Loops

Infinite loops often occur in these scenarios:

1. Complex state management: The AI can get confused when handling complex state updates.

2. Asynchronous operations: Errors are common when dealing with Promises, async/await, etc.

3. Type systems: Complex type definitions in TypeScript can confuse the AI.

4. Performance optimization: The AI might get stuck in a cycle of "optimize => error => revert => optimize again."

5. Cross-file modifications: Modifying multiple files can lead to oversights, especially in larger projects.

### How to Identify an Infinite Loop?

Some signals I use to identify infinite loops:

- The AI provides essentially the same solution three times in a row.
- Each modification only changes the syntax but doesn't address the core issue.
- The AI starts apologizing and says, "Let me try again."
- You find yourself repeating the same problem.

Once you notice these signals, stop immediately and don't continue.

## 3. How to Cut Off Context and Restart

When the AI is stuck in an infinite loop or experiencing severe hallucinations, the most effective method is to cut off the context and start fresh.

### Why Cut Off Context?

Continuing in a chaotic context is like sinking deeper into quicksand. The AI will be influenced by previous incorrect information and struggle to provide the right answers.

Cutting off the context gives the AI a chance to reboot and start from a clean slate.

### The Correct Way to Cut Off Context

Don't just start a blank conversation and ask questions. The correct approach is:

1) Summarize the current issue

Before starting a new conversation, organize:
- What functionality you want to achieve
- What solutions you've tried
- What specific problems you encountered
- The current state of the code

2) Start a new conversation

In the new conversation, provide complete context:

```markdown
I'm developing a blog system using Next.js 16 + TypeScript + Supabase.
I want to implement an auto-save feature for articles but encountered issues.
I tried using useEffect to listen for content changes, but it caused frequent saves. I also tried debounce, but sometimes data is lost.
Here's my current code: [Paste relevant code]
Please analyze the problem and suggest a solution.
```

3) Request a different approach

Tell the AI that the previous solutions didn't work and ask for a completely different approach:

```markdown
The previous solutions didn't work. Please suggest a completely different implementation.
```

This prevents the AI from repeating past mistakes.

Alternatively, use another AI model to generate different solutions and then ask the AI to execute them.

### When Should You Cut Off Context?

Not all issues require cutting off context. If it's a minor problem, correct it within the current conversation. However, if you encounter these situations, cut off decisively:

- The conversation has gone on for too long (over 20 rounds), and the context is already lengthy. Continuing will only waste money and create more confusion.
- The AI starts confusing concepts, such as mixing up your tech stack or blending different functionalities.
- You feel confused yourself and can't clearly explain the current state. Continuing will only make things worse.
- The "infinite loop" situation mentioned earlier.

In short, when the conversation is out of control, cut it off. Instead of struggling in quicksand, start fresh.

## 4. How to Feed Error Messages to the AI

Often, the AI generates buggy code but isn't aware of it. In such cases, you need to accurately feed the error messages to it.

### Copy the Full Error Message

Don't just say, "The code has an error" or "It doesn't work." Instead, copy the full error message to the AI.

❌ Bad feedback: Your code has an issue and doesn't run.

✅ Good feedback:

```markdown
The code threw an error when running. Here's the error message:
TypeError: Cannot read property 'map' of undefined
    at NoteList (NoteList.tsx:15)
    at renderWithHooks (react-dom.development.js:14985)
Here's the code at line 15:
{notes.map(note => <NoteItem key={note.id} note={note} />)}
```

Providing the full error message helps the AI quickly locate the issue.

### Provide Contextual Code

Besides the error message, provide the relevant code context.

```markdown
Here's the complete code for the component where the error occurred, at line 9:
export function NoteList() {
  const [notes, setNotes] = useState();
  
  useEffect(() => {
    fetchNotes().then(data => setNotes(data));
  }, []);
  
  return (
    <div>
      {notes.map(note => <NoteItem key={note.id} note={note} />)}
    </div>
  );
}
```

This allows the AI to see the full context and provide an accurate fix.

### Explain Reproduction Steps

If the bug is related to user interaction, explain how to reproduce it.

```markdown
This error occurs only under specific conditions:

1. The user enters the page for the first time, and everything works fine.
2. Clicking the 'Refresh' button works fine.
3. However, if the user deletes a note first and then clicks 'Refresh,' the error occurs.

Here's the error message: [Paste error message]
```

Since the AI can't see user actions, detailed reproduction steps help it understand the essence of the problem.

### Use the Browser Console

If the issue is on the frontend of a web page, make good use of the browser console.

Press F12 to open the developer tools, switch to the Console tab, and you'll see:

- Error messages (red)
- Warning messages (yellow)
- Log messages (white)

Screenshot or copy these messages to the AI, helping it find the issue faster.

![](https://pic.yupi.icu/1/image-20260104190230437.png)

If you're unsure whether it's a frontend issue or don't even know what frontend is, it's likely a frontend issue.

## 5. Identifying the Source of the Problem

Sometimes, the issue isn't with the AI but with your requirements or logic itself.

If it's an AI issue, it usually has these characteristics:

- Syntax errors or non-functional code
- Use of non-existent APIs
- Logic clearly inconsistent with your description
- Code style completely inconsistent with previous work

These problems can be solved with better prompts or cutting off context.

However, if it's a logic issue, it usually has these characteristics:

- The code runs but produces incorrect results
- Edge cases aren't handled
- Performance issues
- Poor user experience

These problems require you to rethink the requirements rather than blindly blaming the AI.

### How to Identify the Source of the Problem?

A simple method is to ask yourself: If I gave this requirement to a human developer, could they do it correctly?

If the answer is "unsure" or "they might also have issues," it's likely that the requirement itself isn't clear enough.

In such cases, you should first:

1. Reorganize the requirements
2. Clarify edge conditions
3. Draw flowcharts or state diagrams
4. Write detailed test cases

Then discuss the implementation with the AI.

Some might say: How do I know if a human developer could do it correctly?!

This is also a lack of professional knowledge. If you understand the technology, you'll better control the AI and identify issues. Even if you don't know the answer, try describing your requirements differently or use another AI to refine the requirements and help you make judgments.

## 6. Practical Case: Fixing an Out-of-Control Project

Let me use a real case to demonstrate how to fix an out-of-control project.

### Scenario Description

You're building a to-do app and want to implement drag-and-drop sorting. You've had over a dozen rounds of conversation with the AI, but the functionality still isn't working:

- First attempt: The AI used a non-existent library.
- Second attempt: Switched to react-beautiful-dnd, but the code threw an error.
- Third attempt: Fixed the error, but the data didn't update after dragging.
- Fourth attempt: The data updated, but the UI didn't refresh.
- Fifth attempt: The UI refreshed, but the order was incorrect.
- You start questioning your life...

What would you do next?

### 1. Pause and Analyze

Don't continue! Pause and analyze the problem:

- What's the core issue? (Drag-and-drop sorting)
- Why isn't it working? (Possibly the AI misunderstood state management)
- Is there a simpler solution? (Maybe no library is needed)

### 2. Cut Off Context

Start a new conversation but ask differently:

```markdown
I want to implement a simple drag-and-drop sorting feature. Don't use third-party libraries; use the native HTML5 Drag and Drop API.
Requirements:
1. Users can drag list items.
2. Show a placeholder while dragging.
3. Update the order when dropped.
4. Manage data with useState.
Please provide the simplest implementation first. It only needs to allow dragging; no animations are needed.
```

### 3. Gradually Improve

The AI provides a simple version. You test it and find it works. Great!

Then gradually add features:

1. Great, now add visual feedback while dragging: Make the dragged item semi-transparent.
2. Add a placeholder: Show a dashed box at the target position while dragging.
3. Finally, add smooth animations.

Each step is small and testable, preventing the project from going out of control.

### 4. Summarize Lessons Learned

After solving the problem, ask the AI to summarize:

```markdown
We just implemented the drag-and-drop sorting feature. Please summarize:
1. Why didn't the previous solutions work?
2. What are the key points of this solution?
3. What should we pay attention to when implementing similar features in the future?
```

Add these summaries to your project documentation to avoid repeating mistakes.

## 7. Tips to Prevent Hallucination

Besides fixing issues, we can also take preventive measures.

### 1. Ask the AI to Explain

Don't blindly accept the AI's answers. Ask it to explain why it chose this approach.

- Why did you choose useCallback instead of useMemo?
- What are the pros and cons of this solution?
- Are there other implementation methods?

Through explanations, you can discover whether the AI truly understands the problem.

### 2. Ask for Documentation Links

If the AI mentions an API or library, ask it to provide the official documentation link.

```markdown
You mentioned react-query's useInfiniteQuery. Can you provide the official documentation link?
```

If the AI can't provide a link or the link is wrong, the API might be fabricated.

### 3. Verify Step by Step

Don't implement the entire functionality at once. Verify step by step.

- First, help me implement the core part; use dummy data for the rest.
- Once this step works, move on to the next.

Small, fast steps with verification at each stage help identify issues early.

### 4. Use Type Systems

It's recommended to use TypeScript in projects. It's a programming language that adds type checking to JavaScript, leveraging its type system to prevent issues.

What is a type system?

Simply put, it's about clearly labeling what type of data each variable or function handles. For example, this variable is a number, that variable is a string, and this function returns a user object. With these labels, the editor can detect issues while you're writing code, rather than waiting for runtime errors.

Here's an example:

```ts
// ❌ No type definitions: The AI might generate incorrect code
function calculateTotal(items) {
  return items.reduce((sum, item) => sum + item.price, 0);
}

// If the data format is incorrect, it only throws an error at runtime
calculateTotal([{ name: 'Product' }]); // Runtime error: price is undefined

// ✅ With type definitions: The editor immediately highlights errors
interface Item {
  name: string;
  price: number;
}

function calculateTotal(items: Item[]): number {
  return items.reduce((sum, item) => sum + item.price, 0);
}

// The editor immediately highlights with red squiggly lines: Missing price property
calculateTotal([{ name: 'Product' }]); // Error detected while writing
```

If the generated project is complex, the AI should default to using TypeScript. You can also explicitly ask the AI: Please add complete TypeScript type definitions to all functions and components.

This way, if the AI generates code with type mismatches, the editor will immediately highlight them with red squiggly lines, allowing you to spot and fix issues right away. This is much more efficient than discovering problems at runtime.

### 5. Write Tests

Ask the AI to write test cases:

```markdown
Please write unit tests for this function, covering normal and edge cases.
```

Tests help identify logical issues.

### 6. Let the AI Validate Its Work

Don't just let the AI do the work; make sure it knows how to validate its own work.

For example, when developing a web app, you can ask the AI to open a browser to test the UI, identify issues, and iterate automatically until the functionality works correctly. This creates an automated feedback loop:

```markdown
Please implement this feature and automatically open the browser to test it after completion. If issues are found, please fix them and retest until the functionality works correctly.
```

This approach allows the AI to work more autonomously, reducing manual intervention. It's especially suitable for tasks requiring multiple iterations and is a technique strongly recommended by Claude Code's founder.

## 8. Common Hallucination Scenarios and Solutions

Based on my experience, here are some common hallucination scenarios and solutions.

### Scenario 1: Fabricated APIs

Manifestation: The AI uses an API that sounds reasonable but doesn't exist.

Solution:

```markdown
This API isn't found in the official documentation. Are you sure it exists? Please provide the documentation link.
```

If the AI admits the mistake, ask it to provide the correct API:

```markdown
What's the correct approach? Please implement it using the officially recommended method.
```

### Scenario 2: Outdated Practices

Manifestation: The AI uses deprecated APIs or outdated practices.

Solution:

```markdown
This practice is from an older version. I'm using React 19; please use the latest practices.
```

Then explicitly request:

```markdown
Please use Hooks instead of Class components.
```

### Scenario 3: Confused Tech Stacks

Manifestation: The AI mixes up the usage of different frameworks.

Solution:

```markdown
Wait, you provided Vue's approach, but I'm using React. Please rewrite it using React's approach.
```

Then re-emphasize the tech stack:

```markdown
My project uses React 19 + TypeScript. Please ensure the code aligns with this tech stack.
```

### Scenario 4: Logical Flaws

Manifestation: The code runs but has obvious logical issues.

Solution:

```markdown
This solution has a problem: If the user closes the page during loading, data will be lost. Please consider this edge case.
```

Then request improvements:

```markdown
Please add error handling and data persistence.
```

### Scenario 5: Performance Issues

Manifestation: The code works but performs poorly.

Solution:

```markdown
This solution will be slow with large datasets. Please optimize performance, such as using virtual scrolling or pagination.
```

Then request analysis:

```markdown
Please analyze this solution's time complexity and provide optimization suggestions.
```

## Final Thoughts

AI Hallucination and