← Voltar aos guias

A Practical Method to Reduce Code AI Hallucinations

Why Code Models Hallucinate

AI coding assistants rarely invent code at random. Most incorrect answers come from missing context, ambiguous requirements, outdated assumptions, or pressure to produce a complete solution before the repository has been inspected. A model may confidently call a function that does not exist, use the wrong framework version, or silently change behavior outside the requested scope.

The practical solution is to make code generation a constrained engineering workflow. Give the model the right evidence, require explicit assumptions, and verify every meaningful change with tools.

1. Define a Small, Testable Task

Start with one behavioral change instead of asking for an entire feature. Include the relevant file paths, current behavior, expected behavior, constraints, and acceptance tests. A useful request might look like this:

Prompt: Update src/auth/session.ts so expired sessions return HTTP 401. Preserve the existing cookie format and error response. First inspect the current implementation and tests. State which files you will change, then implement the smallest patch. Add a test for an expired session and run the auth test suite.

This prompt reduces hallucinations because it limits the solution space. Asking the model to inspect before editing also prevents it from guessing the project structure.

2. Separate Planning from Editing

Use a two-pass interaction. In the first pass, ask for a short plan containing relevant files, dependencies, assumptions, and verification commands. Review that plan for invented paths or APIs. In the second pass, allow the model to edit only after the plan matches the repository.

For larger tasks, explicitly require uncertainty reporting:

Prompt: If the repository does not provide enough evidence for a decision, do not invent an API. Mark the assumption, identify the missing file or documentation, and ask one focused question.

This is more reliable than simply telling a model to be accurate. It gives the model a valid response when the available context is incomplete.

3. Supply Grounded Repository Context

Context should be relevant, current, and small enough to inspect. Provide the target file, its imported interfaces, nearby tests, package versions, and a representative caller. Avoid pasting the entire repository, which increases distraction and can expose conflicting implementations.

For a dependency question, include the actual package manifest rather than saying “we use the latest version.” For an API change, include the type definition and one successful request. Prefer repository search results and test output over memory-based explanations.

• Include exact file paths and line-level behavior.
• Provide existing tests before requesting new tests.
• State which files are out of scope.
• Ask the model to quote the evidence supporting important decisions.

4. Use a Low-Cost Model Loop

You can run this workflow through 59API, which provides pay-as-you-go access to Claude Opus, Sonnet, Haiku, Fable, and GPT models through one compatible relay. Its base URL is https://api.59api.com, and it works with Claude Code, Codex, and OpenAI SDK integrations.

For example, an OpenAI-compatible Python client can be configured like this:

from openai import OpenAI

client = OpenAI(api_key="YOUR_59API_KEY", base_url="https://api.59api.com")

response = client.chat.completions.create(model="gpt-4o-mini", messages=[{"role": "user", "content": prompt}])

Use an inexpensive model for repository summarization, file discovery, and first-pass test generation. Escalate only ambiguous design work or difficult debugging to a stronger Claude or GPT model. Because 59API uses native official-quality models rather than downgraded substitutes, this routing can reduce cost without forcing every task through the most expensive option.

5. Make Verification Mandatory

Never treat a plausible patch as a correct patch. Ask the model to run the narrowest relevant checks first, then broader checks if the change affects shared code. Typical verification includes type checking, linting, unit tests, integration tests, and a review of the final diff.

A useful completion rule is:

Do not claim the task is complete until the tests have run. Report the exact command, result, failures, and any checks that could not be executed.

You can also ask for adversarial tests: empty input, malformed input, permission failures, timeouts, duplicate requests, and boundary values. These cases expose confident but incomplete implementations faster than a happy-path test alone.

6. Review the Diff, Not the Explanation

Explanations can sound convincing even when the code is wrong. Review the actual diff for unrelated edits, changed public behavior, missing error handling, unsafe defaults, and tests that merely reproduce the implementation. Keep commits small so a reviewer can connect each line to the acceptance criteria.

For a practical, low-cost starting point, sign up for 59API and use its referral rebate while building this inspect, constrain, generate, and verify loop. The reliability comes from the process; the relay helps you run that process economically across the models you already use.

Preços · Docs