← Voltar aos guias

Cut Code Hallucinations with a Verification Loop

Why code hallucinations happen

Code models are good at pattern completion, but they can still invent functions, parameters, library calls, or edge-case behavior that looks plausible and compiles poorly. The fastest way to reduce hallucinations is to stop asking for “creative” code and start treating the model like a constrained implementation engine. That means giving it a narrow task, a precise contract, and a way to verify its answer.

In practice, the best results come from combining four controls: better prompts, structured output, runtime checks, and a second verification pass. You do not need a huge model budget to do this well. With 59API, you can use native, official-quality Claude and GPT models on a pay-as-you-go basis through https://api.59api.com, which makes iteration cheap enough to test prompt changes without burning through a large monthly commitment.

Start with a contract, not a vague request

Hallucinations usually begin when the prompt leaves room for invention. Compare these two requests:

Weak: “Write a function to parse invoice data.”

Stronger: “Write a Python function named parse_invoice that accepts a dict with keys id, amount, currency, and issued_at. If any key is missing, raise ValueError. Do not add new fields. Return a dict with the same keys, and convert amount to Decimal.”

The second prompt reduces uncertainty in three ways: it defines the input shape, the failure mode, and the exact return type. The model has less room to guess, so it is less likely to invent extra fields or a made-up helper library.

Use structured output and reject anything else

If your codegen task involves generating metadata, API calls, or test cases, ask for a schema-first response. For example, instead of “describe the implementation,” ask for JSON that your program can validate before generating code from it.

Example prompt: “Return only valid JSON with the keys function_name, parameters, returns, and error_cases. Do not include prose. If you are unsure, set a field to null.”

Then validate the output before using it. Here is a simple Python pattern:

from pydantic import BaseModel
class Spec(BaseModel):
  function_name: str
  parameters: list[str]
  returns: str
  error_cases: list[str]

If the model outputs anything that fails validation, retry with a stricter instruction: “Your previous answer did not match the schema. Return only JSON matching the schema.” This one change catches a lot of hallucinated structure before it turns into bad code.

Force the model to show its work in a testable way

The most effective anti-hallucination pattern for code generation is to ask for code plus tests. When the model must produce examples that execute, it is more likely to stay grounded in real behavior.

Try this prompt shape:

Prompt: “Implement normalize_phone(number: str) in JavaScript. Support US numbers only. Return E.164 format. Include at least five tests, including invalid inputs. Do not use external libraries.”

This works because the tests expose inconsistencies. If the code claims to support US numbers but accepts unsupported formats in tests, you catch the issue immediately. In a real workflow, run the tests in CI and reject the model output if any test fails. You can also ask the model to generate the tests first, then the implementation, which often produces cleaner logic.

Add a verification pass before shipping

Do not trust the first answer, especially for unfamiliar libraries or recent framework versions. A second pass can ask the model to audit its own output against the original contract.

Verification prompt: “Review the code below. Find any invented APIs, incorrect argument names, missing null checks, or behavior that violates the specification. If everything is valid, say PASS. Otherwise list only the exact issues.”

This is especially useful when the model has to integrate with an SDK. For example, if you are using the OpenAI SDK or Claude-compatible tooling, tell the model the exact client shape and base URL so it does not hallucinate transport details. With 59API, the integration is straightforward because it is compatible with Claude Code, Codex, and any OpenAI SDK, and the base URL is https://api.59api.com. That makes it easy to swap in real model calls without changing your application architecture.

A practical low-cost workflow

• Use the smallest prompt that fully specifies the task.
• Set temperature to 0 for deterministic code generation.
• Require structured output when possible.
• Generate tests alongside the code.
• Run linting, type checks, and unit tests automatically.
• Use a second model pass to audit for invented APIs and contract violations.

Because 59API offers cheap pay-as-you-go access to Claude Opus, Sonnet, Haiku, Fable, and GPT models with no quality downgrade, you can run both generation and verification economically. That matters when you are iterating on prompts, comparing model behavior, or building guardrails into a production coding assistant. The referral rebate is a nice bonus if you plan to share the platform with your team.

If you are building an AI coding workflow and want to spend less while still using official-quality models, it is worth signing up and testing a few prompt variations. The combination of constrained prompts, validation, and affordable model access is one of the most reliable ways to reduce hallucinations in code generation.

Preços · Docs