Prompt Engineering in July 2026: The Prompt-Stripping Era

The Big Picture: The Prompt-Stripping Era

For three years, the reflex when a model underperformed was to add: another rule, another example, another "IMPORTANT: ALWAYS…" line, another guardrail. Within nine days this July, both Anthropic and OpenAI shipped official prompting guidance that says the opposite. The instruction now is to subtract.

• OpenAI (GPT-5.6, July 9): removing repeated instructions and examples and simplifying tool descriptions improves both task performance and token efficiency. In a sample of internal coding-agent eval runs, configurations with leaner system prompts improved evaluation scores by roughly 10–15% while cutting total tokens 41–66% and cost 33–67%.
• Anthropic (Claude Fable 5 prompting guide): "Skills developed for prior models are often too prescriptive for Claude Fable 5 and can degrade output quality. Review and consider removing older instructions if default performance is better."

Two independent labs, two independent eval suites, one conclusion: the scaffolding you built for the last generation is now a tax on this one. It costs tokens, it costs money, and (the new part) it costs quality.

The single most actionable thing you can do this month is a subtraction experiment: take your best-performing production prompt, delete one block, and re-run your evals. The prior probability that it gets better just went up sharply.

Claude Fable 5: Released, Export-Controlled, Restored

Anthropic released Claude Fable 5 (and its lower-safeguard research sibling Mythos 5) on June 9. Three days later the US government applied export controls, and with no way to verify user nationality in real time, Anthropic suspended access for everyone. Fable 5 returned globally on July 1, a 19-day outage of a flagship model, driven by regulation rather than an outage in the usual sense.

The engineering lesson from the post-mortem matters more than the drama. The jailbreak that triggered it didn't expose unique capability. Anthropic's own testing showed weaker models could identify the same vulnerabilities. It hit a deliberately wide safety margin, and the fix (a classifier that blocks the technique >99% of the time) came at an explicit, stated cost: more false-positive refusals on routine coding and debugging.

If you write security-adjacent, life-sciences, or reasoning-heavy prompts against Fable 5, expect the occasional stop_reason: "refusal". Anthropic's recommended pattern is to configure a fallback to Opus 4.8 rather than fight the classifier in the prompt.

How to prompt Fable 5

The official guide is the substantive prompt-engineering document of the period. The patterns:

1. Effort is the primary control, not a "make it smarter" dial. Use high as the default, xhigh only for capability-sensitive work, medium/low for routine tasks. Lower effort on Fable 5 often exceeds xhigh on prior models. Maxing it out is a cost error, not a quality win.

2. Ground progress claims in evidence. The highest-value snippet in the guide, because it kills the failure mode that makes long autonomous runs untrustworthy, fabricated status reports:

   "Before reporting progress, audit each claim against a tool result from this session. Only report work you can point to evidence for; if something is not yet verified, say so explicitly."

   Anthropic says this "nearly eliminated fabricated status reports even on tasks designed to elicit them."

3. Brief instructions beat enumerated ones. A short brevity directive is as effective as naming every unwanted pattern: the subtraction principle, concretely.

4. Build the model a memory file. One lesson per file with a one-line summary at the top; update an existing note rather than duplicating; delete notes that turn out to be wrong. A plain Markdown file is enough.

5. Prefer fresh-context verifiers over self-critique. A verifier subagent that hasn't seen the worker's reasoning catches failures "review your own work" misses. Fable 5 dispatches long-lived async subagents readily.

6. Two new failure modes to prompt around. Fable 5 can occasionally (a) end a turn stating intent without issuing the tool call, and (b) suggest a new session out of unprompted budget concern, usually when the harness shows it a remaining-token countdown. Don't surface context-budget counts to the model.

7. Never instruct reasoning echo. Telling the model to "show your full reasoning" or "transcribe your thinking" can trigger a reasoning_extraction refusal. Read structured thinking blocks via the API instead.

8. Turns run longer. Individual requests can run many minutes, autonomous runs for hours. Raise your client timeouts before migrating, the operational trip-wire most teams hit first.

GPT-5.6: Sol, Terra, Luna

OpenAI shipped a three-tier family on July 9: Sol (flagship), Terra (mid), Luna (small), with tier names now durable and able to advance independently of the version number. What changes for prompt engineers:

