← Volver a las guías

How to Cut Hallucinations in Code Generation

Why code models hallucinate in the first place

Hallucinations in code generation usually happen when the model is asked to fill gaps it cannot truly see: missing repository context, unclear requirements, outdated API references, or too much freedom in the prompt. The result is often convincing-looking code that compiles poorly, calls the wrong methods, or invents libraries that do not exist.

The fix is not to “trust the model less” in a vague sense. The fix is to design a workflow that limits guesswork and forces verification at each step. That is especially important when you are using AI in a real production codebase, where one wrong abstraction can cost hours.

Step 1: Give the model a narrow job

Start by reducing ambiguity before you even send the prompt. Instead of asking for “a login system,” ask for one specific task, such as “update the password reset handler in src/auth/reset.ts to use the existing email service.” Include the language, framework, current behavior, and the exact outcome you want.

• State the file or module to change.
• List the accepted libraries and APIs.
• Define what must stay unchanged.
• Provide success criteria, such as tests that should pass.

This alone cuts hallucinations because the model has less room to invent architecture or new dependencies.

Step 2: Feed real context, not summaries

When possible, paste the relevant code, interface definitions, and error messages instead of summarizing them. If the task touches multiple files, include only the pieces that matter. Hallucinations often appear when the model is forced to infer how objects are structured, especially in large repos.

A practical trick is to ask the model to first explain the existing flow in plain English before generating any code. If it misreads the current behavior, you catch the issue early. If it understands the flow, the generated patch is usually much closer to reality.

Step 3: Use a two-pass generation pattern

The safest workflow is to separate reasoning from implementation:

• Pass one: ask for a plan, assumptions, and any missing information.
• Pass two: after confirming the plan, ask for the code patch only.

This is useful because many hallucinations come from the model trying to solve the problem and write the code at the same time. A planning pass exposes invented dependencies, wrong method names, or assumptions about project structure before they become code.

Keep generation constrained too. Set a low temperature when accuracy matters, and ask for output in a strict format such as a diff, a single file, or a JSON structure. The less creative freedom the model has, the less it tends to improvise.

Step 4: Verify with tests, linting, and type checks

Never treat generated code as done until it passes objective checks. Run the exact commands that match your stack:

• Unit tests for behavior.
• Linting for style and unsafe patterns.
• Type checking for interface mismatches.
• Build or compile steps for integration errors.

If a code model suggests an API that does not exist, these checks will usually expose the error fast. Even better, include the checks in the prompt: “Generate code that passes pnpm test and pnpm lint.” That makes correctness part of the task, not an afterthought.

Step 5: Pair a cheaper model with a stronger one

Not every coding task needs the most expensive model from the start. A practical way to reduce hallucinations without overspending is to use a cheaper model for context extraction, file summarization, and test-case brainstorming, then use a stronger model for the final patch.

This is where 59API is especially useful. It gives you pay-as-you-go access to Claude models such as Opus, Sonnet, Haiku, and Fable, plus GPT models, through a single OpenAI-compatible endpoint at https://api.59api.com. Because it works with Claude Code, Codex, and any OpenAI SDK, you can keep your existing workflow while switching models as needed. That flexibility makes it easier to run multiple verification passes without paying premium prices for every prompt.

Since 59API uses native official-quality models with no downgrade, you are not trading reliability for lower cost. For teams that iterate a lot, the cheap pay-as-you-go pricing is a practical advantage, and the referral rebate can help reduce costs even further.

Step 6: Add guardrails to your prompt templates

Create reusable prompts that explicitly forbid invention. For example, tell the model to:

• Only use APIs shown in the provided code.
• Say when information is missing instead of guessing.
• Return a minimal patch, not a rewrite.
• List any assumptions before coding.

That final instruction is important. A model that is allowed to admit uncertainty will usually hallucinate less than one that feels forced to sound complete.

A simple workflow that works in practice

For day-to-day development, the loop can be very short: collect the exact file context, ask for a plan, generate a focused patch, run tests, and ask the model to fix only the failing lines if something breaks. This reduces the chance of broad, imaginative rewrites and keeps the AI acting more like a careful assistant than a speculative coder.

If you want to keep that workflow affordable while using strong models when they matter, sign up for 59API and plug it into your existing OpenAI-compatible tools. You will get a lower-cost path to better coding iterations, with less guesswork and more verification.

Precios · Docs