Stop Over-Prompting GPT-5.6: Why Leaner Instructions Deliver Better Results

Working with GPT-5.6 is like onboarding a brilliant but impatient new hire. The more you try to micromanage every step, the more likely it is to go off the rails. Instead of spending hours writing lengthy system prompts, focus your energy on clarifying the outcome and defining the stopping conditions.

Earlier this year, OpenAI rolled out GPT-5.6. Our team immediately migrated our internal coding-agent pipeline to test it out. The results were counterintuitive: our old, verbose prompts—the ones that worked perfectly fine on GPT-5.5—actually hurt performance. When we stripped down the system prompts to the bare essentials, our evaluation scores jumped by roughly 10–15%, while token usage dropped by 41–66% and costs fell by 33–67%.

This data completely overturned our default assumption: that the more detailed the instructions, the better the model performs. With GPT-5.6, the exact opposite is true.

The Golden Rule: Define the Destination, Not the Path

Let’s cut straight to it. The best prompt for GPT-5.6 has one sentence at its core: Clearly state the outcome, the hard constraints, the available evidence, and the completion criteria—then get out of the way and let the model choose the execution path.

Traditional prompting is “hand-holding”—telling the model what to do first, then second, then third, and how to judge each step. For GPT-5.6, this style is actively obstructive. It has its own reasoning and planning capabilities. The detailed roadmap you provide actually limits its ability to find the most efficient shortcut. Worse, if a single instruction is slightly ambiguous, the model might faithfully follow a suboptimal route into a dead end.

The correct approach is like briefing a senior engineer: tell them the destination, mark the off-limits areas, and specify the deadline. Let them figure out the best route. This works dramatically better than handing them a turn-by-turn navigation script.

In our internal tests, simply changing one rule from “confirm before every tool call” to “only confirm before external write operations” more than doubled the task completion speed. The model no longer paused to ask permission to read files or check logs; it maintained momentum until it hit a point where human judgment was actually required.

Let’s dive into exactly how to apply this.

Cutting Is More Important Than Adding

When migrating a prompt stack that works on GPT-5.5, your first move isn’t optimization—it’s deletion. Remove one group of instructions at a time, rerun your evals, and observe the behavioral changes.

What You Can Safely Delete

Based on our hands-on experience, these categories are almost always dead weight:

Duplicate rules. If the same “do not hallucinate” rule appears in three different places, you aren’t just wasting tokens—you’re creating contradictions. When two copies use slightly different wording, the model gets confused about which one to prioritize. We’ve seen inconsistent output lengths simply because two “be concise” instructions phrased the rule differently. Cut down to one copy and watch stability improve.

Generic style or process instructions that don’t change behavior. Phrases like “Please use a professional tone” usually do nothing for GPT-5.6. Its default output is already appropriately professional. Adding this instruction just inflates the system prompt. Similarly, “think step by step” or “take this seriously” is pure noise.

Examples that don’t change behavior. Many engineers love stuffing few-shot examples into their prompts. If the scenarios you’re demonstrating are already handled correctly by the model, these examples only add tokens—and they might even bias the model toward surface-level patterns in your examples rather than the underlying rule. Delete the ineffective ones with zero loss.

Process instructions the model already performs reliably. If the model has automatically generated a summary in its last 20 responses, and your prompt still says “remember to generate a summary,” that line is redundant. Try deleting it; the behavior likely won’t change.

Irrelevant tools and tool descriptions. This is where clutter accumulates fastest. You have five or six tools in the toolbox, but you’re only using two or three. The extra descriptions distract the model during routing—it spends valuable reasoning cycles figuring out if the other tools are relevant. Expose only what’s needed and watch routing accuracy improve.

What You Must Keep

After your purge, make sure the following categories are still intact:

  • The user-visible outcome—what is the final deliverable?
  • Success criteria and stopping conditions—when is the job “done”?
  • Safety, business, evidence, and permission constraints—the hard red lines.
  • Tool-routing rules—but only when the correct route depends on dynamic context.
  • Output shape and validation requirements—the structure must pass schema checks.

Here’s a critical step you cannot skip: check for contradictions between your remaining instructions. GPT-5-class models take your “contract” literally. If one rule says “use as few tools as possible,” and another says “you must query the database before every response,” the model enters a conflict state. This instability is far worse than missing a piece of information.

We once maintained a customer support prompt that contained conflicting goals: “resolve the conversation quickly” and “ensure every user question is fully answered.” In 20% of cases, the model would prematurely end conversations with incomplete answers just to hit the “fast” metric. We only resolved it by explicitly re-prioritizing: correctness comes first, speed second.

