Hello, and welcome to Altered Craft’s weekly AI review for developers. Thanks for reading, and for passing it along to your teams. This week’s pieces keep landing on one question: once agents write the code, where does the slow part go? Anthropic rebuilt code review and replaced Git to keep pace, decision models take on the small yes/no calls, and the news weighs what each agent loop costs before closing on Brooks’s Law.
TUTORIALS & CASE STUDIES
The tutorials open with two accounts of where the work goes once agents write the code: planning and review. Two guides to building the tooling around an agent follow, and a week with a decision model closes the section.
The AI-Native SDLC Playbook: Seven Pillars, Two Hard Numbers
Estimated read time: 12 min
Atlassian’s playbook maps seven pillars of AI-native software development, arguing that coding was never the real bottleneck: planning, design, review, and maintenance are. Internal data shows issue cycle time dropping from 11.5 days to 6.7.
Why this matters: Once agents handle the typing, output quality depends on the context you feed them and how you measure results. That shifts where your team’s effort pays off: planning, specs, and review.
How the Claude Code Team Reviews Code It Mostly Didn’t Write
Estimated read time: 14 min
Taking one of those stages, Anthropic’s Claude Code team rebuilt review for agent-speed output: six layers of automated checks, risk-tiered human approval, and past incidents turned into a daily eval. Merged PRs doubled while the revert rate fell over 40 percent.
The reframe: The useful question is no longer whether a human read the code. It is which check, automated or human, is best placed to catch each kind of failure.
Your Game Is a Harness: Making Game Projects Legible to AI Agents
Estimated read time: 39 min
Moving from checking the output to shaping the input, game development exposes what LLMs cannot see: assets, scenes, and engine state that never appear as code. The fix is making your game legible to agents through seeded randomness, screenshot APIs, and quantitative image diffing.
Try this: If your project’s important state lives outside the source code, build tools that expose it to the agent. Deterministic runs and screenshots give it something it can check.
Document Processing Agents That Learn Their Own Extraction Rules
Estimated read time: 11 min
Also building the system around the model, this walkthrough runs eight Strands agents on Amazon Bedrock AgentCore that classify, extract, and validate business documents, then save the corrected prompts for reuse, cutting a repeat purchase order from almost four minutes to 90 seconds.
The pattern: Save the fix, not just the result. When a corrected prompt is stored, every later document of that type skips the slow discovery step, which is where the time savings come from.
A Week Inside Jev: What a Non-Generative Decision Model Is Actually Good For
Estimated read time: 19 min
Building on our coverage of a hand-built single-pass decision model[1] last week, this hands-on week puts TypeSafe’s Jev into a real workflow. The viral “200x faster” claim misleads because Jev cannot generate text. Its guarantee is narrower: it cannot return an invalid answer, only a wrong valid one.
In practice: Use decision models for keep-or-drop and route-here-or-there calls, and set every threshold against your own labeled data rather than inheriting one from a vendor benchmark.
[1] Build Your Own Single-Pass Decision Model
TOOLS
The tools start with two decision models, Jev’s latest release and Microsoft’s first. Two looks at general models follow, then two pieces of agent infrastructure: a rebuilt harness and Anthropic’s new version control system.
Jev 1.14.0 and the “Danger Zone” Header
Estimated read time: 6 min
Following that hands-on week, TypeSafe ships Jev 1.14.0 with multimodal image support, a bounding-box type, and longer context behind opt-in “danger zone” API headers, separating experimental capability from production reliability rather than forcing one standard on every user.
Worth noting: Opt-in flags for experimental features let you try new capability without risking production traffic. Build evals for a flagged feature, and pin the model version, before you depend on it.
Microsoft-Decision-1: A Model That Only Makes Decisions
Estimated read time: 9 min
Microsoft enters the same category with Decision-1, a model built for routing, classification, and workflow control rather than text generation. The pitch: structured outputs software can act on immediately, at low cost, and 2.5x faster than the runner-up in Microsoft’s own benchmarks.
The opportunity: Many agent steps are really yes/no or which-bucket calls. Moving those to a decision model cuts latency and cost, and frees your LLM budget for the steps that need generation.
Meta’s Muse Wonder Bets on Memory and Focus
Estimated read time: 6 min
Shifting to general-purpose models, Meta introduces the Muse Wonder series, pairing Active Memory with Active Focus so agents retain personal context and persist through long tasks. Benchmarks cover legal, finance, health, and coding, plus gains on tasks never targeted in post-training.
What’s interesting: Meta measures how well gains carry over to tasks it did not target in post-training. That is a more useful signal than one benchmark score when you need an agent for varied, unfamiliar work.
10 Hugging Face Models Worth Knowing in 2026
Estimated read time: 12 min
On the open-weight side, with the Hub near 3 million repositories, this roundup picks ten models by adoption, licensing, and hardware cost, noting that access is no longer the problem, selection is, with runnable snippets throughout.
How to use it: Pick models by license and VRAM budget as deliberately as by benchmark score. The roundup’s snippets let you test a shortlist on your own hardware before you commit.
OpenCode 2.0: One Background Service, Code Mode, and 80+ Internal Plugins
Estimated read time: 6 min
Moving from models to the harness around them, OpenCode 2.0 is rebuilt on a single background service, a rewritten API, and code mode that turns MCP servers into callable functions, letting agents compose tools in one round trip instead of sequential calls.
What this enables: Code mode lets you connect many MCP servers without filling the context window. The agent writes one script that calls several tools, instead of making each call separately.
Anthropic Replaced Git With Scion
Estimated read time: 14 min
Continuing our look at tools rebuilt for agent users, like DuckDB’s agent mode[2] last week, Anthropic built Scion, a server-centric version control system, in five months after merge volume jumped from 2,500 to 30,000 changes per day. The bet: agents are always online, so clients need almost no local repo.
Why now: When agents write most of the code, merging, building, and testing become the slow steps. Expect infrastructure built for human pace to be the first place teams need to rethink.
[2] DuckDB’s Agent Mode: A CLI That Knows It’s Talking to a Robot
NEWS & EDITORIALS
The news opens with two pieces on what each pass through an agent loop costs. An inside history of Codex and one developer’s own account follow, and the edition closes on Brooks’s Law.
Are Behavioral Harnesses Worth the Cost?
Estimated read time: 15 min
A controlled experiment runs the same API build ten times per model, with and without a harness of contracts, mocks, and executable tests. For frontier models the harness adds cost without changing outcomes, but it lifts a cost-optimized one from 3 of 10 passing runs to 10 of 10.
The takeaway: Spend harness tokens where the model is unreliable. The harnessed budget model still cost 33 percent less per run than the flagship running without one.
The Expensive-Loop Problem
Estimated read time: 23 min
Where that experiment priced each run, this essay asks what happens when each loop is costly. LLMs do best in cheap-loop domains where feedback is quick, deterministic, and cheap, like computer-checkable code. Most high-value work runs on expensive loops, which demand skills models lack: choosing proxies, building theories, budgeting compute, and questioning their own premises.
A useful lens: Knowing which kind of loop a task sits in tells you how much to delegate. Where feedback is slow or costly, you supply the proxies, theory, and budget the agent lacks.
How Codex Happened
Estimated read time: 54 min
Coding is the clearest cheap loop, and this inside account of OpenAI’s coding agent traces its rise from a failed cloud launch to 40 million weekly users across Codex and ChatGPT for Work. The turn came when reasoning models made slow thinking an advantage instead of a flaw.
Why it worked: Coding agents improved fastest where they could run code and check results themselves. Delegating whole, testable tasks makes better use of them than line-by-line pairing.
The Old Job Is Drifting Into the Distance
Estimated read time: 13 min
From the developer’s side of that shift, a phase-by-phase account of AI-assisted coding runs from pasting Ruby specs into ChatGPT to supervising subagents with burndown charts, landing on a point where the hard part is choosing what deserves human attention, not reviewing every line.
Where to focus: As agents write more code, spend your review time on the parts that matter most: business logic unique to you, customer data, and anything irreversible, like database changes or encryption.
More Agents, Same Mythical Man-Month
Estimated read time: 15 min
Scaling the question to teams, Brooks’s Law gets a 2026 rewrite: cheap code moves the bottleneck to deciding, verifying, and coordinating. One study found multi-agent setups made sequential planning 39 to 70 percent worse, and AI amplifies whatever coordination an organisation already has, rather than supplying it.
Before you scale: Fix the review, specification, and decision steps that more agents will load up. Extra output only turns into value where your team can coordinate and absorb it.