• Programmatic Tool Calling (PTC). Instead of returning tool calls one at a time for your loop, the model writes code that orchestrates the tools itself; only a compact result re-enters context. The sharp insight is when not to use it: PTC is for bounded record-reduction (filter, join, dedupe, aggregate, batch-validate). Use direct calls when each result changes the next decision, when an action needs approval, when citations must be preserved, or when semantic judgment is needed between calls. "Multiple, parallel, or dependent calls alone do not justify PTC."
• Verbosity is an API parameter, not a prompt line. GPT-5.6 is more concise by default; set the default detail level with text.verbosity and reserve the prompt for task-specific length. Re-test your "be concise" instructions. They may now be unnecessary or actively harmful.
• Caching gets predictable. Explicit cache breakpoints and a 30-minute minimum cache life (writes bill 1.25x, reads keep the 90% discount). Same rule as ever: stable prefix, no volatile tokens in the cached region.
• Reasoning-effort migration recipe. Keep your current effort as the baseline and test the same setting and one level lower. Before raising effort, check whether the prompt is missing a success criterion, dependency rule, tool-routing rule, or verification loop. Most reaches for more reasoning are actually unfixed prompts.
• ultra coordinates parallel agents (four by default, up to sixteen): better results in less time, at higher token cost, for tasks that decompose into independent subtasks.

Who's the best coding model? It's a Pareto frontier

OpenAI's own launch table is ambiguous on purpose-defeating grounds. Sol leads the Artificial Analysis Coding Agent Index (80 vs 77.2) and Terminal-Bench 2.1 (88.8% vs 83.1%) using less than half the output tokens, but on SWE-Bench Pro, Fable 5 scores 80% against Sol's 64.6%, a 15-point gap in Anthropic's favor, in OpenAI's own published numbers.

The honest read: Sol wins on efficiency and agentic/terminal work; Fable 5 retains an edge on hard repository-level engineering and aggregate intelligence. Anyone telling you one model is simply "better" is compressing a Pareto frontier into a scalar. Benchmark on your workload. Both labs are grading their own homework.

Gemini 3.5 Pro Is Still Not Out

As of mid-July, Gemini 3.5 Pro remains in limited preview with no model card, no published benchmarks, and no final pricing. Circulating GA dates are unconfirmed by Google. The practitioner guidance, now vindicated twice: do not re-architect around unconfirmed capabilities. Keep your eval harness model-agnostic so you can re-benchmark in hours when it actually ships.

The Research Catches Up: Context as a Living Artifact

The academic thread converged on the same idea both vendors shipped. Agentic Context Engineering (ACE, arXiv:2510.04618, ICLR 2026) treats context not as a static file you author once but as an artifact the agent evolves: generate strategies from attempts, reflect on what worked, curate by adding successes and removing failures. Reported gains: +10.6% on coding benchmarks, +8.6% on financial reasoning (author-reported; not independently replicated here).

The convergence is the signal. ACE's "curate the context, remove what failed" is almost verbatim Anthropic's memory-file instruction ("update an existing note rather than creating a duplicate; delete notes that turn out to be wrong"). Research and product docs arriving at the same place from different directions is the strongest evidence available that this is real, not fashion.

What We Shipped into PromptArch

We folded this briefing into the product the same week, and, per our own principle, into the linter as much as the generator, so the guidance reaches you whether you build in the browser, from the CLI, or over MCP:

• New model targets. Claude Fable 5 / Mythos 5 and GPT-5.6 are now selectable across the builder and Studio, each with a dedicated model-optimization profile encoding the guidance above (effort-first, evidence-audited progress, PTC routing, text.verbosity, reasoning-echo avoidance).
• A subtraction principle now runs through every generated prompt: the leanest version that fully specifies the task: every requirement stated once, and nothing that isn't a requirement.
• New deterministic lint rules, free and offline in the linter, the CLI, and the MCP server: reasoning-echo detection (flags reasoning_extraction refusal triggers), a verbosity-instruction check (verbosity belongs in the API), a context-countdown check, emphasis-inflation (too many ALL-CAPS rules dilute the ones that matter), and duplicate-line detection.
• A new Studio artifact (Agent Memory File) that generates a MEMORY.md policy encoding the one-lesson-per-file convention, plus a matching lint format so the thing you generate is the thing you can check.

Your Checklist for the Week

1. Run a subtraction experiment on your highest-value prompt. Delete one block; re-run your evals. Verify it on your own workload. That's the whole point.
2. Audit for reasoning-echo instructions ("show your work," "explain your reasoning," "transcribe your thinking"). Replace with structured thinking blocks. Lint a file free to find them.
3. Add the progress-audit instruction to any long-running agent. Three sentences against the failure mode most likely to burn you.
4. Raise client timeouts before migrating to Fable 5.
5. Decide PTC vs. direct calls per stage, not per app. Bounded reduction → PTC. Judgment, approvals, citations → direct.
6. Don't build on Gemini 3.5 Pro yet.