Start with the Goal, Then Discuss the Route

How you phrase the objective directly dictates the quality of the model’s execution.

The Wrong Way

Please follow these steps to resolve the customer issue:
1. Query the user's account info.
2. Query the policy details.
3. Check eligibility based on policy rules.
4. If eligible, execute the action.
5. Return the result.

The problem here is that you’ve assumed the optimal path has exactly five steps. But what if the user’s question can be resolved in three? The model will still walk through all five. What if step 3 returns nothing? The prompt doesn’t say how to handle a missing data point—so the model might freeze.

The Right Way

Resolve the customer's issue end-to-end.

Success looks like:
- Eligibility decision based on available policy and account evidence.
- Any allowed action is completed before responding.
- Return completed_actions, customer_message, and blockers.
- If required evidence is missing, ask for the smallest missing field.

This prompt defines the “what” and the “done” without dictating the “how.” The model is free to choose the shortest path—sometimes one lookup is enough, sometimes three. It judges dynamically.

We ran a head-to-head comparison: the “step-by-step” prompt averaged 4.2 tool calls for a set of customer issues; the “goal-oriented” prompt averaged just 2.7. Those 1.5 saved calls were pure efficiency gains from the model taking its own shortcuts.

How to Write Stopping Conditions That Work

Stopping conditions are more critical than execution steps. If the model doesn’t know when to stop, it will spiral—either looping indefinitely or bailing out prematurely.

Resolve the request in the fewest useful tool loops, but do not let loop
minimization outrank correctness, required evidence, calculations, or
required citations.

After each result, ask: Can I now answer the core request with useful evidence?
If yes → answer.
If still missing required evidence → name the missing fact and use the smallest
useful fallback.

The key phrase is “name what’s missing.” If the model needs three evidence points to make a judgment but only has two, it should explicitly say “still missing X information,” rather than attempting a shaky inference using two points. This gives the user or upstream system precise action items.

Don’t Let “Be Concise” Turn into “Be Curt”

GPT-5.6 is noticeably more concise than GPT-5.5 out of the box. Your first step after switching models should be to check whether your old “be concise” directive is still appropriate—or actively harmful.

Test Without It First

In many scenarios, leaving out “be concise” produces a response that’s exactly the right length. Adding it back results in answers that are too short—just the final verdict without the necessary context and reasoning.

For instance, if a user asks, “Is this customer eligible?” without the conciseness rule, the model outputs: “Yes, because criteria A, B, and C are all satisfied.” With the rule, it might just output “Yes.” For the user, the second version is unverifiable and practically useless.

If You Need Length Control, Use Priorities, Not Word Counts

Instead of “limit the response to 50 words,” try this:

Lead with the conclusion. Include the evidence needed to support it, any material
caveat, and the next action. Omit secondary detail and repetition.

Keep all required facts, decisions, caveats, and next steps. Trim introductions,
repetition, generic reassurance, and optional background first.

Now the model knows which information is sacred and which is disposable, rather than blindly compressing. In our tests, the “priority-based” approach preserved about 25% more core information than the “hard word limit” approach.

Use the Verbosity Parameter for Defaults

The API offers a text.verbosity parameter with low, medium, or high settings. Use this as your global default. Reserve the prompt itself for task-specific length, structure, and content requirements.

Keep the global control separate from the task control. This yields more consistent behavior across different request types.

Personality and Collaboration: Keep It to Two Sentences Each

There’s a common habit of writing a lengthy persona paragraph: “You are a warm, empathetic, professional customer service representative…” This text mostly burns tokens and rarely changes behavior meaningfully.

Distinguish “Personality” from “Collaboration Style”

  • Personality controls: tone, warmth, directness, formality, humor, empathy, and polish.
  • Collaboration style controls: when to ask questions, make assumptions, take initiative, explain tradeoffs, check work, and handle uncertainty.

Limit both to two to three sentences. Personality shapes user experience; collaboration style shapes task behavior. Neither replaces clear goals, success criteria, tool rules, or stopping conditions.

Be Specific; Don’t Use Labels

“Friendly” is far too vague. Tell the model “be friendly” and it might respond with “Dear valued user! 🌟” and excessive emojis. Instead, describe the specific writing choices you want:

State the answer directly. If the user reports a problem, acknowledge the
specific issue before giving the next step. Use reassurance only when it is
relevant. Omit generic praise and unnecessary sign-offs.

