← Retour aux guides

Reduce Hallucinations in AI Code Generation

Reducing Hallucinations in Code Generation: A Practical Beginner Guide

AI code generation is powerful, but it can sometimes produce confident-looking code that is wrong, outdated, insecure, or based on APIs that do not exist. These mistakes are often called hallucinations. In coding, hallucinations can appear as invented package names, fake function parameters, incorrect framework behavior, broken edge-case logic, or tests that pass only because they do not actually verify the requirement.

The good news is that hallucinations are not random magic you simply have to accept. You can reduce them with better context, smaller tasks, verification steps, tests, and the right model workflow. This guide explains practical techniques beginners can use immediately, whether you are working in Claude Code, Codex, an OpenAI-compatible SDK, or a custom developer tool.

1. Give the Model the Real Project Context

Many hallucinations happen because the model is guessing. If you ask, “Add authentication to my app,” without showing the folder structure, dependencies, framework version, routes, and database schema, the model may invent whatever seems likely.

Before asking for code, provide relevant files and constraints. Include the package manager, language version, framework version, existing style, database tables, and the exact files the change should touch. For example, instead of asking for “a Stripe webhook,” say which runtime you use, where routes live, how environment variables are loaded, and what library version is installed.

Good prompt pattern: “Here are my package.json dependencies, the current Express route file, and the payment service. Add a Stripe webhook endpoint using the installed Stripe SDK version. Do not introduce new dependencies. If you need information I did not provide, ask before coding.”

2. Ask for a Plan Before Code

A simple way to catch hallucinations early is to request a short implementation plan first. The plan should name the files to edit, the functions to create, and the assumptions being made. This gives you a chance to spot imaginary APIs or wrong architecture before the model generates a large patch.

Use instructions like: “First produce a plan. List assumptions separately. Do not write code until the plan is approved.” This is especially useful for database migrations, authentication flows, caching, deployment scripts, and anything involving security.

3. Force the Model to Use Existing APIs Only

AI models often hallucinate method names because many libraries have similar patterns. To reduce this, tell the model to use only APIs visible in the provided code or official documentation snippets you paste into the prompt. If you are using a tool that can search docs, ask it to cite the exact doc section or version.

You can also add a constraint: “If you are not sure whether a method exists, do not use it. Add a TODO or ask a question.” This small instruction often prevents fake calls such as non-existent ORM methods, deprecated cloud SDK functions, or imagined CLI flags.

4. Break Big Requests into Smaller Tasks

Large prompts produce more opportunities for hallucination. Instead of asking for a full feature with UI, backend, database migration, tests, and deployment configuration at once, split the work into stages.

• Stage 1: inspect the existing code and propose changes.
• Stage 2: update the database schema or types.
• Stage 3: implement backend logic.
• Stage 4: add UI changes.
• Stage 5: write tests and fix failures.

This keeps the model focused and makes each answer easier to review. It also reduces token waste, which matters when you are running many iterations.

5. Make Tests Part of the Prompt

Tests are one of the best hallucination detectors. Ask the model to create or update tests that prove the behavior, not just tests that check a function was called. For example, if the code validates an email verification token, the tests should cover valid tokens, expired tokens, reused tokens, missing users, and database errors.

After generating code, run the actual test suite locally or in CI. If a test fails, paste the exact error output back to the model and ask for a minimal fix. Avoid vague feedback like “it does not work.” Real compiler errors, stack traces, and failing assertions give the model concrete facts instead of room to guess.

6. Prefer Strong Models for Complex Reasoning

Not every coding task needs the most expensive model, but complex debugging, architecture decisions, security-sensitive code, and multi-file refactors benefit from stronger reasoning. A practical workflow is to use a fast, cheaper model for simple edits and a stronger model for planning, review, or difficult failures.

This is where 59API is useful for developers. It provides cheap, pay-as-you-go access to Claude models such as Opus, Sonnet, Haiku, and Fable, as well as GPT models, through an API relay compatible with Claude Code, Codex, and any OpenAI SDK. The base URL is https://api.59api.com, so teams can often switch with minimal configuration changes. Because 59API uses native official-quality models with no downgrade, you can choose the right model for the job while keeping experimentation affordable.

7. Add a Review Pass

After code generation, ask a second model call to review the patch. Use a prompt such as: “Review this diff for hallucinated APIs, missing imports, unsafe assumptions, race conditions, and tests that do not verify behavior. Do not rewrite everything; list concrete issues and fixes.”

This works best when the reviewer sees the diff, relevant dependencies, and test output. You can even use a stronger model for the review pass and a cheaper one for routine implementation. With a low-cost relay like 59API, this two-step workflow becomes easier to justify because extra review calls are less expensive.

8. Keep a Project Instruction File

Create a short project instruction file for your AI coding tool. Include naming conventions, preferred libraries, forbidden dependencies, test commands, build commands, deployment constraints, and security rules. For example, “Use Zod for validation,” “Do not use moment.js,” “Run npm test and npm run typecheck,” and “Never log access tokens.”

Consistent instructions reduce repeated mistakes and help the model stay aligned with your codebase. This is especially helpful when multiple developers use the same AI assistant.

A Reliable Workflow to Start With

• Provide the relevant files, versions, and constraints.
• Ask for a plan and assumptions before code.
• Generate a small patch, not a whole feature at once.
• Run tests, type checks, linters, and builds.
• Paste exact errors back for targeted fixes.
• Use a separate review pass for hallucinated APIs and logic gaps.
• Choose stronger models for harder reasoning and cheaper models for simple edits.

Reducing hallucinations is not about finding one perfect prompt. It is about building a workflow that gives the model facts, limits guessing, and verifies outputs with real tools. If you want to test this workflow affordably across Claude and GPT models, consider signing up for 59API and pointing your Claude Code, Codex, or OpenAI SDK setup to https://api.59api.com. The pay-as-you-go pricing, low-cost relay model, official-quality native models, and referral rebate make it a practical choice for developers who iterate often.

AI-generated code should be treated like a junior developer’s pull request: useful, fast, and worth reviewing. With clear context, tests, smaller tasks, and smart model selection, you can get the productivity benefits while dramatically reducing hallucinated code.

Tarifs · Docs