如何防止 AI 重複犯錯：從持久規則到自動驗證

Introduction

Artificial Intelligence (AI) is getting smarter, faster, and more capable every day. Yet, despite all this progress, one frustrating problem remains: AI can repeat the same mistake even after you have corrected it.

You point out an error, explain the correct approach, and ask the AI to fix it. It agrees, makes the correction, and then commits the exact same mistake in the next response.

Sound familiar?

The problem is not always that AI fails to understand your correction. Often, the real issue is that the correction does not become a persistent rule that influences future decisions.

So, how do we prevent AI from repeating its own mistakes? The answer lies in better context management, explicit rules, memory systems, automated validation, and feedback loops.

1. Understand Why AI Repeats Mistakes

Before fixing the problem, we need to understand its causes.

A. AI does not automatically learn from every correction

Many AI systems generate responses using the current conversation, their trained model, and any available memory or external tools. Correcting an answer in a conversation does not automatically update the model's underlying parameters.

For example, suppose you ask an AI to build a FastAPI application and explicitly request a self-executing startup line. The AI provides the code but forgets the startup line in the next script.

Even though you corrected it previously, that correction may not be available or sufficiently prominent in the next context.

B. The AI loses important context

Long conversations can contain hundreds of instructions, corrections, and decisions. Some systems may truncate or summarize older context, causing important details to disappear.

C. Instructions are too vague

Telling AI to "avoid this mistake" is less effective than specifying exactly what it must do.

Compare these instructions:

• Weak: "Don't forget the startup command."
• Strong: "For every standalone FastAPI script, include a self-executing entry point at the end unless the user explicitly requests a different execution method. Validate that the entry point matches the application's configuration."

The second instruction defines both the rule and its scope.

D. AI does not verify its own output

AI can produce an answer that sounds correct without actually checking whether it satisfies every requirement.

Without tests, constraints, or external validation, the same error can survive multiple rounds of correction.

2. Turn Every Repeated Mistake Into a Permanent Rule

One of the most effective strategies is to convert corrections into reusable instructions.

Instead of correcting an individual response repeatedly, create a rule that can be applied to future responses.

For example:

Mistake: AI repeatedly generates incomplete Python scripts.

Correction rule:

• Include all required imports.
• Define the complete application logic.
• Handle expected errors.
• Include execution instructions.
• Add a self-executing entry point when required.
• Check that the code meets the user's stated requirements before presenting it.

Store these rules in an appropriate place, such as project instructions, a system prompt, a persistent memory feature, or a version-controlled configuration file.

Important: A rule is only as persistent as the system storing and applying it. Conversation history alone is not a reliable permanent memory system.

3. Build an AI Mistake Log

Humans learn from documented mistakes. AI applications can use a similar approach by maintaining a structured record of past failures.

A mistake log might look like this:

Whenever a recurring mistake occurs, record the failure, its cause, the correct solution, and a test that detects it.

This is more useful than storing a vague instruction such as "be more accurate."

However, the system should not blindly save every correction. A correction may be temporary, specific to one project, or based on an incorrect assumption. Review important rules before making them permanent.

4. Use Retrieval-Augmented Generation (RAG)

Retrieval-Augmented Generation, or RAG, allows an AI system to retrieve relevant information from an external knowledge source before generating a response.

Instead of expecting an AI to remember every past correction, you can store approved rules and examples in a searchable database.

A typical workflow is:

1. The user submits a request.
2. The system identifies relevant past mistakes and rules.
3. A retrieval mechanism searches the knowledge base.
4. The retrieved rules are added to the AI's context.
5. The AI generates a response.
6. A validation step checks the response for known errors.

For instance, a coding assistant could retrieve a project rule requiring a particular API structure before generating a new endpoint.

RAG is especially useful when the knowledge base is large, rules change frequently, or multiple AI agents need access to the same information.

However, retrieval is not a guarantee. Poor search results, irrelevant documents, or conflicting instructions can still cause failures.

5. Add Automated Validation Instead of Trusting AI

Here is a simple principle:

Do not rely on AI to promise that it will not make a mistake. Build a system that catches the mistake if it does.