Now the model knows what to do, not what to role-play. The execution fidelity is radically different.

The same goes for empathy. Don’t say “be empathetic.” Say “when the user expresses frustration, restate their problem back before offering the solution.”

We ran a blind user test: Prompt A had an 80-word persona definition. Prompt B had zero persona definition, only behavioral rules. Users rated both versions equally on “warmth,” but Prompt B was 12% faster. The persona was mostly noise.

Language Switching: Be Explicit, Don’t Use “Always”

“Always respond in the user’s language” often backfires. If a user asks a question in English but expects a Chinese response, the model will stubbornly output English. Instead:

Output language is Chinese. Only change the language if the user explicitly switches.

Define the Boundary: What’s Allowed, What’s Not

A defining trait of GPT-5.6 is proactivity and persistence. Give it a multi-step task and it will push forward relentlessly. This is a double-edged sword: good because you don’t have to nudge it, bad because it might push straight into forbidden territory.

The Three-Tier Authorization Model

For requests to answer, explain, review, diagnose, or plan:
  Inspect the relevant materials and report the result. Do not implement
  changes unless the request explicitly asks for them.

For requests to change, build, or fix:
  Make the requested in-scope local changes and run relevant non-destructive
  validation without asking first.

Require confirmation for:
  External writes, destructive actions, purchases, or material expansion of scope.

This tiered approach ensures the model operates autonomously within safe boundaries and hits the brakes at the danger line.

In practice, define “local changes” explicitly: reading files, inspecting logs, editing the current codebase, and running tests are safe operations that don’t require check-ins. Pushing to production, deleting database records, or sending emails to customers are red-line actions that require explicit human approval.

Don’t Jump Layers

For long-running tasks, define the current “work layer.” Distinguish: research, design, implementation, review, and external coordination. The model needs to know which layer it’s in and must not silently transition between them.

Consider a task: “Help me optimize API performance.” The correct layer progression is: Research (check current metrics) → Design (propose solutions) → Implement (change code) → Verify (run tests). If the model starts rewriting code during the Research phase, it’s jumping layers. Your prompt must explicitly prohibit this.

Tools: Less Is More

Tool descriptions and routing rules are the primary drivers of whether the model uses the right tool at the right time.

Expose Only Relevant Tools

Only put task-relevant tools in the toolbox. This isn’t about saving tokens; it’s about accuracy. When a model chooses between 10 tools versus 3 tools, the error rate isn’t linear—it compounds. We measured an 18% improvement in tool-selection accuracy when reducing the toolbox from 8 to 3 tools.

The Four-Element Description Rule

Every tool description needs to clearly state:

  1. What it does—one sentence.
  2. When to use it—clear trigger conditions.
  3. Important return fields—which outputs matter.
  4. Error behavior—how it fails and what it returns on failure.

Avoid empty phrases like “general-purpose tool” or “use as needed.”

Explicitly State Dependencies

Before taking any action, resolve required discovery, retrieval, and
validation steps. Do not skip a prerequisite because the intended final
state seems obvious.

This seems like common sense, but the model will skip steps when the answer seems “obvious.” For example, if a user asks about “Order 12345,” the model might output “Shipped” without querying the database because it saw a similar order in the conversation history. You must force the retrieval.

Parallel vs. Sequential Execution

When reads are independent, tell the model to parallelize:

If multiple queries are independent, execute them in parallel.

When one result determines the next query, tell it to go sequential:

If the result of this query affects the next query, execute them sequentially.

Parallelism cuts latency, but it’s not always appropriate. Give the model the judgment criteria to decide.

Handling Empty Results

If a tool returns empty, partial, or suspiciously narrow results, allow one or two meaningful fallback attempts before concluding “no result.”

For example, searching for “John Doe’s policy” returns nothing. A fallback might be searching for “Doe policy” or by phone number. But if two fallbacks fail, the model should stop and report “not found” instead of making endless attempts.

Programmatic Tool Calling: Only for Boundary Scenarios

GPT-5.6 supports Programmatic Tool Calling (PTC)—the ability to generate a small program to batch-process tool results. It’s powerful, but easily misused.

When to Use PTC

  • Filtering, joining, sorting, ranking, deduplication, and aggregation.
  • Batching across many similar records.
  • Repeated deterministic validation.
  • Large structured results that can be reduced to a compact schema.

