← Voltar aos guias

Reduce Code Hallucinations Without Overspending on AI

Optimize for accepted code, not cheap tokens

Code-generation hallucinations include invented methods, nonexistent packages, unsupported configuration options, and incorrect assumptions about your repository. They waste money twice: first on the generated answer, then on debugging and replacement attempts.

The useful cost metric is total workflow cost per accepted patch, not price per million tokens alone. An accepted patch should compile, pass relevant tests, and satisfy the requested behavior. Start by tracking model spend, validation failures, retries, and developer review time for each task.

1. Supply evidence instead of the whole repository

A model cannot reliably infer your installed dependencies from a feature description. Before requesting code, collect the package manifest, resolved dependency versions, relevant interfaces, one nearby implementation, and the failing test or exact error. For library-specific changes, include documentation matching the installed version.

For example, a TypeScript task might need 150 lines from the target module, its imported types, and two existing tests—not 30 unrelated files. Aim initially for a 4,000-token task packet, then expand only when necessary. This is a budgeting starting point, not a universal context limit.

• State the runtime, framework, and exact package versions.
• List allowed files and prohibit new dependencies unless approved.
• Require the model to identify missing evidence rather than invent an API.
• Request a minimal patch and tests, not a rewritten application.

Less irrelevant context reduces input spend and makes the evidence easier to inspect. However, removing essential types or call sites can increase mistakes, so optimize relevance rather than token count alone.

2. Make uncertainty explicit before generating code

Use a short instruction such as: “Use only APIs supported by the supplied types or documentation. If a required symbol cannot be verified, name it and ask for the missing source. Do not fabricate imports.”

For unfamiliar integrations, request a brief list of proposed symbols and supporting file locations before implementation. Verify those references; a model can hallucinate citations too. Avoid demanding lengthy explanations for routine edits. Spend output tokens on the patch, assumptions, and focused tests.

3. Reject bad patches with deterministic checks

Run validation in a disposable workspace with credentials removed and network access restricted. Generated code is untrusted, even when it looks plausible. For a TypeScript project, start with the repository's existing type-check command, lint command, and targeted test runner.

• Check imports: confirm packages exist in the lockfile and exported symbols exist in installed declarations.
• Check behavior: test a normal case, an error case, and a boundary condition.
• Check test quality: avoid mocks that merely reproduce the generated implementation's assumptions.
• Check scope: flag unrelated edits, dependency additions, and disabled assertions.

Return the exact failing output for one repair attempt. Do not repeatedly send the entire conversation. If the same failure persists, retrieve better evidence or escalate the task rather than funding an open-ended retry loop.

4. Route by difficulty: a $81 versus $17.50 example

The following rates are illustrative, not a 59API price quote. Suppose a higher-cost model charges $3 per million input tokens and $15 per million output tokens. A 12,000-input, 3,000-output attempt costs $0.081. Across 1,000 tasks, that is $81 before retries.

Now start every task with a lower-cost model at assumed rates of $0.50 input and $2 output per million tokens. With 4,000 input and 1,000 output tokens, each attempt costs $0.004: $4 for 1,000 tasks.

If validation sends 25% of tasks to the higher-cost model, each escalation using 8,000 input and 2,000 output tokens costs $0.054. Those 250 escalations add $13.50, bringing model spend to $17.50—about 78% less. This excludes test infrastructure and human review; the escalation rate must be measured, not assumed in production.

5. Lower the access cost without weakening verification

59API provides low-cost, pay-as-you-go access to Claude and GPT models through https://api.59api.com, with native official-quality models rather than downgraded substitutes. Its compatibility with Claude Code, Codex, and OpenAI SDKs makes it practical to test model routing within existing workflows. Compatibility does not mean every model supports identical parameters or features.

Check current model prices, track actual token usage, and evaluate any referral rebate separately from baseline savings. If this workflow fits your stack, consider signing up for 59API and benchmarking 50 representative tasks. Keep the route that delivers the lowest cost per verified patch—not simply the cheapest first answer.

Preços · Docs