For software development, this could mean:

• Running unit tests.
• Checking types and schemas.
• Using linters and formatters.
• Validating API responses.
• Checking security constraints.
• Running regression tests against previously fixed bugs.

Suppose an AI repeatedly creates an endpoint that returns the wrong response format. Rather than repeatedly asking it to remember the correct format, write a test that fails whenever the response violates the required schema.

The AI can then revise its code based on the test results.

This creates a feedback loop:

Generate → Test → Detect → Correct → Retest

For high-impact applications, automated checks should be combined with human review. A passing test suite does not prove that software is entirely correct; tests only cover the conditions they actually check.

6. Use Negative Examples and Counterexamples

Sometimes, explaining the correct solution is not enough. The AI also needs to understand what a failure looks like.

Provide both a bad example and a good example.

Bad instruction:

"Make sure the code is complete."

Better instruction:

"Do not return a standalone FastAPI script that defines an application but omits its required execution entry point. Include the entry point and verify that the configured application variable exists."

This technique is particularly useful for formatting requirements, coding conventions, data extraction, and repeated structural errors.

Counterexamples help define the boundaries of acceptable behavior, but they should be specific and representative rather than an enormous collection of unrelated prohibitions.

7. Use a Verification Checklist Before Every Response

A simple checklist can prevent many recurring mistakes.

Before an AI returns its answer, it should verify:

• Does the output satisfy every explicit requirement?
• Have previously identified mistakes been avoided?
• Are all necessary components included?
• Do the facts, calculations, or code have supporting evidence or tests?
• Are there conflicting instructions?
• Has the output been checked using an appropriate validation method?

For coding tasks, this verification should ideally be performed by actual tools, not just another AI-generated statement claiming that the code is correct.

For research tasks, use reliable sources. For calculations, use a calculator or executable code. For structured outputs, use schema validation.

Different mistakes require different verification mechanisms.

8. Create a Feedback Loop That Improves Over Time

A reliable AI system should not treat every correction as an isolated event.

Instead, use a continuous improvement process:

1. Detect: Identify a mistake.
2. Classify: Determine whether it was caused by missing context, faulty reasoning, outdated information, or an execution failure.
3. Correct: Establish the right solution.
4. Record: Store the correction in an appropriate knowledge base.
5. Prevent: Add a rule, test, or validation step.
6. Evaluate: Check whether the same error occurs again.
7. Refine: Improve the prevention mechanism if the error returns.

The critical step is prevention. Fixing the current output is not enough if the system remains vulnerable to the same failure.

For more advanced applications, developers can track error rates, recurring failure categories, regression-test results, and the effectiveness of different prevention strategies.

9. Choose the Right Solution for Your AI System

Not every problem requires a sophisticated architecture.

For most developers, the best starting point is not fine-tuning a model. It is combining clear instructions, a small set of approved rules, automated tests, and a reliable feedback loop.

Fine-tuning can help with consistent behavioral patterns, but it is not a substitute for external memory, current facts, or runtime validation.

10. The Future: AI That Learns From Its Own Failures

The long-term goal is not simply to create AI that apologizes for mistakes. It is to create AI systems that systematically reduce the probability of repeating them.

Such systems could identify recurring errors, retrieve relevant corrections, propose new tests, evaluate their effectiveness, and update approved rules under controlled conditions.

For safety and reliability, these updates should be evaluated before deployment. Otherwise, an incorrect correction could become a permanent rule and cause even more failures.

The distinction is important: a system that remembers mistakes is not necessarily a system that learns from them. Learning requires evidence that the correction improves future performance.

Conclusion

Preventing AI from repeating its own mistakes requires more than telling it to try harder.

The most effective approach combines persistent instructions, structured mistake logs, relevant memory retrieval, automated validation, and continuous evaluation.

Start small. Identify the mistakes that occur most frequently, document their causes, and build a mechanism that detects them before they reach the user.

If an AI repeatedly makes the same mistake, stop relying on repeated corrections. Fix the process that allows the mistake to happen.

The real measure of an intelligent system is not whether it can apologize for an error. It is whether the system can demonstrate that the error becomes less likely to happen again.