When NOT to Use PTC

  • A single direct call is sufficient.
  • Intermediate outputs are already small.
  • Each result changes the next decision.
  • An action requires approval.
  • The final answer must preserve citations or native artifacts.
  • The workflow requires semantic judgment between calls.

In most straightforward scenarios, direct tool calling is simpler and more reliable than PTC. We learned this the hard way: we refactored a three-step sequential workflow into PTC, only to end up with doubled code complexity, longer debugging time, and slightly worse results.

PTC Prompt Template

Use Programmatic Tool Calling only for the bounded record-reduction stage.
Call only the documented read-only tools. Filter and deduplicate the
intermediate results, then emit exactly the required compact schema with
evidence fields. Retry transient failures at most twice. Use direct tool
calls for approval, semantic judgment, citations, and final validation.

The key is defining the boundary—which stage, which tools, what output format, and how to handle errors. Anything outside this boundary goes to direct tool calling.

Don’t Forget to Check Both Outputs

PTC produces two outputs: program_output (structured data) and the final assistant message (the human-facing reply). You have to test both. We’ve encountered cases where the program returned the correct records, but the final message omitted a required field or citation. The logic can be right, but the output can still be wrong.

Grounding and Citations: No Guessing, No Inventing

GPT-5.6 is better at grounded responses than its predecessors, but that’s contingent on explicit citation rules in the prompt.

Three Things You Must Clarify

  1. What content needs evidence? All factual claims, or just specific types?
  2. What counts as “enough” evidence? One source? Two for cross-validation?
  3. What to do when evidence is missing? Explicitly report “not found,” or fall back to common sense?

Retrieval Budget for Q&A

For standard Q&A: Start with one broad search using short, discriminative
keywords. If the top results contain enough support for the core request,
answer from those results.

Make another retrieval call ONLY when:
- A required fact, owner, date, ID, or source is missing.
- The user asks for exhaustive coverage or comparison.
- A specific artifact must be read.
- An important claim would otherwise be unsupported.

Do NOT search again just to improve phrasing, add examples, or support
nonessential detail.

The core logic here is limiting retrieval attempts. Models have a natural tendency to think “more data is safer,” but each call has cost and latency. A clear stop rule (“when to stop looking”) is far more effective than a vague “try to be efficient.”

Citation Rules for Research and Synthesis

  • Cite only retrieved sources.
  • Attach citations to the claims they support.
  • Label inference separately from directly supported facts.
  • State conflicts between sources.
  • Narrow the answer or report missing evidence instead of guessing.

The last point is critical. When faced with “no data,” the model’s default tendency is to “invent a reasonable answer.” You must explicitly prohibit this. Better yet: give it a template for “I don’t know” so it knows that admitting missing information is acceptable.

Creative Drafting: Handle with Care

For hybrid “creative + factual” tasks like marketing copy or product descriptions, clearly distinguish between:

  • Source-backed facts (product specs, customer outcomes, release dates).
  • Creative wording (metaphors, adjectives, calls-to-action).

Explicitly forbid inventing names, metrics, dates, roadmap statuses, customer outcomes, or product capabilities to make the copy “sound better.” We’ve seen the model sneak in flattering but false details just to make the output more persuasive. The only effective guardrail is a direct, explicit “no-invention” list.

Long-Running Workflows: State Management and Update Cadence

In multi-step or tool-heavy tasks, the model needs to give visible progress feedback to the user—but it shouldn’t narrate every single tool call.

Update Cadence: Only on Phase Transitions

Before tool calls for a multi-step task, send a one- or two-sentence
user-visible update stating the first step.

During the task, update only when:
- A major phase begins, or
- A finding changes the plan.

Each update should state one concrete outcome and the next step.

This keeps the user informed without overwhelming them with “querying database… parsing results… calling API…” noise.

Compression vs. Retention

Long conversation histories cost tokens, but aggressive compression might lose crucial state. Strategy:

Compact after major milestones, not after every turn. Treat compacted content as opaque state—the model doesn’t need to understand it, just know that “this work is done.”

If you’re using previous_response_id, the assistant state is preserved automatically. If you’re replaying history manually, preserve each original phase value unchanged.

Persistent Reasoning vs. Current Reasoning

GPT-5.6 supports persistent reasoning—preserving reasoning chains across turns. This works well when the objective, assumptions, and priorities remain stable.

However, if previous reasoning becomes outdated, persistent reasoning drags down performance: it adds tokens, increases latency, and anchors the model to stale assumptions.

The decision rule: if new user input invalidates previous assumptions, prioritize current reasoning and ignore the persisted chain.

