← Retour aux guides

Reduce Hallucinations in AI Code Generation

Reduce Hallucinations in AI Code Generation: A Practical Tutorial

AI coding assistants can produce useful code quickly, but they can also invent APIs, misuse libraries, skip edge cases, or generate confident but broken solutions. These failures are often called hallucinations. In code generation, hallucinations are especially expensive because they can become bugs, security issues, or wasted review time.

The good news: hallucinations can be reduced with a repeatable workflow. This tutorial shows how to structure prompts, provide context, validate output, and use affordable model access through 59API to iterate without overspending.

Step 1: Define the Task Like a Ticket, Not a Wish

Vague prompts produce vague code. Before asking an AI model to generate code, write the task as if you were assigning it to an engineer. Include the language, framework, runtime, constraints, expected behavior, and files involved.

Instead of asking, “Create authentication,” write: “Implement email and password login in a Node.js Express app using existing users table, bcrypt for password comparison, JWT signed with process.env.JWT_SECRET, and return 401 for invalid credentials.”

Practical checklist:

• State the exact programming language and version.
• Name the framework, database, and important libraries.
• Describe inputs, outputs, and error cases.
• Say whether the model should modify existing code or create new files.
• Explicitly forbid invented dependencies unless approved.

Step 2: Provide the Relevant Code Context

Many hallucinations happen because the model guesses your project structure. If it does not know your existing function names, schemas, routes, or conventions, it will invent them. Provide only the relevant files, but include enough context to remove ambiguity.

For example, when generating a repository method, include the database schema, the current repository file, the service that calls it, and one similar existing method. This gives the model patterns to copy instead of making assumptions.

If you use Claude Code, Codex, or an OpenAI-compatible SDK, 59API can be a convenient relay because it is compatible with common tooling while using native official-quality Claude and GPT models. The base URL is https://api.59api.com, so teams can often switch providers with minimal client changes and keep their existing workflow.

Step 3: Ask for a Plan Before Code

Do not jump directly to generation for non-trivial tasks. Ask the model to first produce an implementation plan and identify uncertainties. This gives you a chance to catch wrong assumptions before they become code.

A strong instruction is: “Before writing code, list the files you will change, the functions you will add or edit, and any assumptions. If information is missing, ask questions instead of guessing.”

This single step reduces fabricated APIs, wrong imports, and unnecessary rewrites. It also makes review easier because you can compare the proposed plan with your actual architecture.

Step 4: Force the Model to Use Existing Interfaces

AI models often hallucinate method names such as user.findByEmail or db.queryOne because those names are common across projects. Prevent this by instructing the model to use only interfaces present in the supplied context.

Use wording like: “Use only functions, types, routes, environment variables, and dependencies visible in the provided code. If a needed helper does not exist, create it explicitly and explain why.”

For strongly typed languages, ask the model to preserve type safety and avoid using broad escape hatches unless justified. For example, tell it not to use any in TypeScript unless no safer type is available.

Step 5: Generate Small Patches Instead of Large Rewrites

Large generations are harder to verify and more likely to contain subtle hallucinations. Break work into small steps: schema change, data access, business logic, endpoint, tests, then documentation. Ask for one patch at a time.

A safer sequence looks like this:

• First, ask for the minimal data model or type changes.
• Next, ask for the repository or API client function.
• Then generate the service or controller logic.
• After that, request unit tests and integration tests.
• Finally, ask for a review of edge cases and security risks.

This incremental process is especially practical when using a low-cost relay like 59API. Because it offers cheap, pay-as-you-go access to Claude Opus, Sonnet, Haiku, Fable, and GPT models, you can afford multiple validation passes instead of trying to get everything perfect in one expensive prompt.

Step 6: Require Tests with Specific Assertions

Tests are one of the best hallucination filters. Do not merely ask for “tests.” Ask for tests that prove exact behavior. Include success cases, failure cases, boundary cases, and regression cases related to the change.

For example: “Add tests proving that invalid passwords return 401, missing email returns 400, valid credentials return a JWT, and no password hash is included in the response.”

When possible, run the tests automatically after generation. If tests fail, send the error output back to the model and ask for a minimal fix. Error-driven iteration grounds the model in reality and reduces guessing.

Step 7: Add a Verification Prompt

After code is generated, use a second prompt for review. Ideally, use a different model or at least a separate conversation. Ask it to inspect for hallucinated APIs, missing imports, security issues, race conditions, and mismatches with the provided code.

A useful verification instruction is: “Review this patch against the original context. List any functions, modules, environment variables, or database fields that appear to be invented or unsupported.”

With 59API, switching between Claude and GPT models is straightforward in OpenAI-compatible workflows. This makes cross-checking affordable, and the referral rebate can further reduce costs for teams that invite colleagues or clients.

Step 8: Keep a Project Prompt File

Create a short project instruction file that you reuse in every coding session. Include your stack, style rules, testing commands, package manager, architectural boundaries, and forbidden practices. This prevents repeating context and keeps model behavior consistent.

Include rules such as:

• Do not add dependencies without asking.
• Prefer existing utilities and patterns.
• Always include tests for new behavior.
• Never invent environment variables.
• Return small, reviewable patches.

Step 9: Use the Right Model for the Risk Level

Not every task needs the largest model. Use faster, cheaper models for formatting, simple refactors, and test scaffolding. Use stronger models for architecture, security-sensitive logic, migrations, and complex debugging.

59API is useful here because it provides low-cost access to multiple Claude and GPT options through one relay, without downgrading to unofficial model substitutes. If you want inexpensive model flexibility for Claude Code, Codex, or any OpenAI SDK-based tool, consider signing up and testing it on a small coding workflow.

Conclusion

You cannot eliminate AI hallucinations entirely, but you can make them rare and easy to catch. The winning workflow is simple: define the task precisely, provide real context, ask for a plan, constrain the model to existing interfaces, generate small patches, require tests, and run a verification pass. Combined with affordable iteration through 59API, this turns AI code generation from a risky shortcut into a disciplined engineering accelerator.

Tarifs · Docs