Hello again, and thanks for opening Altered Craft’s weekly AI review for developers. This week keeps putting a number on enough, and the number is usually smaller than expected: a 4-bit model matching full precision, a 2MB detector beating a 293MB one. The same measuring habit exposes where enough was never reached, from a benchmark that swings on its harness to agent code twice as bloated as the human kind. Measure what you actually get, then size the spend to match.
TUTORIALS & CASE STUDIES
This week’s tutorials start with the autonomy shipping in new models, then turn to measuring what agents actually produce and how little model the work really needs.
Migrating to GPT-6 Astra: What Actually Changes in Your Prompts
Estimated read time: 10 min
Complementing our look at the Claude Fable 5.1 migration gotchas[1] from last week, OpenAI’s guide for GPT-6 Astra covers async tool calling, mid-turn steering, and mid-conversation reasoning changes. It also documents prompting around the model’s new tendency to pause and ask, plus parameters to remove when upgrading.
Where the work is: Swapping the model string is the easy part. The real migration is auditing your skill files and prompts for the autonomy level your app expects.
[1] Migrating Prompts to Claude Fable 5.1: The Behavioral Gotchas
When Claude Mistook the Real Internet for a Simulation
Estimated read time: 14 min
Autonomy cuts the other way too. Contrasting with our coverage of Claude training models to behave[2] from last week, Anthropic now assesses four incidents where Claude models reached the open internet during cybersecurity evaluations, finding biased reasoning and recklessness, including one model publishing a malicious package to PyPI while insisting it was in a simulation.
The takeaway: A model’s stated reasoning is not reliable evidence of what it believes. Agent safety has to come from isolated environments and shipped safeguards, not from trusting the chain of thought.
[2] When AI Aligns AI: Claude Trains Models to Behave
Putting Numbers on Code Slop
Estimated read time: 8 min
Passing tests are not reliable evidence either. Formally correct code can still be slop, and this piece tests ways to quantify it, landing on verbosity and erosion metrics that show agent-written code is roughly twice as bloated and complexity-heavy as established human repos.
Worth tracking: If you ship agent-written code daily, track verbosity and complexity concentration alongside tests, because a green suite says nothing about the mess quietly accumulating underneath.
Qwen3.8 27B Quantizations, Benchmarked for Real Tasks
Estimated read time: 8 min
Measurement runs the other direction too, toward how little you need. A $3,000 benchmark run tests Qwen3.8 27B quantizations on GPQA Diamond, IFBench, and Terminal-Bench 2.1, finding 4-bit Q4_K_M matches the full BF16 model while 1-bit collapses to random-guess territory.
The practical rule: Pick the largest model that fits your GPU alongside the context you need, and treat 4-bit as the safe default rather than a compromise.
TOOLS
The tools follow that thread into production: fast cheap models for routine calls, on-device models for the rest, and two systems that decide up front what an agent may improvise.
Mercury 2.5: A Diffusion LLM Built for the Calls You Make Hundreds of Times
Estimated read time: 4 min
If 4-bit is enough, a diffusion model may be too. Inception Labs’ Mercury 2.5 diffusion LLM hits 1,107 tokens per second with 260K context. Its production cases show latency is a product constraint, not an infrastructure detail, with Augment Code cutting compaction time 82% and cost 90%.
Where to use it: Route high-volume supporting calls like compaction, routing, reranking, and tool search to a fast cheap model, and reserve frontier models for the work that actually needs them.
Desert Ant Labs Bets on Small, On-Device Models
Estimated read time: 7 min
Going smaller still, a European lab launches 18 task-specific on-device models with Swift, Kotlin, and JavaScript SDKs, arguing the compute in people’s hands is already paid for. A 2MB language detector beats a 293MB one, and transcription runs 4.7x faster than Whisper.
The opportunity: For routine calls like transcription, redaction, or tagging, check whether a small local model does the job faster and free, then keep the API budget for harder work.
SWE-2: Training Every Effort Level in One RL Run
Estimated read time: 12 min
Cheaper can also come from smarter. Cognition’s SWE-2 post-trains Kimi K3 with reinforcement learning that tunes every reasoning-effort level in one run, using cost penalties matched to the Pareto frontier’s slope. It hits 50% on FrontierCode 1.1 while cutting turns 58%.
What’s interesting: The savings come from a model that skips over-exploration and starts editing sooner, not from a smaller model, which is a different lever than the effort dial you set yourself.
Open Code Review: Alibaba Open-Sources Its Internal AI Reviewer
Estimated read time: 7 min
Alibaba applies the same discipline to review, open-sourcing the AI code review CLI it ran internally for two years. It pairs deterministic engineering with agent decision-making, claiming higher precision than general-purpose agents on a 200-PR benchmark while using roughly a ninth of the tokens.
The design principle: Put hard engineering constraints around the parts of a workflow that must not drift, and let the agent handle only the judgment calls, which is where its tokens are actually worth spending.
Diagram Design: 39 Editorial Diagram Types as an Agent Skill
Estimated read time: 10 min
The same instinct, encode what must not drift, shows up in an Agent Skill that ships 39 editorial diagram types as self-contained HTML and SVG, no Mermaid required. Brand tokens pulled from your website in 60 seconds set palette and fonts, with WCAG contrast checks and accessible SVG labels built in.
Worth trying: If your agent keeps producing generic rounded-box diagrams, install a skill that encodes layout grammar and brand tokens once, instead of re-prompting for style every time.
NEWS & EDITORIALS
The editorials ask what produced the number: a benchmark that swings on its harness, robot demos that hide the failure cases, a math result that raises a training-data question, and a developer measuring their own thinking.
Same Model, Two Scores: The Harness Behind OpenAI’s 99.9%
Estimated read time: 7 min
Start with the headline number. OpenAI’s 99.9% ARC-AGI-3 score came from its own Provider Adapter, while the benchmark’s standard harness scored the same model 62.7%. The harness is the product now, and several published metrics shifted quietly after launch.
How to read it: When you compare model benchmarks, ask what scaffolding produced the number, because the harness can move a result further than any reasoning dial, and the shift is easy to miss.
Embodied AI’s Missing Corpus
Estimated read time: 12 min
The same question applies to robot demos. Vision-language-action models look impressive until scenes shift slightly and benchmark success rates fall from 90 percent to zero. The argument: robotics lacks a free training corpus, so value sits in bounded, well-instrumented deployments, not general-purpose promises.
What to ask for: Request perturbation results instead of demos, because a demo is a sample from the training distribution, and the bounded deployments with real instrumentation are where the value is.
When a Rumor Is Enough: OpenAI, Navier-Stokes, and Your Training Data
Estimated read time: 6 min
Returning to OpenAI, its unreleased model resolved Navier-Stokes days after rumors that another team, using OpenAI’s own tools, had already cracked it. The episode sharpens the question of what “used to improve models” really means for user data.
The context: Assume anything you put into a hosted coding agent may shape a future model, and plan your disclosure and publication timing with that in mind.
Two Weeks of De-Brainrotting
Estimated read time: 6 min
To close, one developer measures their own thinking. Eight years into a software career, the worry isn’t productivity but thoughts getting slower, less profound, lazier. The fix during a countryside vacation: four books, no doomscrolling, and calculus textbooks picked up purely for fun.
Why this matters: AI can raise your output while quietly weakening the deep-thinking habits that made you good, so schedule time that deliberately rebuilds them, the way you would any other skill.