Cache-Friendly Construction

Prompt caching is a proven way to reduce latency and cost. Keep reusable prefixes stable, and avoid unnecessary churn in large system prompts. Only use explicit cache breakpoints when you’ve measured actual improvements in cache behavior for your specific workload.

Reasoning Effort: Start Low, Climb Only When Necessary

GPT-5.6 offers multiple reasoning effort settings, from low to max. Higher settings are more capable, but slower and more expensive.

The Migration Best Practice

  1. Use the current model’s (GPT-5.5/5.4) reasoning effort as your baseline.
  2. Test the same setting and one level lower on a representative subset.
  3. Choose the lowest setting that preserves quality.
  • low: Use for latency-sensitive work when quality holds up.
  • medium: A balanced default starting point for most tasks.
  • high or xhigh: Only when evals show meaningful gains.
  • max: Reserve for the hardest quality-first workloads; do not recommend globally.

Fix the Prompt Before Cranking Up Reasoning

In many cases, poor performance is due to a missing success criterion, dependency rule, tool-routing rule, or verification loop—not insufficient reasoning power. Throwing higher reasoning effort at a bad prompt is wasteful.

Correct sequence: debug the prompt first, then consider increasing reasoning effort. We’ve seen multiple cases where simply adding “if evidence is missing, report the absence rather than guessing” improved outcomes more than moving from medium to high.

Frontend and Visual Tasks: Preserve the Design System

GPT-5.6 shows stronger layout, visual hierarchy, and design judgment compared to previous versions. Still, it requires explicit contextual constraints.

Rules for Incremental Changes

Before modifying, inspect and preserve:
- Existing design tokens, components, and patterns.
- Do NOT add extra features or decorative UI unless requested.
- Preserve responsive behavior and expected states.

Render and inspect the result before finalizing.

Don’t let the model “get creative.” We’ve seen it reposition buttons because “they look better over there.” Uninvited UI changes are a nightmare to debug in production. The prompt must explicitly limit the scope to exactly what was requested.

Visual Precision Requirements

For vision, computer-use, localization, or OCR tasks where spatial precision matters, be intentional about image detail. Use original for large, dense, or coordinate-sensitive images (accept the higher input cost and latency). Use low for simpler scenes. Do not apply one setting globally.

Verification: Check Your Work Before Submitting

Give the model access to validation tools, and clearly state which validations matter.

For Coding

After making changes, run the most relevant validation available:
- Targeted tests for changed behavior.
- Type checks or lint checks when applicable.
- Build checks for affected packages.
- A minimal smoke test when full validation is too expensive.

If validation cannot be run, explain why and describe the next best check.

The key here is giving the model a path forward even if validation fails—not every codebase has a comprehensive test suite. If tests can’t run, the model should say “I recommend manual review of X and Y” rather than getting stuck.

For Visual Artifacts

Render the artifact before finalizing. Inspect layout, clipping, spacing,
missing content, and visual consistency. Revise until the rendered output
matches the requirements.

For UI code, the model can see the code but not the actual rendering. You must give it the tooling (e.g., a browser preview) to “render and inspect” rather than relying on its imagination.

For Implementation Plans

Ensure the plan includes:

  • Requirements.
  • Named resources or files.
  • State transitions or data flows.
  • Validation checks.
  • Failure behavior.
  • Privacy or security considerations.
  • Open questions that materially affect implementation.

Recommended Prompt Template

Use this structure as your starting point for complex prompts. Keep each section brief. Add detail only where it demonstrably changes behavior.

