Good Outputs Survive Revision

If You Only Read One Thing

The useful AI output is no longer the first one. It is the artifact that survives revision. Images Learn to Hold Still turns OpenAI's new image model into a test of whether one edit preserves the rest; New Requirements Reprice Old Code shows the inverse, with late constraints roughly doubling deletion of prior agent-written lines. Generation is becoming cheap. Preservation is harder.

Images Learn to Hold Still

The important advance in ChatGPT Images 2.5 is not a prettier first picture. It is a better chance that the fifth edit preserves the four decisions already approved. Image generation is shifting from one-shot creation toward revision without collateral damage.

OpenAI says people now create more than 3 billion images a week across ChatGPT and its image APIs. The September 8 release reaches every ChatGPT, ChatGPT Work and Codex tier, plus two API models. GPT-Image-2.5 Flare is the faster default. Sunburst spends more time on precision. Flare delivers higher quality than GPT-Image-2 at up to 50% lower latency; an early Manus evaluation reported two-to-fourfold faster generation.

The capability is revision survival. Think of an image edit as a code diff: the requested region should change while the accepted subject, layout and brand treatment remain fixed. Earlier generators often behaved like a full rewrite. Images 2.5 adds focused comments, sketch input and stronger multi-turn consistency so the interface can express both the change and the state that must survive it. Axios's hands-on tests found better likeness preservation and more precise text placement, although the sample was small.

Faster is not automatically cheaper. OpenAI's API price table lists both 2.5 models at $8 per million image-input tokens and $30 per million output tokens. GPT-Image-2 costs $4 and $15. The new endpoints therefore double token rates while claiming half the latency. The economic case depends on fewer discarded generations and fewer repairs, not on speed alone.

That changes model choice. Flare fits high-volume iteration when accepted-image cost falls despite the higher rate. Sunburst fits work where preserving an approved asset is worth waiting longer. Neither choice is proven by OpenAI's selected demos. The system card reports policy tests, not a repeated-edit benchmark, and the company publishes no pixel-level locking measure.

The decisive signal is a public five-turn edit suite that measures unintended pixel or layout changes after every instruction. Images 2.5 becomes a production upgrade if cumulative drift falls by at least half while cost per accepted asset stays below GPT-Image-2. Without that result, the release is a faster, more expensive promise about preservation.

New Requirements Reprice Old Code

A late requirement is not another prompt correction. It changes the value of code the agent has already written. New evidence puts a number on that reset: prior agent-authored lines are deleted or replaced at roughly twice the rate after a requirement arrives.

The study reconstructs 3,553 SWE-chat sessions and identifies constraints not stated before implementation. It then tracks what happens to earlier agent-written lines over the next five edits. Between 18% and 22% of clean-start sessions contained at least one late requirement. Fifty-four percent of those events arrived after the session midpoint, so the problem does not disappear once the agent is deep into the task.

Most arrivals were not dramatic reversals. The canonical labels classify 89.3% as supplementary and 10.7% as contradictions; only 14.5% were destructive in form. Small constraints still invalidated settled work. In a stricter analysis using non-overlapping event windows, requirement arrivals produced 1.82 times as much invalidation as matched ordinary edits. A net-deletion sensitivity test put the ratio at 2.28.

The mechanism is discovery through reaction. A person sees working code and realizes that the interface, edge case or ownership rule was missing. The agent must now fit a new constraint through decisions made under the old contract. This extends the reader's planning-heavy workflow with a harder lesson: front-loading thought helps, but requirement completeness cannot be assumed.

The controlled experiment makes that lesson sharper. Delaying disclosure moved the expected implementation work until after the reveal. Yet advance warning that another requirement was coming did not measurably reduce overwriting once follow-up work was held equal. A longer preamble is not the demonstrated cure.

