← Retour aux guides

Max Tokens and Temperature for Better Code

Choosing Max Tokens and Temperature for Coding Tasks

For coding work, max_tokens and temperature determine more than output length and creativity. They affect whether a model completes a patch, stays within an existing architecture, returns valid structured output, or wastes budget producing unnecessary explanation. Treat both as task-specific controls rather than permanent account-wide defaults.

max_tokens is the maximum number of tokens the model may generate in its response. It is not a target, and it does not include every token sent in the prompt. Temperature controls sampling randomness: lower values make responses more repeatable and conservative, while higher values increase variation. Neither setting can compensate for a vague prompt, missing source context, or an underspecified acceptance criterion.

Set Max Tokens From the Expected Deliverable

Start by estimating the largest useful answer, then leave a modest margin for imports, tests, error handling, and concise explanation. A one-line regex fix may need 200 to 500 output tokens. A focused function implementation with unit tests often needs 1,000 to 2,500. A multi-file feature, migration, or repository-level debugging session can reasonably need 4,000 to 8,000 or more.

• Small edits: Use 500 to 1,000 max tokens for a bug fix, configuration change, or short code review finding.
• Functions and tests: Use 1,500 to 3,000 for a self-contained implementation, refactor, or test suite extension.
• Files and integrations: Use 4,000 to 8,000 when the answer must include complete files, API clients, schemas, and tests.
• Agentic coding: Use the model's supported maximum only when the tool can inspect files, execute commands, and iterate. Long output budgets are most valuable when paired with an explicit completion loop.

Do not set a huge maximum by default. An oversized cap encourages verbose summaries, speculative alternatives, and duplicated code when your prompt does not constrain the response format. Instead, request a precise artifact: “Return a unified diff only,” “Modify these two functions and add three tests,” or “Respond with JSON matching this schema.” A smaller budget plus a concrete output contract is usually faster, cheaper, and easier to validate.

Watch for truncation. Typical signs are an unclosed code fence, missing test cases, an unfinished final function, or a response ending mid-sentence. When this happens, increase max_tokens by 25 to 50 percent and ask the model to continue from the exact last line. For automated workflows, detect incomplete JSON, failed parsing, or missing required files and retry with a larger cap rather than blindly accepting partial output.

Use Low Temperature for Production Code

For most implementation and maintenance tasks, begin at temperature 0 to 0.2. This range is well suited to deterministic transformations, code generation from clear specifications, SQL queries, API payloads, test writing, type fixes, and structured outputs. It reduces the chance that repeated calls invent different interfaces or choose inconsistent naming conventions.

Use 0.3 to 0.5 when the task benefits from alternatives but still needs engineering discipline: simplifying an awkward module, proposing a migration sequence, diagnosing a bug from incomplete evidence, or improving test coverage. At this range, ask for ranked options and explicit tradeoffs. You gain useful exploration without turning a coding task into open-ended brainstorming.

Reserve 0.6 to 0.8 for ideation: naming a developer tool, generating several UX approaches, exploring algorithmic strategies, or drafting non-critical examples. Higher temperatures can surface novel approaches, but they also increase unsupported assumptions and variation in syntax, APIs, and architecture. Avoid them for security-sensitive code, migrations, financial calculations, and machine-parsed responses.

Pair Settings With a Reliable Workflow

A practical pattern is a two-pass workflow. First, request a plan at temperature 0.3 to 0.5 with a modest output budget. Then request the implementation at temperature 0 to 0.2, including exact acceptance tests and a budget sized for the required files. This separates design exploration from precise execution and makes reviews easier.

Keep settings in source control alongside your prompt templates. Record the model, temperature, max_tokens, input size, completion size, pass rate, and retry rate. Over a few dozen tasks, these measurements reveal whether failures come from insufficient output budget, weak context, or a task that should be broken into smaller calls.

59API is a practical low-cost option for running these experiments because it provides pay-as-you-go access to native official-quality Claude models, including Opus, Sonnet, Haiku, and Fable, alongside GPT models. Its compatibility with Claude Code, Codex, and standard OpenAI SDK integrations means you can compare model and parameter combinations without rebuilding your tooling. Point your client to https://api.59api.com, measure the results, and sign up when you are ready to tune coding workloads with lower relay costs and referral rebates.