Role: [the model's function and context]

Personality: [tone and collaboration style]

Goal: [user-visible outcome]

Success criteria: [what must be true before the final answer]

Constraints: [policy, safety, business, evidence, and side-effect limits]

Tools: [which tools to use, when, and what not to use]

Output: [sections, length, format, and tone]

Stop rules: [when to retry, fallback, abstain, ask, or stop]

The Migration Workflow: One Change at a Time

When moving an existing application to GPT-5.6, follow this exact sequence:

  1. Switch the model and preserve the current reasoning effort.
  2. Run representative evals before changing the prompt to get a solid baseline.
  3. Remove obsolete scaffolding, repeated instructions, and irrelevant tools.
  4. Add only the smallest targeted instruction that fixes a measured regression.
  5. Re-run evals after each prompt or reasoning change.

Do not rewrite the entire prompt stack in one go. If you do, you won’t be able to tell whether a behavior change came from the model switch, the reasoning setting, the prompt changes, the toolset, or the runtime.

When a change causes regression, debug it with a small set of real traces. Identify the failure mode, pinpoint the instruction or contradiction that caused it, make a surgical edit, and rerun the same cases. This “surgical” iteration is far more efficient than wholesale rewrites.

Common Pitfalls from Our Own Migration

  1. Deleting too many “safety net” instructions at once. Some instructions are redundant 99% of the time but protect against edge cases in the remaining 1%. Validate deletions one by one; never batch-delete.
  2. Overestimating the model’s “common sense.” We assumed the model “obviously knows” not to leak PII. It didn’t. Safety-related rules cannot be abbreviated.
  3. Underestimating the impact of tool descriptions. We trimmed a tool description from 30 words to 15 and watched tool-selection accuracy drop. The missing 15 words contained the critical line: “do NOT use this tool in X scenario.”
  4. Upgrading the model and rewriting the prompt simultaneously. When things broke, it took us three days to isolate the cause to model behavioral changes, wasting huge debugging effort.

Actionable Summary / Checklist

If you only take away 10 things from this guide:

  1. Delete first, add later. Purge duplicates, redundancies, and irrelevancies before adding anything new.
  2. Describe goals, not steps. Define “what” and “done,” let the model figure out “how.”
  3. Stopping conditions > execution steps. Tell the model when to stop, ask, or give up.
  4. Test without “be concise.” GPT-5.6 is already concise by default—adding this may make responses too short.
  5. Personality and collaboration style: two sentences each. No one needs a 100-word persona.
  6. Expose only relevant tools. Descriptions must include: what, when to use, return fields, error behavior.
  7. PTC only for boundary scenarios. Use it for batch/structured data; use direct calls for judgment workflows.
  8. Citation rules: three items. What needs evidence, what counts as enough, what to do when missing.
  9. Reasoning effort: start low. Fix the prompt before increasing reasoning.
  10. One change at a time. Modify, evaluate, repeat. Never rewrite everything at once.

One-Page Cheat Sheet

DO THIS AVOID THIS
Define goals and success criteria List every step of the process
Provide stopping conditions and fallbacks Provide endless execution plans
Expose only relevant tools Stuff the toolbox with unused options
Describe personality via specific behaviors Use vague labels like “friendly” or “professional”
Define a 3-tier authorization boundary Use either full autonomy or full manual control
Use PTC only for batch scenarios Use PTC for everything
Evaluate before changing prompts Switch models and rewrite prompts simultaneously

FAQ

Q: Will my existing GPT-5.5 prompts work out-of-the-box on GPT-5.6?
Possibly, but likely not optimally. GPT-5.6 has different default behaviors, especially regarding conciseness and autonomy. Best practice: switch models, run evals, then adjust prompts based on results.

Q: How do I know if an instruction is truly redundant?
Delete it, run a representative test set, and check if behavior changes. If it doesn’t, it’s redundant. Let data decide, not intuition.

Q: How much context does GPT-5.6 support?
Refer to the official model guide. This article focuses on prompt design strategy, not specific API parameters.

Q: What’s the ideal use case for Programmatic Tool Calling?
Scenarios requiring processing large structured datasets: filtering, sorting, aggregation, and batch operations. Avoid it for workflows requiring semantic judgment or step-by-step decisions.

Q: How do I set the reasoning effort?
Start with medium. If quality is insufficient, check your prompt completeness first, then consider raising it. Only use high or higher for latency-insensitive, high-quality tasks.

Q: My model outputs are too long or too short. What do I do?
Adjust the text.verbosity parameter first for global control, then use priority-based rules in the prompt (what to keep, what to omit) for fine-tuning. Avoid hard word-count limits.

Q: Should I use few-shot examples?
Try without them first. GPT-5.6’s instruction-following is robust enough for most tasks. Examples can actually limit generalization. If you must include them to stabilize output, revisit your core instructions—they may not be clear enough.

Q: Should I include “think step by step” in the prompt?
No. GPT-5.6 autonomously judges when reasoning is necessary versus when a direct answer is appropriate. Adding this may trigger unnecessary reasoning overhead.

Q: How do I handle multilingual scenarios?
Explicitly specify the output language and the switching rules. Avoid broad statements like “always respond in the user’s language.”

Q: What if the model hallucinates (invents information)?
Prohibit hallucination explicitly in the constraints. Clarify the correct behavior when evidence is missing (report absence rather than guess). Make citation rules specific enough that the model knows exactly which claims require source support.