The evidence supports a trigger, not a recipe. When a non-entailed requirement appears after the first edit, the review boundary should expand from the new diff to the prior agent-written lines it touches. Tagging that event, refreshing the acceptance contract and counting invalidated code turns surprise into observable rework. The study does not prove that a specification checkpoint reduces the cost; the authors name that intervention as future work.

The boundaries matter. The dataset comes from open-source developer sessions. Deletion is only a proxy for wasted work, and an adversarial validation of the line-replay method found 0.40 precision and 0.67 recall. The association is temporal, not causal. A multi-provider controlled trial clears the practice bar only if a requirement-reset checkpoint cuts prior-code invalidation by at least 25% without raising regression rates.

The Contrarian Take

Everyone says: Better models make prompting less important, while a sufficiently detailed upfront specification eliminates coding-agent rework.

Here's why that's wrong (or at least incomplete): Images 2.5 is valuable precisely because the first output is not the finished artifact; the model must preserve accepted state through later instructions. Coding sessions have the inverse problem: late constraints roughly double prior-code invalidation, and advance warning alone did not measurably reduce overwriting. Intelligence does not remove revision cost. It moves the scarce capability from generation to controlled change.

Under the Radar

Models are teaching one another a house dialect. September 7's Pydantic note covered dependency trust; today's analysis finds a language-layer analogue across 4,319 pre-2025 READMEs and 1,047 2026 Claude Code repositories. vocabguard checks output fields and tool arguments, and its held-out classifier reached 0.869 AUC. The author does not know whether rewriting flagged prose improves production outcomes, so drift detection is not yet a quality gate.
Repositories can compile into operating instructions. AREX-Skill turns more than 1,000 ML repositories into 5,000 verified skills with routing, commands, checks and recovery paths. Holding the model, harness and budget fixed, its authors report gains from 9.2% to 134.3% across four research benchmarks. The artifact runs in Codex and Claude Code, but the full technical report is still forthcoming and the tests measure ML research, not general software delivery.

Quick Takes

OpenAI's 10,000-agent proof makes verification the bottleneck. An internal model beyond Astra used about 10,000 concurrent agents, 2.7 million messages and 130 billion output tokens to produce a proposed Navier–Stokes solution in 88 hours; Astra then spent 17 hours formalizing it in Lean. The scale is not a portable agent recipe. The technical signal is that massive stochastic search becomes useful when a formal checker can reject almost everything it generates. A Lean certificate still cannot establish provenance or whether the encoded statement matches the external claim, which is why today's News briefing owns the market-structure dispute. (Source)
GitHub puts the sandbox above the developer. Enterprise administrators can now lock Copilot for JetBrains policies covering filesystem, network, proxy, developer tools and macOS Keychain access, with managed restrictions overriding user settings. The control is in public preview, but policy diagnostics make the enforced boundary locally inspectable instead of leaving it as an administrative promise. (Source)
Agent traces acquire a common front door. Pydantic's Logfire Agents view discovers runs through the OpenTelemetry invoke_agent convention or OpenInference, then groups cost, errors, latency, tools and human annotations across Pydantic AI, LangGraph, CrewAI, AutoGen and the OpenAI Agents SDK. OpenInference spans still lack aggregate per-call cost, so some totals remain estimates rather than receipts. (Source)

The Thread

AI work is acquiring a change budget. Images 2.5 tries to shrink the blast radius of one visual edit; late requirements show how a small constraint can double the blast radius across existing code. Vocabulary guards, routed skills and sandbox policies make collateral change visible before it propagates. Formal proof is the limiting case because every step must preserve the statement being proved. The useful metric is now change efficiency: how much requested difference arrives per unit of accepted work that must be revalidated.

Predictions

New predictions:

I predict: By October 9, OpenAI or a public image benchmark will publish GPT-Image-2.5 results across at least three sequential edits, reporting preservation or drift rather than only single-image preference. (Confidence: medium; Check by: 2026-10-09)

Issue date: September 9, 2026 · Generated: 4:22 a.m. ET