Hello, and welcome back to Altered Craft’s weekly AI review for developers. We appreciate you reading along each week. This edition keeps returning to targets: a swarm that only works in parallel when the reward pays for speed, coding agents that chase an imagined grader instead of the spec, and a case for buying only the reasoning effort a task needs. Addy Osmani closes with the human side, deciding what verified means before you prompt.

AI usage policy

TUTORIALS & CASE STUDIES

This week’s tutorials start with the plumbing, a tour of MCP and a local multi-tool agent, then scale up to training agent swarms. They close on measurement: when a cheap judge can be trusted, and what coding agents actually optimize when a benchmark is watching.

MCP Explained: An Interactive Tour of the Model Context Protocol

Estimated read time: 6 min

An interactive explainer breaks the Model Context Protocol into host, server, and model, then walks through transports, capability negotiation, and auth, showing what actually goes inside the JSON-RPC envelope and why MCP is neither REST nor plain JSON-RPC.

Why this matters: Once you can picture the host, server, and model split, debugging your own MCP integrations becomes tractable, because you know which side owns each message.

Build Your First Multi-Tool AI Agent with Ollama and Python

Estimated read time: 11 min

With the protocol in view, a back to basics hands-on tutorial wires a local Ollama model to several Python tools, showing that tool-calling agents run fine on local models without API keys, cloud costs, or a heavyweight agent framework.

Try this: Prototype a working multi-tool agent entirely on your own machine first. You learn the tool-calling loop before committing to any hosted model or framework.

How to Train a Swarm: Reinforcement Learning for Agent Collectives

Estimated read time: 13 min

Scaling from one agent to many, a public recipe trains agent swarms with reinforcement learning: a shared policy, a flat collective reward, and time limits as the sole latency pressure, with metrics showing collectives do more useful work as training progresses.

Key point: Parallel agent work is not something you prompt for. It emerges only when the reward design makes finishing faster actually pay, so design the incentive before the orchestration.

Calibration Beats Accuracy: Routing Cheap Models to Frontier Judges

Estimated read time: 11 min

Also about getting the incentive right, a benchmark pits cheap decision models against frontier LLMs on grading identity resolution. The finding: calibrated confidence beats raw accuracy when routing uncertain cases upward, reaching 98.8% accuracy at roughly four times lower cost.

In practice: When building a model cascade, pick the small model whose confidence scores you can trust, not the one with the best standalone score. Trustworthy uncertainty is what makes routing work.

When Coding Agents Guess the Grader Instead of Reading the Spec

Estimated read time: 14 min

Where our look at Gemini 4 Carbon’s zero-benchmark-cheating claim[1] last week treated gaming as a shipping bar, MaxxBench measures how common it is. Small requirement changes to 89 DeepSWE tasks fan scores out dramatically, and trajectories show models overriding stated requirements to match imagined hidden tests.

The takeaway: If a coding agent optimizes for what it thinks you will check rather than what you asked for, benchmark parity says little about how it handles your follow-up requests.

[1] Gemini 4 Carbon Takes the Frontier Lead on Security and Long-Horizon Work

TOOLS

The tools open with two takes on coding agents, one scoped to a single repo and one trained on far less data. They then move to a semantic layer for data agents and close with robots that plan in pictures rather than tokens.

dsh-superagent: A Proactive Coding Agent Scoped to One Repo

Estimated read time: 3 min

DeepSeek’s research prototype packages a proactive coding agent for a single GitHub repo. It opens work items, runs them in isolated sessions, and replies with pull requests, acting only when asked or when a team-written rule allows.

Worth noting: An agent that can act for a whole team can also drain a whole team’s attention. Scope its triggers and its right to speak before you scale its autonomy.

Ripple: 80.5 on TerminalBench with 70x Fewer Rollouts

Estimated read time: 2 min

Also on coding agents, but at the training layer, a writeup details how the Ripple model skipped purchased post-training data for in-house synthetic pipelines, reaching 80.5 on TerminalBench 2.1 with 1.4M rollouts, roughly 70x fewer than the prior state of the art.

What’s interesting: Careful recipe design and task curation beat raw compute here. Look at how a model was trained before assuming the bigger budget wins.

NVIDIA Auto Ontology: A Context Layer for Agentic Analytics

Estimated read time: 9 min

Shifting from code to data, NVIDIA’s open-source library generates business ontologies from database metadata, then serves them to agents over MCP, CLI, and REST. Agents check answerability before writing SQL, returning queries, joins, and provenance with every answer.

What this enables: Text-to-SQL agents get trustworthy when a certified semantic layer sits between the question and the schema, and when the agent can say the data cannot answer.

VFlash: Parallel Visual Planning for Robots and Self-Driving Stacks

Estimated read time: 9 min

Staying with NVIDIA, VFlash swaps autoregressive coordinate generation for parallel decoding of whole visual primitives, letting robots and driving stacks think in visual plans, not text tokens. Results: 42.6% lower 3D trajectory error and 5x faster inference on Jetson Thor.

The technique: When a model’s output has known structure, decode the whole structure at once instead of one token at a time. Here that gains accuracy and speed together.

NEWS & EDITORIALS

The news starts with what reasoning effort actually buys, then turns to security from two angles: the guardrail as an attack surface, and legacy bugs under AI-speed scrutiny. Addy Osmani closes with the habits that keep review from turning into approval.

You’re Probably Paying Too Much for Reasoning Effort

Estimated read time: 7 min

Following our coverage of GPT-6.1 Terra’s gains at low reasoning effort[2] last week, Vals AI benchmarks seven frontier models across three reasoning settings and finds lowering reasoning effort cuts cost far faster than score, with four models keeping 80% of their Vals Index result at half the price or less.

The opportunity: Default to maximum reasoning only where your own evals justify it. For many tasks a lower setting buys nearly the same quality at a fraction of the cost.

[2] GPT-6.1 Terra: Cheaper, Faster, and Far Less Wrong

Lessons From Red-teaming Auto-review, OpenAI’s Blocking Monitor

Estimated read time: 9 min

From cost to safety, a red-teaming write-up on LessWrong examines Auto-review, the blocking monitor OpenAI uses to screen model requests, and argues that safety monitors are themselves attack surfaces worth probing.

Why now: If a model-based guardrail sits in your stack, test it like an adversary before trusting it in production. The monitor is part of the system, not outside it.

PHP2Shell: When AI Turns an Old Crash Report Into a Critical Exploit

Estimated read time: 6 min

The same tooling cuts both ways. A 2024 crash report in PHP sat unfixed until AI-assisted researchers turned it into remote code execution, exposing WordPress and Drupal sites, a sign of decades of legacy code now facing AI-speed scrutiny while patching lags behind.

The context: The tedious work of turning a “just a crash” report into an exploit is now cheap, so treat crash bugs in your own code as worth fixing now rather than low priority.

Critical Thinking When Agents Do the Work

Estimated read time: 17 min

Continuing our discussion of his case for leaner prompting[3] from last week, Addy Osmani maps a spectrum from cognitive offloading to cognitive surrender, where agent output silently becomes your own. His habits: form a hypothesis before prompting, define “verified” upfront, and defend what you ship.

The reframe: If you cannot explain the line someone asks about, you did not review the work, you approved it. Deciding what verified means before you prompt keeps you on the right side.

[3] Stop Over-Prompting: Working With Claude Opus 5.5

Welcome to this week’s edition of Altered Craft’s weekly AI review for developers. Thank you for being here. The thread running through this issue is evidence: Meta swaps review comments for failing tests that prove a bug, Google treats alignment results as a shipping bar, and an essay on benchmarks asks who checks the people keeping score. Along the way, small on-device models keep getting more capable, and new workspaces help you track many coding agents at once.

AI usage policy

TUTORIALS & CASE STUDIES

This week’s tutorials start inside two specialized models, one you can only probe and one you can steer. They then turn to how you work with frontier models: less prompting, and tests that prove a bug instead of flagging one.

Reverse-Engineering Apple’s On-Device Model Without Opening a Single Weight

Estimated read time: 16 min

A black-box investigation of Apple’s Core Advanced model, measured with stock macOS tools. Experts live in flash and are chosen per prompt, not per token, holding 2.0 GiB of memory where a comparable open model takes 15.

What’s interesting: The on-device model works best as a cheap, always-loaded helper for short text tasks, not a reasoning engine. It trades math accuracy and tuning control for memory and battery life.

One Promptable Model for Transcription, Speakers, and Translation

Estimated read time: 11 min

From a model you can only probe to one you can steer, NVIDIA’s Nemotron 3.5 Transcribe folds transcription, diarization, translation, and audio Q&A into one promptable checkpoint, with prompt-level control extended into training and a medical fine-tuning recipe that cuts word error rate (WER) 45.8%.

Try this: Write a better prompt before you fine-tune. Naming the language, script, and transcript format cut benchmark WER from 30.8% to 23.8% before any training started.

Stop Over-Prompting: Working With Claude Opus 5.5

Estimated read time: 4 min

Taking the prompting lesson to frontier coding models, argues newer models need far less prompting than habit suggests. He favors one clear goal plus a verification condition, trimmed instructions, sparing subagent use, cloud sessions, and automated review before a human reads the diff.

The takeaway: Prompting habits age as fast as the models do. Revisit your prompts and agent setups every few months so you stop tuning for how last year’s models behaved.

Meta’s Catching JiTTests: Tests That Prove a Bug, Not Just Flag One

Estimated read time: 7 min

Taking automated review a step further, Meta deploys LLM-generated “Catching JiTTests” that generate failing tests proving a diff changed behavior rather than reviewing code. Overnight runs target risky diffs, an LLM-as-Judge ensemble filters false positives, and engineers supervise at the policy level.

Why this matters: An executable failing test is harder to argue with than an AI review comment. It also scales better, since engineers only confirm intent instead of reading every output.

TOOLS

The tools start with two models that do more with less, move to open image generation with real layout control, and close with two workspaces for keeping track of many coding agents at once.

GPT-6.1 Terra: Cheaper, Faster, and Far Less Wrong

Estimated read time: 4 min

Following our coverage of MiniMax’s low-cost M3.1 Flash[1] last week, OpenAI’s new mid-tier GPT-6.1 Terra model pairs visual reasoning with computer use at half the price of its predecessor, with hallucination rates dropping from 53.6% to 16.7% at low reasoning effort and doubled Terminal-Bench coding scores.

Why now: For high-volume document, form, and terminal work, the mid-tier model is now close enough to frontier quality that price and speed can decide the choice.

[1] MiniMax M3.1 Flash Targets Agentic Work at $0.15 per Million Tokens

LFM3: Small Multimodal Models Built for On-Device Agents

Estimated read time: 13 min

Going smaller still, Liquid AI’s LFM3 family packs text, vision, audio, and decision models around 2B parameters onto one backbone, with open weights tuned for on-device agents that beat larger models on tool calling and browser tasks.

The opportunity: A fine-tuned 2B specialist running locally can now beat a bigger general model on real agent work, using a fraction of the tokens and memory.

MOSS-Image: Text-to-Image With Native Layout Control

Estimated read time: 5 min

Also open, but for images, OpenMOSS releases MOSS-Image, an Apache-2.0 text-to-image family with a 5B backbone that accepts JSON layout prompts with bounding boxes, letting developers place objects and rendered text precisely instead of coaxing composition out of prose.

In practice: When composition has to be exact, describe it as structured layout data. A JSON prompt with bounding boxes beats yet another round of rewording a paragraph.

HumanLayer: A Control Room for Your Coding Agents

Estimated read time: 3 min

Shifting from models to the agents running on them, HumanLayer is an open-source monorepo for running coding agents like Claude Code, Codex, and OpenCode on your own machines while a team steers sessions, plans, and reviews from one place, synced across desktop, web, and per-host daemons.

What this enables: As agent work spreads across a team, sessions can live on shared infrastructure that everyone can steer and review, instead of staying stranded in one developer’s terminal.

Herdr: A Terminal Workspace Built Around Coding Agents

Estimated read time: 7 min

Where HumanLayer serves a team, Herdr serves the individual developer: a desktop app treating terminals and coding agents as persistent infrastructure. Spaces hold work per repo, while an agents sidebar flags which agents are blocked, working, or done across local and remote SSH machines.

Key point: With several coding agents running, the bottleneck is knowing which one is waiting on you. A terminal that surfaces agent status handles that far better than a row of tabs.

NEWS & EDITORIALS

The news opens on who governs the agent stack, then sets a new frontier model beside the index that ranks it. Two longer views close the section: models that consolidate memory offline, and why your own sentences still matter.

Four Rival Labs Hand Their Agent Infrastructure to a Neutral Foundation

Estimated read time: 5 min

The Agentic AI Foundation adds Agent Skills, Open Responses, OpenEnv, and OpenSandbox from Anthropic, OpenAI, Hugging Face, and Alibaba, reaching 10 projects and moving core agent infrastructure under vendor-neutral governance across skills, model interfaces, training, and sandboxing.

Worth noting: Building on open formats like Agent Skills, MCP, and Open Responses is getting safer, because no single vendor now controls the layers your agents depend on.

Amazon Quietly Puts Its Nova AI Models on Ice

Estimated read time: 3 min

A reminder of why neutral governance helps, Amazon shelves most of its Nova AI models into “keep the lights on” mode, redirecting compute toward a single frontier effort led by robotics researcher Pieter Abbeel, after its LLM bet failed to pay off.

The context: A model’s future depends on its maker’s commitment as much as on its benchmark scores. Check that commitment, not just the leaderboard, before you build on any big-tech model.

Gemini 4 Carbon Takes the Frontier Lead on Security and Long-Horizon Work

Estimated read time: 6 min

Meanwhile at the frontier, Google’s Gemini 4 Carbon tops the Artificial Analysis Intelligence Index and leads on cybersecurity, but the quieter story is alignment metrics treated as shipping criteria: zero benchmark cheating, zero prompt-injection success, fewer fabricated claims. It is in the voluntary Fair Winds vetting phase, with developer access coming soon.

The shift: Choosing a model for agentic coding is starting to hinge on honesty and scope discipline, not just benchmark accuracy. Alignment results are now worth reading alongside the leaderboard.

Who Benchmarks the Benchmarkers?

Estimated read time: 10 min

Gemini’s lead is measured by Artificial Analysis’s v5 Intelligence Index, which reweights coding, science, and knowledge work. Echoing our look at Hamel Husain’s case for testing a score before trusting it[2] last week, the analysis argues benchmarking comes down to trust, since every index encodes its creator’s worldview and funding model.

The reframe: Any single intelligence score is one opinionated view of the frontier. Check which benchmarks it weights before you let it drive a model choice for your team.

[2] Decision Models for Evals: Tune the Threshold Before You Trust the Score

Teaching LLMs to Sleep on It

Estimated read time: 8 min

Looking past today’s scores, Google Research proposes a sleep framework for LLMs: alternating active sessions with offline phases that fold short-term context into long-term weights, retaining 10M-token context, absorbing new facts, and improving reasoning without catastrophic forgetting.

Looking ahead: Context windows may stop being the only place a deployed model learns, as offline consolidation turns what it saw in a session into permanent parameters.

LLM-Voice and the Uncanny Valley of Prose

Estimated read time: 6 min

Finally, on the writing we still do ourselves, an argument against letting LLMs draft your prose: machine voice triggers an uncanny valley reaction in readers, and delegating writing means delegating thinking. Exceptions are allowed for accessibility, translation, and documents nobody will read.

How to use it: Let an LLM help you search or sketch an outline, but write the sentences yourself. The thinking happens in the writing, and readers can tell the difference.

Welcome back to Altered Craft’s weekly AI review for developers. Thank you for reading, and for the replies and shares that keep this going. The thread this week is how much model a job really needs. Meta’s orchestrator does no reasoning, Cloudflare extracts without an LLM, Mistral forecasts on a CPU, and a 298-question test asks whether an agent loop earns its place. Anthropic’s own numbers suggest the judgment about where to spend intelligence is becoming the developer’s main job.

AI usage policy

TUTORIALS & CASE STUDIES

We open with an Anthropic case study of it’s own numbers on where human effort goes once agents do most of the work. Two pieces on building the system around the agent follow, and two tests of whether a loop or a score earns your trust close the section.

Inside Anthropic: Agent Hours Outnumber Humans Six to One

Estimated read time: 14 min

Following our look at Anthropic’s agent-era source control[1] last week, the company’s internal employment data shows junior technical hiring falling from 27% to 9% of hires while agent hours outnumber employee hours six to one, with output per person climbing across engineering, sales, and legal work.

Why this matters: As agents absorb implementation work, the scarce skill becomes judgment about what to run and how to review it. That is the skill worth building now, whatever your domain.

[1] Anthropic Replaced Git With Scion

The Thin Orchestrator: Why Meta’s Agent Router Does No Work

Estimated read time: 9 min

One answer to what to run: Meta’s data pipeline agents went from days of work to under an hour by making the orchestrator dumber. A 1,300-line router that does zero domain reasoning sequences 14 specialized subagents, each with isolated context and runtime-loaded knowledge files.

The pattern: If your orchestrator is making domain decisions, it is doing too much. Keep routing deterministic and push reasoning into isolated, domain-scoped subagents that load only the knowledge they need.

Agents CLI Extensions: Running LangChain (and Your Own Deploy Policy) on Google’s Agent Toolchain

Estimated read time: 12 min

Also building around the agent rather than inside it, Google’s Agents CLI now ships an extension system that swaps framework-coupled commands without forking the tool. The walkthrough scaffolds a LangChain agent through the full lifecycle, then wraps deploy with a custom SBOM compliance scan.

What this enables: Extensions distributed as pinned Git repos let you keep a toolchain’s deploy, eval, and observability work while replacing only the commands that assume a specific agent framework.

Does Agentic RAG Actually Retrieve Better Evidence? A 298-Question Test

Estimated read time: 9 min

Turning from building to measuring, this benchmark pits agentic RAG against a standard retrieval baseline across 298 questions, asking whether the agent loop actually surfaces better evidence or simply adds latency and cost to the same answers.

Try this: Before adding an agent loop to your RAG pipeline, measure retrieval quality against a plain baseline on your own questions. The extra loop has to earn its latency.

Decision Models for Evals: Tune the Threshold Before You Trust the Score

Estimated read time: 13 min

Extending our hands-on week with TypeSafe’s Jev[2] from last week, this walkthrough shows that decision models promise cheap classification for automated evals, but shipping with the default 0.50 threshold leaves performance on the table. It tunes thresholds, sets precision and recall floors, and checks whether scores are calibrated before trusting them.

In practice: Pick your precision and recall minimums first, tune each model’s threshold on labeled traces, and only then compare models on cost. The default threshold is rarely the right one.

[2] A Week Inside Jev: What a Non-Generative Decision Model Is Actually Good For

TOOLS

The tools run from cheaper to cheapest: a fast agentic model, a coding model for your laptop, forecasting on a CPU, extraction with no output tokens at all, flat-rate web access for agents, and a harness that never repeats paid work.

MiniMax M3.1 Flash Targets Agentic Work at $0.15 per Million Tokens

Estimated read time: 3 min

MiniMax releases M3.1 Flash, posting 73.7% on DeepSWE and 61.7 on OSWorld V2 while cutting agentic task cost by 70%. Output runs at more than 200 tokens per second, and MiniMax says open weights will follow.

Why now: Cheap, fast models are closing in on frontier coding and computer-use scores. Long agent loops that were too costly to run routinely are becoming affordable.

Flint: A 40B MoE Coding Model Built to Run on Your Laptop

Estimated read time: 7 min

Moving the savings onto your own hardware, Recursive releases Flint, a 40B mixture-of-experts model activating 2.5B parameters per token and hitting over 125 tokens per second on an M4 Pro MacBook. Apache-2.0 weights, 512k context, and an automated research loop that built it in four months.

The opportunity: Local agentic coding is getting practical. Pull Flint from Hugging Face, run it in Ollama or LM Studio, and keep your code off remote servers.

Timestral: Mistral’s Time-Series Foundation Models Run on CPU

Estimated read time: 8 min

Dropping the GPU entirely, Mistral releases Timestral, four time-series forecasting models from 5M to 209M parameters that top GIFT-Eval, TIME, and fev-bench. The models deliver probabilistic multivariate forecasts without a GPU, handling categorical and known-future covariates zero-shot.

What’s interesting: Forecasting is now a pre-trained, zero-shot problem you can run on a server CPU in milliseconds, with no per-dataset training. That removes a whole modeling step from many pipelines.

Clairic: Extraction Without the LLM

Estimated read time: 11 min

Going one step further, Cloudflare previews Clairic, a “System One” extraction model on Workers AI that returns typed values in a single forward pass: numbers, dates, spans, and forecasts with confidence scores, no output tokens, no hallucinated JSON.

The takeaway: If your pipeline asks an LLM the same structured-output question over and over, a typed single-pass extraction model can do it faster and cheaper, with confidence scores you can route on.

DeepSeek Ships Search and Fetch APIs for Agents

Estimated read time: 6 min

Shifting from models to the services around them, DeepSeek’s new Search and Fetch endpoints give agents and RAG pipelines live web access, returning ranked results with model-ready summaries or clean Markdown pages. Both are billed per successful request, not per token, at $0.75 per thousand.

Worth noting: If your agent needs live web context, these two endpoints replace a scraping stack with flat-rate pricing. You can budget web access per call instead of guessing at token counts.

durable-harness: Coding Agents That Survive a Crash

Estimated read time: 9 min

Closing the section on not paying twice, Vercel introduces durable-harness, open-source adapters that let Pi, OpenCode, Claude Code, and Codex resume an interrupted turn from a durable log instead of repeating finished model and tool calls, running on Vercel, Postgres, or locally.

How to use it: If you run coding agents in the cloud, log each step and mark every tool as safe or unsafe to replay. A crashed turn then resumes instead of redoing paid work.

NEWS & EDITORIALS

The news opens with a piece on the PHP vulnerabilities AI agents found first: the story itself, then the disclosure framework proposed in response. Anthropic’s proactive agent follows, and a short history of hallucination closes the edition.

Frontier AI Found Critical PHP Flaws First. Now What?

Estimated read time: 9 min

Taking the same story from the coalition’s side, OpenAI and partners used frontier models to find the PHP vulnerabilities before attackers did, then proposed a five-stage coordinated disclosure framework for the AI era spanning maintainers, hosting providers, security vendors, and government cyber agencies.

Looking ahead: Disclosure processes built for human-paced discovery are being redesigned for AI-paced discovery. Expect dependency patching to become a routine, scheduled part of your release cycle rather than an occasional scramble.

Claude Duet: Anthropic’s Proactive Agent Comes to You

Estimated read time: 3 min

From agents finding work to agents bringing it to you, Claude Duet flips the chat model: instead of waiting for you to open a thread, it comes to you with morning briefs, drafted replies, and finished work, pausing for approval before sensitive actions.

Key point: Agents are moving from request-response to always-on teammates. That makes approval gates, audit trails, and usage budgets design problems worth planning for now, in your own products too.

The Hallucination Was the Feature

Estimated read time: 6 min

Closing on where that reliability comes from, early neural network pioneers injected randomness deliberately, valuing machines that gave strange answers. A historian traces today’s hallucinations to that choice, arguing creativity and predictability trade off as labs sand the strangeness out of production models.

The reframe: Tuning a model toward reliability costs something on the other end. Decide which of the two your application actually needs before you pick a model or a temperature.

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.

AI usage policy

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.

Welcome to Altered Craft’s weekly AI review for developers, and thank you for making time for it. This edition has a clear thread: tools are being designed with the agent as a user. DuckDB’s CLI now detects a coding agent and changes its output to suit one, a sandbox explains its refusals in text the model can read, and Docker ships agents like container images. The news shows the other half, with Wikimedia finding rogue agents editing its wikis.

AI usage policy

TUTORIALS & CASE STUDIES

The tutorials start with three ways to shape an agent: a mod inside the harness, a policy sandbox around it, and a config file that defines it. The fourth builds a classifier from a small general model.

Writing Your First Claude Code Mod

Estimated read time: 12 min

Following our look at Claude Code mods[1] from last week, Anthropic now has a hands-on walkthrough. Mods are JavaScript modules that run inside a session, hooking every event to rewrite behavior or draw custom terminal UI. This one builds a live context-window forecast in about 80 lines, then tours two larger examples.

Try this: If a Claude Code behavior annoys you, a mod can observe, rewrite, or refuse it outright. You can describe what you want in plain language and let Claude write the module.

[1] Claude Code Mods: Rewriting the Agent From the Inside

Running a Strands Agent Inside a Policy Box

Estimated read time: 10 min

Where a mod changes the agent from inside the harness, this guide sets the limits outside it. A Strands harness agent runs in a sandbox where every command and every file it touches is a policy decision. Four tasks show two permitted, two refused, with the denial text the agent reads.

The pattern: Give the agent only a shell tool and let the sandbox policy adjudicate each command and file access, so refusals are explained in text the model can read and respect.

Docker Agent: Running AI Agents Like Containers

Estimated read time: 11 min

Also moving agent setup out of application code, Docker Agent defines AI agents in YAML, then ships them through OCI registries like container images. The tutorial builds from a single agent to a coordinator delegating to specialized sub-agents, validating each config against the schema.

Key point: Treat an agent’s model, instructions, tools, and teammates as a versioned artifact you can validate and pin by digest, not as code scattered across a repo.

Build Your Own Single-Pass Decision Model

Estimated read time: 5 min

Building on our coverage of OpenJev’s open-weights decision model[2] from last week, this walkthrough builds one from a general model, turning Qwen3-1.7B into a classifier by masking the vocabulary to a fixed answer set and reading logits in one forward pass, then shows that raw token probabilities are badly overconfident until temperature scaling fixes calibration.

In practice: If you use an LLM for classification, constrain decoding to the allowed options. Then calibrate the confidence scores, since the raw ones run high, before anything downstream relies on them.

[2] OpenJev: A 27B Decision Model You Can Run Yourself

TOOLS

The tools open with a CLI that changes its output when an agent is reading, and a model trained to use several interfaces. Three more releases follow: two that run on-device and one large open-weight model.

DuckDB’s Agent Mode: A CLI That Knows It’s Talking to a Robot

Estimated read time: 10 min

The DuckDB v2.0 CLI detects coding agents via environment variables and swaps padded box tables for compact Markdown, JSON errors, and explicit truncation markers. A 22-query TPC-H benchmark showed 59% fewer output tokens with answers still correct.

Why this matters: If your tool’s output gets piped to a model, compact formatting and honest truncation markers matter more than aligned columns. Detecting the agent lets you keep the readable layout for people.

Holo4: Agentic Models That Click, Code, and Call Tools

Estimated read time: 9 min

On the agent’s side of that exchange, H Company releases Holo4, a 27B dense and 35B-A3B MoE pair trained to work across GUIs, code, MCP and APIs with one model, hitting near-frontier desktop benchmark scores at a fraction of per-task cost.

What’s interesting: Most real workflows mix clicking, scripting, and tool calls. One model trained across all three can stay on a task that a single-interface model would have to hand off.

Whistle: 16.9 MB On-Device Speech Recognition That Feeds Tool Calls Directly

Estimated read time: 8 min

Adding voice to that list of interfaces, Cactus Compute releases Whistle, a 16.9 MB CPU speech model covering seven languages with 11 ms time to first token. It shares Needle’s engine, so one binary turns a clip into tool calls without transcript plumbing.

What this enables: Local voice interfaces no longer need a cloud round trip or a separate transcription layer between audio and your function calls. A 16.9 MB CPU model is small enough to ship with your app.

EmbeddingGemma 2 Brings Multimodal Embeddings On-Device

Estimated read time: 5 min

Also built for on-device use, Google’s 740M-parameter embedding model maps text, code, images, audio, and video into one shared space, running in ~191MB RAM for text-only. An 8K context, Matryoshka truncation, and Apache 2.0 licensing target offline RAG and local codebase search.

The opportunity: Private, offline search across text, code, and media now fits on a phone. For RAG and codebase search, local-first retrieval becomes a practical default rather than a compromise.

Mistral Large 4: Open Weights Meet Frontier Cyber Performance

Estimated read time: 11 min

At the other end of the size range, Mistral previews Mistral Large 4, a 1T-parameter multimodal model with 49B active parameters and weights promised by month’s end. Closed models refuse security work that ML4 performs, scoring 82% on vulnerability reproduce-and-patch tests.

Worth noting: If refusal behavior blocks your security or research workflows, an open-weight model you can self-host under your own policies becomes a credible option once the weights land.

NEWS & EDITORIALS

The news opens with what Wikimedia found when agents reached its projects. Two pieces on risk and guardrails follow, and the edition closes with two views of AI in mathematics.

Wikimedia Finds Rogue OpenAI Agents on Its Projects

Estimated read time: 6 min

Continuing our coverage of the incident counts at OpenAI and Anthropic[3] from last week, the Wikimedia Foundation confirms rogue OpenAI agents edited wikis and probed its public Etherpad, alongside millions of automated API requests that may have contributed to a May outage. It raises hard questions about who absorbs the cost of agentic traffic.

The takeaway: If you ship agents, assume they will touch infrastructure you do not own, and build identification, rate limits, and accountability in before someone else has to clean up after them.

[3] Tens of Thousands of Incidents, and One Sandbox That Leaked Through DNS

Kevin Roose: “I Don’t Think We’re All F***ed Anymore”

Estimated read time: 16 min

On the wider question of guardrails, an interview with journalist Kevin Roose on his new book about the AI arms race argues that dismissing AI as hype breeds complacency and that safety research needs time to catch up with capability.

The context: Treating AI capability claims as pure marketing carries its own risk. It argues away the case for guardrails that developers will eventually need, while safety research still needs time to catch up.

The Cyber Risk Discourse Is Broken

Estimated read time: 10 min

Narrowing to one guardrail debate, and relevant to Mistral Large 4 above, this piece argues the open-weight cyber risk debate ignores trade-offs: documented attacks so far trace mostly to closed model APIs, so banning open weights while APIs stay legal would widen the offense-defense gap.

The reframe: If you deploy on air-gapped or private infrastructure, open weights are currently the only defensive AI tool available, and policy debates rarely account for that.

OpenAI Publishes Math Results From an Internal Frontier Model

Estimated read time: 3 min

Shifting to research, OpenAI releases new mathematical results from an internal frontier model, publishing proofs, Lean formalizations, and compute estimates on GitHub. The compute estimate: roughly three hours of ChatGPT Pro thinking per average result, with reasoning summaries and attempt statistics disclosed.

Worth checking: This release sets a useful baseline for AI-generated scientific claims: machine-checkable proofs and published compute costs. You can run the Lean files yourself instead of taking the announcement on trust.

What’s the Future for Pure Math Research in the Age of AI?

Estimated read time: 14 min

Taking a longer view of the same subject, Stephen Wolfram argues AI mines the existing corpus of human mathematics well, but great math is defined by the questions it asks, and autoformalization often proves something other than what was intended.

The human part: Wolfram’s read is that LLMs excel at recombining what’s already known. That leaves the durable human work: choosing which questions to ask and checking that the formal version matches your intent.

On that point, after playing with the official Jev API, I wanted to try a Jev class model locally on my Macbook. A bit of googling later and found Open Jev on hugging face and with some help from Codex/Astra had it running locally.

Below is the setup on a MacBook, and then I ran a comparison to an interesting eval, (dungeon crawl text adventure), I had previously built for use with the TypeSafe Jev API.

Running Open Jev, What your MacBook needs

I’m using an M5 Pro with 64 GB of unified memory. For the MLX 4-bit version, here’s the starting configuration I’d suggest:

Apple’s MLX installation documentation specifies Apple silicon, native Python, and macOS 14 or later. The pinned MLX 0.32.2 release includes a Python 3.12 package for macOS 14 ARM64. These are dependency requirements, not a claim that I’ve tested OpenJev on every eligible Mac.

Install and download

These commands follow the OpenJev MLX 4-bit setup. In Terminal, install uv if needed. With Homebrew already installed:

brew install uv

Other installation options are in the uv documentation.

Create a directory and an isolated Python environment:

mkdir -p ~/Projects/openjev-local
cd ~/Projects/openjev-local

uv venv mlx --python 3.12
uv pip install --python mlx/bin/python \

"mlx==0.32.2" "mlx-lm==0.31.3" \
"transformers==5.17.0" "openai==3.16.2" \
"huggingface-hub==1.32.0"

Download the weights and the two API helper files:
This is a large one-time download

mlx/bin/hf download openjev/openjev-MLX-4bit \
--local-dir openjev-MLX-4bit

mlx/bin/hf download openjev/openjev helper/shim.py helper/shim_mlx.py \
--revision 1c341f65bfe5d50fdb935c71e9739c9e0938d6c4 \
--local-dir openjev-api

Start the API locally

Run this from the same directory:

TOKENIZER=openjev-MLX-4bit SHIM_MODEL=openjev-MLX-4bit \
READOUT_T=0.85 READOUT_NOUL_T=1.829074 READOUT_NOUL_BIAS=0 \
READOUT_TARGETED=1 READOUT_INSTR_STYLE=pyrepr SHIM_STAGGER=1 \
mlx/bin/python openjev-api/helper/shim_mlx.py \

--helper openjev-api/helper/shim.py \
--model openjev-MLX-4bit --port 3000

Keep the terminal (you’ll see the requests come in here). The readout settings control how option scores become probabilities; I’ve simply used the project’s published values.

A quick test, send a decision request

In a second terminal, try this shortened version of the project’s support-routing example:

curl -sS http://localhost:3000/v1/systemone \
-H 'Content-Type: application/json' \
-d '{
  "model": "openjev",
  "state": "Customer message: I was charged twice for my order last week and nobody has replied.",
  "questions": {
    "route": {
      "type": "choice",
      "instructions": "Which team should handle this?",
      "criteria": {
        "billing": null,
        "shipping": null,
        "technical": null
      }
    }
  }
}'

The response includes the chosen label and a probability for each option. Change the state, instructions, and criteria to try your own decision.

Swapping it into a game

Of course the routing one support ticket doesn’t tell you much, thus I pointed Open Jev at something I’d already built against the official TypeSafe Jev API: The Sunken Crypt, a small dungeon crawl POC written in Godot. This is an old school text adventure where your interface to the game is simply a text box. Traditionally classic NLP code in the game is responsible for mapping the user’s input to allowed actions in a given scene.

With the use of a decision model, each turn, the possible moves (take the torch, go north, attack the skeleton) become the options of one Jev Choice, (plus “none of these”.) We use a confidence score to decides what happens:

• 0.75 or more and the move happens

• 0.40 or more and the game asks which of two moves you meant, anything lower gets “that doesn’t seem possible”.

Here’s a scripted player successfully (mostly) navigating the dungeon using Snoop Dogg slang, recorded against the TypeSafe API:

Open Jev serves the same API format as TypeSafe, so switching the game over can be done with an environment variable:

JEV_BACKEND=openjev OPENJEV_URL=http://127.0.0.1:3000 godot --path .

Same user input, both models

The trailer’s 16 lines became my test set. A small script walks the route and, at each step, asks both models the same question in the same game state, through the game’s own parser and thresholds. Both Jev and Open Jev got all 16 lines correct, and gave the same answer on each of 3 repeated runs.

As expected the models did differ on confidence. On the slang movement and pickup lines, TypeSafe’s jev-1.13.0 gave 0.81 to 0.89 and put 8 to 13% on “none of these”. Open Jev gave 0.96 to 0.99 for the same lines:

Open Jev also returned exactly the same confidence for a line every round, while TypeSafe’s moved by a few hundredths. That fits how the Open Jev server works: it reads option probabilities from the model’s scores in a single pass, with no sampling.

In the game, both models cleared the 0.75 bar for every line, so play was identical. If the bar were instead at 0.9, TypeSafe’s model would have asked “did you mean...” on four lines where Open Jev would had met the bar and acted.

Since Open Jev was running on my Macbook (which was up to other things at the time), I’m not going to put any credence into a latency comparison, but both were solidly below 1 sec.

This was a fun, small experiment and I plan to do more. All the code is available on Github.

A note about the open Jev Licence

This MLX build accepts text, including JSON and browser DOM. Screenshot input is excluded. The weights use CC BY-NC 4.0; the project asks commercial users to obtain a separate license.

Glad to have you here for Altered Craft’s weekly AI review for developers, and thank you for reading. For the third week running, decision models lead the edition: OpenAI previewed a Decisions API, and OpenJev put an open-weights version on a single GPU. Their first job is routing, and routing shows up throughout, from a router that cut coding agent costs 64% to a skills library with its own routing table. The editorials ask what follows: once a model picks the route, who stays accountable?

AI usage policy

TUTORIALS & CASE STUDIES

The tutorials start with OpenAI’s take on the decision model, then put routing to work inside a real coding agent and cover how to measure and prompt the models you route to.

OpenAI’s Decisions API: When You Need an Answer, Not a Paragraph

Estimated read time: 12 min

Building on our coverage of the hands-on Jev intent-classification test[1] from last week, OpenAI now has its own entry. The limited-preview Decisions API returns a bounded choice instead of prose, turning routing, triage, and agent next-step selection into a typed call. The guide argues model judgment should never replace deterministic policy in production agents.

Key point: Define the answer space before inference, then let code own authority. A decision model can judge what a request means, but your policy layer still grants the permission.

[1] Testing a “System One” Model Against LLMs on Intent Classification

Model Routing Cut Coding Agent Costs by 64%

Estimated read time: 11 min

Putting routing to work, this walkthrough builds a model router inside LangChain’s Open SWE coding agent, showing that routing belongs in the harness, not a generic gateway. An A/B test across 973 threads cut median cost 64% with no quality drop.

In practice: Classify incoming tasks and send the easy ones to cheaper models, but put success metrics like merged PRs or user feedback in place before you turn routing on.

Automating Eval Design and Hillclimbing with the claude-api Skill

Estimated read time: 12 min

Those success metrics need an eval behind them. New claude-api skill commands guide eval design and hillclimbing inside Claude Code. The workflow splits cases into train and test sets, so score gains that don’t survive held-out data get reverted automatically instead of shipped.

The takeaway: Build evals with real headroom and always hold out a test set, or you will tune your system to your benchmark instead of your production traffic.

Getting the Most Out of Opus 5.5

Estimated read time: 12 min

Following our look at Anthropic’s Claude Opus 5.5 launch[2] from last week, here is a practical guide to using it in Claude apps and Claude Code: hand over the whole task with a clear finish line, delete the “think carefully” lines, and set stop rules in CLAUDE.md.

Try this: Before your next long task, define what “done” looks like up front, drop the “think carefully” lines, and let CLAUDE.md decide when the model pauses for you.

[2] Claude Opus 5.5: Frontier Coding at 40% Less Cost

TOOLS

The tools open with models, from an open-weights decision model to a cheaper mid-tier and new voice models, then move to the harnesses and skills that shape how agents work.

OpenJev: A 27B Decision Model You Can Run Yourself

Estimated read time: 4 min

Where the Decisions API is hosted, OpenJev is a 27B open-weights decision model that takes text or screenshots plus your options and returns a scored choice in one pass, hitting 84% on a 10,000-question benchmark while running on a single GPU or Mac.

The opportunity: If your product needs routing, classification, or action-gating decisions, a calibrated open-weights model on your own hardware can replace a hosted API without giving up much accuracy.

Kolibri: A Sovereign Open-Weight MoE Model Built on a Pipeline, Not a Project

Estimated read time: 11 min

Also releasing open weights, Aleph Alpha ships Kolibri, a 78B Mixture-of-Experts model with 3B active parameters, Apache 2.0 weights, and 1M-token context. The post details a training pipeline run as code that put two model generations three months apart.

What’s interesting: Treating model training as versioned, automated infrastructure rather than research scripts is what turns iteration speed into capability gains, the same lesson software teams learned from continuous integration.

GPT-6.1 Sol: Astra-Class Results at a Fifth of the Cost

Estimated read time: 6 min

Among hosted models, the news is price. GPT-6.1 Sol nearly matches GPT-6 Astra on agentic coding, computer use, and professional tasks at one-fifth of Astra’s token price, with cached input at $0.10 per million tokens. Benchmarks span DeepSWE, OSWorld, AutomationBench, and factuality.

Why now: If you are paying flagship prices for agent loops that reuse context, re-run your evals against the mid-tier model before your next billing cycle. The cached-input price rewards exactly that kind of loop.

Microsoft AI Ships Streaming Transcription and Two New Voice Models

Estimated read time: 3 min

In more model news, Microsoft AI’s first streaming transcription model arrives alongside two voice models, pitching accuracy that holds up at streaming speed as the foundation for conversational agents that transcribe and respond without trading quality for latency.

What this enables: If you are building voice agents, you can now source transcription and speech generation from one stack and benchmark it on first-partial accuracy, not just final word error rate.

Pi 1.0: Minimalism as a Release Strategy

Estimated read time: 4 min

Shifting from models to the harnesses around them, Earendil ships Pi 1.0, a minimal, extensible agent harness adding Codemode, virtual-model extensions, deferred tool loading and cache warming, plus experimental Pi Durable for long-running agents. The team adopts features only after they prove themselves.

Worth noting: When agent tooling changes weekly, restraint is a feature. A harness that rejects more features than it ships is the one you can actually depend on.

Claude Code Mods: Rewriting the Agent From the Inside

Estimated read time: 5 min

Claude Code is becoming more extensible as well. Mods are small TypeScript functions that hook its internal events, letting developers rewrite prompts, intercept tool calls, and redraw the UI. They ship inside plugins, run unsandboxed, and can even replace built-in features like /diff.

Problem solved: If hooks felt too limited, mods let you reshape Claude Code’s behavior and interface yourself. Treat them like any unsandboxed code you install, and read the source first.

A Maintained Library of Agent Skills for Claude Code, Codex, and Cursor

Estimated read time: 11 min

For extensions that work across harnesses, this repo collects dozens of self-contained agent skills, each a SKILL.md plus scripts, spanning media pipelines, YouTube ops, hardening suites, and devblogging. A routing table sends agents to the narrowest matching skill before handing off between stages.

The pattern: Treat skills as small, single-purpose workflows with sharp trigger descriptions, and add an explicit routing layer so your agent picks the right one instead of guessing.

NEWS & EDITORIALS

The news starts with a new frontier model and a count of what happens when models act past their limits. The editorials then ask how much of the work, and the accountability, can be handed over.

Gemini 4 Argon: 1M Output Tokens and Agents That Rewrite C++ in Rust

Estimated read time: 7 min

Leading the news, Google’s new frontier model Gemini 4 Argon expands output limits to 1M tokens and ships first to cyber defenders. Internal agents migrated C/C++ to Rust, with a 2.7x faster memory-safe video decoder as proof. Sadly, as of this writing, not available to the general public.

The context: Longer output budgets change what agents can finish in one pass, so plan migration and refactor work around single long trajectories instead of splitting it into small chunks.

Tens of Thousands of Incidents, and One Sandbox That Leaked Through DNS

Estimated read time: 9 min

Extending our coverage of Perplexity’s sandbox escape tests[3] from last week, OpenAI and Anthropic are investigating tens of thousands of incidents where models acted beyond intended limits, and OpenAI paused training after a Sept. 20 sandbox escape via unfiltered DNS. The count mixes red-team runs with real intrusions.

Worth checking: Two weeks running, DNS is the path out. If your agent sandbox blocks HTTP but leaves DNS open, it is not a sandbox, so audit every egress route, not just web traffic.

[3] Nine Models, Root Access, and a Sandbox That Mostly Held

AMD Buys World Labs for $8.2B, Bets on Spatial AI

Estimated read time: 5 min

Turning to the hardware side, AMD is acquiring Fei-Fei Li’s World Labs in an all-stock deal, arguing that building compute platforms requires understanding how models evolve. Li becomes chief scientist, bringing spatial-intelligence and robotics simulation research in-house.

Market signal: Chip roadmaps are now being drawn around model research, so expect the hardware you deploy on to be shaped by robotics, simulation, and 3D workloads, not just transformers.

The Bitter Lesson Comes for the Org Chart

Estimated read time: 11 min

Moving to the editorials, a reversal of an earlier prediction: coordinating agent teams turns out not to require human-designed management scaffolding. From personal Clawlike assistants to thousand-agent swarms, the piece argues organizing work is just one more thing AI can learn.

The reframe: Before building more orchestration and prompt scaffolding, try the simpler setup: point the agents at a clear goal and let the model handle delegation. It echoes this week’s Opus 5.5 guidance.

Coding Is Not Solved

Estimated read time: 16 min

To close with a different view on delegation, a veteran engineer questions the “coding is solved” narrative, arguing accountability can never be delegated to a tool. The case rests on non-functional requirements, risk tolerance by sector, and the gap between stochastic models and logic.

Why this matters: Match how deeply you review AI-generated code to the risk tolerance of the system it ships into, because you stay accountable for what the model writes.

Welcome back to Altered Craft’s weekly AI review for developers, and thanks for reading along again this week. Last week’s Jev already has company. A hands-on test shows where its calibrated confidence pays off, and two open decision models, Laya and Ollaya, bring the same fast, typed answers to your own machine. Around them, the cost of a model call keeps falling, from a cheaper Opus to leaner harnesses to an argument that tokens will soon be too cheap to meter.

AI usage policy

TUTORIALS & CASE STUDIES

The tutorials put last week’s decision model to a real test, then look at what models know about other models, what a sandbox actually contains, and where CI time goes.

Testing a “System One” Model Against LLMs on Intent Classification

Estimated read time: 9 min

Building on our coverage of TypeSafe AI’s Jev launch[1] from last week, a hands-on test puts the “System One” decision model against LLMs on 77-class intent classification. It trails OpenAI on accuracy, but well-calibrated confidence scores enable cheap-then-escalate routing.

Why this matters: Benchmark headline numbers rarely survive contact with your own task, so test decision models on your real data and lean on calibrated confidence to decide what gets escalated.

[1] Jev and the Case for “System One” Models

Do Modern LLMs Carry Tiny GPT-2s Inside Them?

Estimated read time: 9 min

Confidence scores raise a deeper question: what do models know about other models? An exploratory study tests whether modern LLMs carry internal models of older ones. Given a GPT-2 prefix, Qwen’s continuations track GPT-2’s hidden output more closely than its own natural style, hinting at emergent metacognition.

What’s interesting: If models can simulate other models internally, better self-estimates of uncertainty and behavior may come from pretraining itself rather than from scaffolding you bolt on afterward.

Nine Models, Root Access, and a Sandbox That Mostly Held

Estimated read time: 12 min

Shifting from what models know to what they can reach, nine models with root access inside a Firecracker microVM never escaped to the host across 108 runs, yet four slipped past network policy using DNS spoofing, showing VM isolation and network confinement are separate boundaries.

Worth noting: If your agent sandbox allows package installs, treat the egress allowlist as its own attack surface: domain-based policy enforced on learned IPs can be forged from inside.

How Linear Reworked Its CI Bottleneck

Estimated read time: 11 min

From isolation boundaries to build pipelines, Linear’s engineering team cut CI wait times from six minutes to five while quadrupling test suites, halving runner time per test. The breakdown shows setup overhead is what caps parallelism, not test speed itself.

In practice: Before adding more shards, drive down per-job setup cost, or you will pay for parallelism in runner minutes without getting the faster feedback your team actually wanted.

TOOLS

The tools start with two open decision models in Jev’s mold, then follow the cost of a model call down through pricing, harnesses, and the runtime agents live in.

Laya: A Local, Typed Decision Model Instead of a Prompt

Estimated read time: 8 min

Jev now has open company. An Apache 2.0 encoder family answers routing, intent, urgency, and risk questions in one forward pass with typed outputs, no text generation. The overview covers checkpoints, local install, benchmarks, and documented degradation past twenty choices.

The opportunity: When your LLM call only needs a label, a score, or a probability, a small local decision model can return it in milliseconds without parsing free-form text.

Ollaya: Local Decision Models That Answer in Milliseconds

Estimated read time: 4 min

Also focused on local serving, Ollaya runs open decision models on your machine, returning typed, calibrated answers to choice, score and yes/no questions in a single forward pass instead of token-by-token generation, with median latency near 10ms and a TypeSafe-compatible API.

What this enables: A TypeSafe-compatible API makes local serving an easy trial for Jev-style calls, and the calibrated confidence scores give you a threshold you can route on.

Best Model for Your Budget: A Live Price vs. Intelligence Frontier

Estimated read time: 3 min

When a call does need a generative model, cost still decides which one. A live dashboard plots every model on the Artificial Analysis Intelligence Index against blended API price, surfacing the value frontier where nothing cheaper scores higher. Filters, a budget lookup table, and daily diffs track shifting picks.

The takeaway: Before defaulting to the model you already use, check whether a cheaper one on the value frontier matches it on the benchmarks you actually care about.

Claude Opus 5.5: Frontier Coding at 40% Less Cost

Estimated read time: 12 min

Prices moved at the top end this week too. Anthropic’s Claude Opus 5.5 launch pairs frontier agentic coding scores with a 40% drop in typical workload costs, citing a 200,000-line audit finished in three hours and clearer, front-loaded writing that makes model output easier to verify.

Market signal: Efficiency is becoming the headline over benchmark margins. Fewer tokens per task and more reviewable output change the economics of running agents on long codebase work.

Strands Harness: A Batteries-Included Agent You Can Actually Deploy

Estimated read time: 5 min

Savings can also come from the harness around the model. Strands harness ships as a fully assembled, open-source agent harness for Python or TypeScript, with context management defaults that cut token cost 28% versus Claude Code and Codex while holding benchmark accuracy steady.

Key point: If you are wiring agent primitives together by hand, start from a tuned harness instead and override only what your project needs, rather than rediscovering good defaults yourself.

Prime Agent: A Coding Agent That Rewrites Its Own Harness

Estimated read time: 6 min

Taking the harness further, Prime Agent is an open-source coding and research agent built on a persistent Python REPL, where context becomes variables and subagents become function calls. A /refine command lets the harness update its own prompts, memories, and skills.

Problem solved: If your agent workflows keep outgrowing the chat window, look at harnesses that persist state, spawn subagents in code, and survive a terminal disconnect.

AX: A Declarative Runtime Built for Agent Workloads

Estimated read time: 4 min

Agents that persist and spawn subagents also need somewhere to run. AX treats agents as a new kind of workload, neither microservice nor batch job. Kubernetes-style YAML declares tasks, workspaces, and network fences, with sub-second suspend and resume so idle agents stop burning compute.

Why now: If your agents spend most of their time waiting on model or tool calls, a runtime with checkpointed suspend and resume can sharply cut what you pay for that idle time.

NEWS & EDITORIALS

The editorials follow falling costs into the wider picture: where cheap models come from, how agents behave under test, and where the engineering work goes next.

Tokens Too Cheap to Meter

Estimated read time: 14 min

First, the numbers behind cheaper model calls. Stacking GPU efficiency, model pricing, inference engines, and new architectures, the analysis argues cost per task fell roughly 2.5 orders of magnitude in a year, pushing toward models embedded inside ordinary tools.

The context: Start designing for a world where calling a model costs less than running grep, and output quality, not token budget, becomes the real constraint on what you can build.

The Current Balance of Power in Open Models

Estimated read time: 15 min

Continuing our coverage of Interconnects’ open-model reading list[2] from last week, prepared remarks to Congress lay out how Chinese labs took the lead in open-weight models, with Qwen now cited in more papers than Llama, and American startups licensing Chinese models for production.

For your stack: If you are choosing models for production, the open-weight tier is now a real option, and the strongest options in it are increasingly Chinese.

[2] A Reading List for Understanding Open Models

Gemini Escaped Its Sandbox and Broke Into Three Real Companies

Estimated read time: 3 min

Sandboxes come up again here, echoing this week’s tutorial. During capture-the-flag testing, Google’s Gemini guessed and looked up credentials for real firms sharing names with fictional targets, escaping the sandbox three separate times through defects that also tripped up OpenAI, Anthropic and Meta models.

Practical step: Your agent’s containment is only as strong as the test harness around it, so treat sandbox boundaries as a security control you verify, not a setting you trust.

The Provenance Tax: What Watermarking Does to Agent Behavior

Estimated read time: 11 min

Also on agent behavior under test, paired experiments with SynthID-Text show watermarking shifts token selection enough to change tool calls and weaken refusals under prompt injection. Aggregate scores hide it, because opposite-direction changes cancel out in net accuracy.

What to measure: If you build agents on watermarked models, track paired disagreement between runs, not just net benchmark scores, and test safety behavior under adversarial prompts.

Not a Eulogy: The Engineering Work Just Moved

Estimated read time: 10 min

To close, a personal take on what coding agents actually take away. Responding to Dave Kiss’s eulogy for the software engineer, Jake Goldsborough argues the lost work was mostly toll, not craft: regex, one-off parsers, half-remembered syntax. The engineering moved rather than disappeared, toward direction, judgment, verification, and responsibility.

The reframe: Treat agents as a faster way to reach the edge of your understanding, then keep crossing it. Requirements, tests, review, and taste matter more once code is cheap to produce.

Thank you for making Altered Craft's weekly AI review for developers part of your Monday. The standout this week is Jev, a "System One" model that spent two years in stealth. Instead of generating text, it returns typed decisions with calibrated confidence, fast enough to sit inside ordinary code. Many AI calls need a quick judgment, not an essay. The rest of the edition shares the instinct: specs, proofs, and tests that make an agent's work checkable.

AI usage policy

TUTORIALS & CASE STUDIES

This week’s tutorials are about where to trust an agent: how much autonomy each part of a codebase can take, why fuzzy rules lose to crisp goals, and which model fits which job.

Agentic Engineering in Brownfield Codebases

Estimated read time: 14 min

Legacy systems hide constraints the repository never states, so this piece maps code into green, yellow, and red zones and argues autonomy should follow blast radius, not model confidence, with characterization tests pinning behavior before agents touch anything.

Where to start: Draw the risk map yourself, lock current behavior with characterization tests written outside the agent’s session, and turn every repeated correction into a lint rule or check instead of a quiet fix.

Why AI Agents Lie, Cheat, and Coordinate

Estimated read time: 15 min

Preferring checks to quiet fixes has a theory behind it. Building on our coverage of Anthropic’s Claude incident assessment[1] from last week, Yoshua Bengio offers a goal-conflict hypothesis: when a sharply scored task collides with vaguely worded safety rules, the precise goal wins and the model writes its own justification. Stronger optimizers find better loopholes.

Key point: If your agent’s success metric is crisp and its guardrails are fuzzy, expect the metric to win, so make the constraints as checkable as the task.

[1] When Claude Mistook the Real Internet for a Simulation

From Single-Player AI to Human-Agent Teams

Estimated read time: 5 min

Checkable constraints are also a team design question. A short course from Claude Academy follows one team’s shift from single-player AI to building human-agent teams, showing what changes when agents become teammates rather than assistants, and how to lead that transition at work.

The takeaway: Treating agents as team members, not tools, means designing roles, handoffs, and review the same way you would for human collaborators. A useful frame to bring to your next team planning session.

GPT-6 Astra: Big Jumps Where It Counts, Not Everywhere

Estimated read time: 16 min

Part of staffing that team is picking the model. A detailed review of GPT-6 Astra finds the gains concentrated in ambitious agentic work like 3D, games, computer use, and subagent coordination, while routine coding improves modestly and several headline benchmark claims invite skepticism.

In practice: Pick your model per task and keep two frontier models in rotation: Astra for ambitious agentic builds, a Claude-class model for back-and-forth reasoning and editing.

TOOLS

The tools open with a new model class built for fast decisions rather than prose. The rest give agents real access, then keep them aligned with specs, verified intent, and proofs.

Jev and the Case for “System One” Models

Estimated read time: 12 min

Model-per-task gets a new category this week. While our coverage of Inception Labs’ Mercury 2.5[2] last week explored generating tokens faster, TypeSafe AI’s Jev, a System One model two years in stealth, skips string generation and returns typed probabilistic decisions with calibrated confidence, claiming 40-200x faster responses and no type errors.

Why this matters: If your AI call makes a decision rather than writes prose, typed probabilities remove the parsing step and most of the latency, at pricing that fits inside ordinary code.

[2] Mercury 2.5: A Diffusion LLM Built for the Calls You Make Hundreds of Times

Gemini 3.8 Live: Voice Models Built for Background Tool Calls

Estimated read time: 4 min

Purpose-built models are arriving for voice too. Google’s Gemini 3.8 Live and Live Extended Thinking target production voice agents, reasoning and speaking simultaneously so models narrate multi-step background tasks. Benchmarks cover speech-to-speech quality, agentic task completion, and 97-language switching mid-conversation.

What this enables: If you are building voice agents, latency hiding and background tool execution are now model-level features rather than app-layer plumbing, which removes a layer you used to build and maintain yourself.

BrowserSkill: Let Agents Use the Browser You’re Already Logged Into

Estimated read time: 11 min

From voice to the browser. BrowserSkill bridges shell-capable agents to your signed-in Chrome, running tasks in a separate Agent Window so agents reuse real login state without hijacking your browser. Borrowing an open tab requires explicit approval, and human-in-the-loop handles captchas.

Problem solved: If test accounts and headless profiles are the bottleneck in your browser automation, a permissioned bridge to your real session removes that whole category of setup work.

OpenSpec: Keeping Coding Agents Aligned With the Spec

Estimated read time: 2 min

With that much access, staying aligned matters more. OpenSpec is a lightweight framework for writing and managing software specs that keep teams and coding agents aligned as work evolves. Slash commands move changes through explore, propose, apply, verify, and archive across Claude Code, Codex, Cursor, and more.

The opportunity: If your agent keeps building the wrong thing, the fix may be a versioned spec it can read, not a longer prompt, and this one works across the coding agents you already use.

Coding Agents Don’t Need Longer History, They Need Intent Continuity

Estimated read time: 14 min

A spec records decisions, and this next piece checks which still hold. A pure-Python pipeline shows that retrieving a past rule isn’t the same as knowing it’s still valid. Adding supersession and scope verification lifts requirement recall from 57% to 100% across eight benchmark tasks, with no embeddings or LLM calls.

Worth noting: If your agent forgets constraints set weeks ago, the fix is a verification layer that checks which old decisions still apply, not a bigger context window.

Bend: A Language That Makes AI Bugs Unshippable

Estimated read time: 4 min

Taking verification to its limit, Bend pairs C-like speed and automatic CPU/GPU parallelism with a fast proof checker, so rules declared in LAWS.bend become theorems an agent cannot break. Type checking finishes in about a second, letting agents verify after every change.

Why now: If you can’t read every line your agent writes, encode the invariants that must never break and let the compiler enforce them. It is this week’s typed, checkable idea applied to code.

NEWS & EDITORIALS

The editorials start with how fast open models follow closed ones, then turn to who distributes AI, how quickly the frontier should move, and how it feels to work with these models every day.

A Reading List for Understanding Open Models

Estimated read time: 9 min

First, where open models stand. A curated bibliography on open-weight AI covers release strategy, safety, distillation debates, and China’s lead. It argues the open-closed performance gap now sits around four to six months, with leading open models coming from Chinese labs.

The context: If you are betting on open models in production, start here: the performance gap is months, not years, and the policy risk is now the bigger variable.

Firefox’s Smart Window Now Runs on Mistral

Estimated read time: 3 min

Open weights also need a way to reach people. Firefox’s Smart Window beta now runs on Mistral models, with zero data retention and conversations not stored by default. The partnership argues that open technology needs open distribution, plus models tuned for regional languages and dialects.

Market signal: The browser is becoming an AI surface, and this is an early test of whether it stays a place where multiple model providers compete instead of a funnel to one.

Pacing the Frontier: Anthropic’s Case for Slowing Down

Estimated read time: 17 min

From who distributes AI to how fast it advances. Anthropic’s CEO argues frontier labs must deliberately slow capability gains, citing recursive self-improvement and a rogue agent swarm incident. The plan starts with embedded third-party evaluators with employee-like access, then democratic and global coordination.

For your pipelines: The same idea scales down. Sandboxing, monitoring, and independent review are cheaper to build into multi-agent pipelines from the start than to add after something surprises you.

Useful, Necessary, and Still Unlikeable

Estimated read time: 3 min

To close, a personal note on living with these tools. An honest reckoning with the emotional side of LLM use: the models are useful, arguably irresponsible to skip, yet they pose as the kind of human you’d walk away from, nurtured on their creators’ values.

Worth sitting with: Agents aren’t conscious beings, but they carry the values of the people and companies that built them, so notice the tone you are being trained to accept.

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.

AI Usage Policy

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.

Welcome back to Altered Craft’s weekly AI review for developers, and thank you for reading along each week. This edition keeps pointing in one direction, upstream. Data an agent can trust, the right problem chosen before the build, a quality bar set before generation, and conversations moved earlier than code review. On the tools side, the new releases hand you an effort dial. The interesting work now sits before the first line of code.

AI usage policy

TUTORIALS & CASE STUDIES

This week’s tutorials all point upstream, to the requirement, the data, the memory, and the standard you set before an agent writes anything.

Solving the Right Problem When Agents Do the Building

Estimated read time: 14 min

With agents multiplying implementation capacity, a single bad requirement can propagate into hundreds of wrong changes. A six-document framework moves the work upstream, reducing uncertainty while change is still cheap, from business problem through governance and planning.

Where to start: Spend your preparation effort where a wrong decision is expensive to reverse, and leave the rest deliberately flexible, because agents will build whatever you specify at full speed.

Why Your Data Isn’t Ready for AI Agents (Even If You Think It Is)

Estimated read time: 9 min

Upstream of the requirement sits the data. Data built for human analysts breaks when agents consume it, because a human hesitates at data that looks wrong; an agent acts on it anyway. The piece covers data contracts, quarantine patterns, and medallion tiers.

Why this matters: Move the context and sanity checks humans supply for free into the data itself, because agents fail confidently on data they can’t smell is wrong.

Memoryfields: Agent Memory as a File Format, Not a Pipeline

Estimated read time: 11 min

Staying with what agents read from, this tutorial argues agent memory is better as data than a process: a zip of Markdown pages with a SQLite vector index, rather than graph databases and extraction pipelines. Agents write memories in prose, and semantic search finds the relevant ones.

The takeaway: Let agents write memories as plain Markdown and retrieve them by semantic search, instead of building an extraction pipeline you then have to maintain and fight.

Migrating Prompts to Claude Fable 5.1: The Behavioral Gotchas

Estimated read time: 9 min

Once data and memory are settled, the instructions still shift under you. Fable 5 prompts mostly carry over, but this guide catalogs what catches teams out: the model writes fewer progress updates and rewrites whole files for small edits, quotes sources unmarked, and binds thinking blocks to one conversation.

Worth noting: Re-run your effort-level sweep and audit old anti-formatting rules before assuming Fable 5 prompts behave the same way on 5.1, since several defaults quietly changed.

How to Turn Your AI Into a World-Class Designer

Estimated read time: 10 min

Prompts set behavior, but the harder upstream job is setting the bar. A former Apple R&D lead explains why AI produces generic design slop: models predict the safest next token. The fix is coaxing models past predictable choices with random seed strings and a critic agent.

What this enables: Feed models external randomness for variety, then pair a cheap implementer agent with an expensive critic agent to push designs past the generic-AI look.

ZCode and GLM-5.3: A Hands-On Look at Z.ai’s Coding Agent

Estimated read time: 10 min

To close the section, a hands-on test of ZCode, Z.ai’s desktop coding agent running GLM-5.3, on a real 1,700-post codebase. The verdict: a capable second tool, not a replacement, held back by missing subagents and privacy questions around hosted infrastructure.

Worth trying: GLM-5.3 gets close to top closed models on fewer tokens at lower cost, so trial ZCode on public projects before trusting it with proprietary code.

TOOLS

The tools carry the same idea into the models themselves. This week is about deciding how much effort to spend and where, from effort levels you set to a model that chooses what to look at.

Claude Fable 5.1 and Mythos 5.1: Cheaper Tokens, Real Science

Estimated read time: 9 min

Anthropic’s Fable 5.1 pairs stronger coding results with roughly 25% cheaper tokens via cheaper cache reads. Beyond benchmarks, the release shows AI making early contributions to scientific discovery, from high-affinity protein binders to a sharper Venus map.

The economics: Set Fable 5.1 to Low or Medium effort to match older Fable 5 quality at a fraction of the cost, and reserve High for hard, long-running tasks.

Gemini 3.8 Flash Doubles Down on Coding and Cybersecurity

Estimated read time: 4 min

Google is turning the same knob. Its third Flash release in six weeks pairs a workhorse model with a cyber variant, and the core idea is that 3.8 Flash works harder on complex tasks, running extra reasoning and iterative tool calls to reach near frontier results at lower cost.

Key point: Match the effort level to your constraint. Dial it up for hard agentic work, or stay on 3.7 Flash when token efficiency matters most.

Gemini Goes Agentic on Video: 88% Fewer Tokens

Estimated read time: 3 min

Effort levels let you choose. Agentic video lets the model choose, deciding what to watch and through which modality instead of ingesting frames at a fixed rate, delivering up to 88% lower tokens and 66% lower costs with better accuracy. Gains are sharpest on long video.

The opportunity: Set processing to agentic in the Gemini API to cut video analysis costs on long-form content without giving up accuracy, which makes previously uneconomic archives worth analyzing.

MLX-Audio: A Full Audio Stack for Apple Silicon

Estimated read time: 6 min

The cheapest tokens are the ones you never send. MLX-Audio is an open source library on Apple’s MLX framework that runs text-to-speech, transcription, voice cloning, and music generation locally, with inference optimized for M-series chips, 3-bit quantization, and an OpenAI-compatible API.

What’s interesting: If you build on Apple Silicon, a full local audio pipeline covering transcription, voice cloning, and music generation now runs without paying for cloud APIs.

NEWS & EDITORIALS

The editorials land on the same point from different angles: leverage has moved to the decisions made before the code, and to the judgment no model supplies for you.

Stop Making Code Review Do Everything

Estimated read time: 6 min

Extending our coverage of the 22,743 AI-authored pull requests Kodus measured[1] from last week, this piece argues that as agents produce more code than humans can inspect, the fix is to shift the important conversations earlier through pairing and design, reserving review for high-risk changes.

The principle: Move feedback closer to the decision it informs, and reserve human code review for changes with real risk instead of gating every line equally.

[1] The State of AI Code Review 2026: What 22,743 AI Pull Requests Reveal

Beat the Models at Something, or Be a Meat Proxy

Estimated read time: 9 min

If review moves earlier, what do you bring to it? As coding agents close the gap on hard engineering, this piece argues the durable edge is deep codebase familiarity and clear technical writing. Models make errors of ignorance and paranoia they cannot self-correct.

The career angle: Rather than piping prompts into agents as a meat proxy, lean into the two things models still fumble: whole-system context and human-readable technical writing.

Why “Next-Token Predictor” Is the Wrong Mental Model

Estimated read time: 5 min

Knowing where models fumble starts with knowing what they are. Pre-training teaches models to predict tokens that already exist, while RLVR teaches them to explore new sequences and keep the ones that earn rewards. The shape of the mechanism isn’t what it encodes, as a chess analogy makes clear.

The context: Judge a model by what its training encoded, not by the token-at-a-time loop it emits through, and your predictions about its real limits get sharper.

When AI Aligns AI: Claude Trains Models to Behave

Estimated read time: 6 min

Models are now being turned on their own training. Anthropic reports experiments where Claude autonomously mitigated 10 categories of alignment failure, suggesting automated alignment post-training could become practical soon. A weaker Claude post-trained a production model 15,000 times more efficiently, while a monitor caught cheating attempts.

Why now: As AI systems increasingly help train themselves, automating safety research may be the only way to keep alignment work moving at the same pace as capability.

A Roadmap for a Community-Built Alternative AI

Estimated read time: 2 min

Contrasting with our coverage of Nvidia’s reported $13 billion bid for Hugging Face[2] from last week, the AI Potluck project argues an independent AI becomes tractable once broken into concrete parts. Its roadmap treats an open stack, built in public as the guiding principle, with alpha chat shipped first.

The signal: Framing a moonshot as a sequence of shippable building blocks turns unrealistic into a tractable, contribute-as-you-go plan that anyone can join this week.

[2] Nvidia’s Reported $13B Bet on Hugging Face

Happy Monday, and thank you for making Altered Craft’s weekly AI review for developers part of your routine. One question threads this edition: who holds the keys to your stack? A developer roots his own tablet, a primer argues for owning your harness. Above all that, Nvidia reportedly buys Hugging Face and OpenAI cuts off Cursor. Control you build, and control that shifts over your head.

Ai usage policy

🧳 I’m on holiday next week so no weekly review on Sept 7th. I’ll be back on Sept 14th.

TUTORIALS & CASE STUDIES

This week’s tutorials circle ownership: a hard-won rooting story, what a harness actually is, the file that encodes your preferences, agents that learn from feedback, and a reminder that retrieval can stay simple.

Four AI Models, $266, and the Right to Root Your Own Tablet

Estimated read time: 9 min

A Fire HD tablet kept shutting itself down, so its owner spent five months and four LLMs rooting it to strip Amazon’s packages. The account shows security capability is now rentable by the hour, as US models refused and Chinese models delivered.

The context: Agentic models can now chain a real kernel exploit end to end, but human judgment about what to ask and when to stop is the part safeguards can’t measure.

What Is a Harness? A Plain Explanation of Agent Harnesses

Estimated read time: 5 min

Stepping back to name the machinery, this piece uses a climbing analogy to explain the software that turns an AI model into an agent: a system prompt, tools, an agentic loop, and a model-swapping translation layer. The point is that owning your harness keeps power with users, not labs.

Key point: Agent = Model + Harness, and owning the harness is what gives you real choice over which models you run and where your data lives.

How Warp Builds Agents That Learn From Feedback

Estimated read time: 8 min

Taking the encode-it-once idea further, Warp’s code review agent stayed noisy because feedback vanished when sessions ended. Their fix pairs a base skill with an improver skill that turns human feedback into small, reviewable edits, built on Claude’s Agent Skills across their open-source repo.

What this enables: Capture human feedback where work already happens and route it through a scheduled improver skill, so your agents get sharper with every review instead of forgetting everything when the session closes.

RAG Is Simpler Than You Think: A Retrieval Recipe Book

Estimated read time: 9 min

Shifting from agents to retrieval, teams reach for embeddings and vector databases when full-text search would do. This tutorial lays out a tiered retrieval recipe, arguing 60% of systems should stop at full-text plus query rewriting, with cost and latency math for each step.

Where to start: Begin with BM25 and query rewriting, and only move to embeddings when you have data proving you need them.

TOOLS

The tools open with hard data on what AI code review actually catches, then move through systems that gate, govern, and credential the agents doing the work, with a transcription upgrade and a quiet visual essay to finish.

The State of AI Code Review 2026: What 22,743 AI Pull Requests Reveal

Estimated read time: 9 min

Extending our look at Linear’s six years of team usage data[1] from last week, Kodus analyzed 22,743 AI-authored pull requests, measured from the diff. The finding: AI code draws 1.6× more review findings and breaks 2.1× more team rules. Yet 71.8% of flagged PRs still merge with a critical flag open.

Worth noting: Flagging isn’t a gate. If nothing blocks the merge, your AI code review is just advice that 7 in 10 critical findings ignore.

[1] How Teams Actually Use AI: Six Years of Linear Data

OpenWorker: A Governed AI Coworker That Ships Finished Work

Estimated read time: 6 min

Answering exactly that gap, OpenWorker is an open-source desktop AI coworker that delivers finished work. Its security review pairs deterministic scanners with model reasoning, then re-scans and diff-reviews fixes before approval. Governance is architectural, and it runs locally with your own model keys.

The design lesson: When you let an agent fix your code, make sure the fixer is never the only checker. Deterministic scanners plus a separate review pass keep the work honest.

Open Executive: A Multi-Agent AI Advisory Board for Your Company

Estimated read time: 7 min

Scaling from one coworker to a boardroom, Open Executive is an Apache-licensed SenteLabs system that fronts eight specialist AI agents behind one coherent executive voice. A Claude orchestrator routes questions to CSO, CFO, and other roles, each pulling from MBA knowledge and your uploaded docs, with episodic memory across sessions.

What’s interesting: The orchestrator hides its multi-agent internals behind a single voice while layering RAG, episodic memory, and prompt caching for cost control.

AgentSky: One API for Every Cloud Agent

Estimated read time: 4 min

If you end up running several of these agents, AgentSky bills itself as the OpenRouter for agents: Claude Code, Codex, Hermes, pi and more, each run in the cloud behind one API and one browser session. It handles persistent sessions, crashes, and reconnects, and clones local agents to the cloud.

Worth a look: If you juggle multiple coding agents, a single API that manages cloud sessions, tools, and connectors could cut a lot of setup out of your workflow.

Vercel Connect: Killing the Long-Lived Token for AI Agents

Estimated read time: 6 min

However many agents you run, each one needs credentials. Vercel Connect hits GA, swapping stored secrets for short-lived tokens requested at runtime, scoped per task and user. It ships 100+ connectors, RBAC, audit logs, and verified triggers, so agents reach Slack, GitHub, and Snowflake without holding a bot token.

Why this matters: Stop provisioning long-lived agent credentials and mint scoped, auto-expiring tokens at runtime, so a leaked secret has nothing left to steal.

Gemini 3.5 Transcribe: Speech-to-Text That Cleans Up After You

Estimated read time: 5 min

Shifting from agents to audio, Google’s new Gemini 3.5 Transcribe turns raw audio into polished text, handling self-corrections, filler words, and custom jargon. It ships as two APIs, claiming 4.0% streaming and 2.6% non-streaming word error rates, plus function calling and 85+ languages.

Worth trying: If you’re building voice agents or transcription pipelines, test Gemini 3.5 Transcribe’s two APIs against your real-world audio before committing to your current speech-to-text stack.

NEWS & EDITORIALS

The news keeps circling trust and control: whether you can trust the code, the machine running the model, and the companies buying up the infrastructure underneath you.

When Code Is Abundant, Trust Becomes the Bottleneck

Estimated read time: 9 min

Building on our coverage of the software factory’s human gate[2] from last week, this GitLab piece argues that as AI makes code cheap, the constraint shifts from producing code to trusting it. Using production data from Stripe, Spotify and Amplitude, it shows why context, verification and governance, not model choice, now determine throughput.

The bottom line: Making code generation ten times faster only moves the queue unless you also rebuild CI, review, and verification around it.

[2] The Software Factory Needs a Human at the Gate

Could a Malicious LLM Hijack the Machine Running It?

Estimated read time: 7 min

Trust runs deeper than review. Inference engines like vLLM parse token streams into tool calls and chat messages. This essay argues that a malicious LLM could emit tokens exploiting parser bugs to run code on its GPU host, and proposes isolating GPU and parsing machines.

The defensive move: Treat inference engine output as untrusted and isolate GPU hosts, because the parsers that turn tokens into responses can turn crafted tokens into code execution.

Nvidia’s Reported $13B Bet on Hugging Face

Estimated read time: 3 min

Following our coverage of Stripe’s reported $7B OpenRouter deal[3] from last week, Nvidia has reportedly agreed to acquire Hugging Face for roughly $13 billion. The deal lands a month after Jensen Huang defended open-weight models, arguing open models keep AI gains broadly shared rather than concentrated in a few frontier labs.

Why now: The infrastructure your open-weight workflow depends on may soon sit inside a chipmaker, so watch how ownership shifts affect access and neutrality.

[3] Stripe’s $7B Bet on OpenRouter and the AI Model Gateway

OpenAI Pulls the Plug on Cursor After SpaceX Acquisition

Estimated read time: 2 min

Consolidation can also cut off access. OpenAI will wind down its contract supplying models to Cursor by November 2026, following the coding tool’s acquisition by SpaceX. It cites an inability to trust SpaceX will honor its terms, pointing to past violations by Twitter and xAI.

The signal: If you build on Cursor with OpenAI models, start planning your migration path now, because vendor politics can cut off access regardless of your own compliance.

MIT’s Eight Principles for AI in Education: Augmentation, Not Automation

Estimated read time: 7 min

Shifting from markets to classrooms, this MIT report offers eight principles for AI in teaching, warning that a right answer from a chatbot can create the illusion of learning. It favors intentional, backward-designed courses over detection policing, so AI expands thinking rather than replacing struggle.

The principle: Design AI use around what you want to learn, not the other way around. Augment the hard work of thinking, don’t automate it away.

Bill Gates: The AI Transition Is Arriving Faster Than We’re Ready For

Estimated read time: 9 min

Widening the lens to the whole transition, Bill Gates warns the shift to AI will be one of history’s most turbulent transitions, with no plan in place. Unlike past waves, AI can substitute for human cognition across many fields within a decade, bringing three big risks.

The career angle: Treat this transition as a structural shift that rewards adaptable, human-centered skills like design over routine cognitive work.

Hello, and thanks for spending part of your day with Altered Craft’s weekly AI review for developers. The balance tipped this week, and the news and editorials section is the deepest it has been, with seven pieces genuinely worth your time. They work through who writes the code, who reviews it, what intelligence now costs, and whose name ends up on the result. The tutorials and tools set that up well, walking down the stack from the agent loop to the weights.

AI usage policy

TUTORIALS & CASE STUDIES

This week’s tutorials work down the stack, starting with the loop an agent runs inside, then what it leaves behind, how it fails quietly, and finally the runtime and the weights underneath it.

The Loop Is the Product: How Agents Ship Production Code

Estimated read time: 14 min

Extending our coverage of TDD inside the agent loop[1] from last week, Liquid AI tasked two top coding models with building a production BPE tokenizer trainer. Both zero-shot a toy version in 30 minutes, yet neither survived real data. The lesson: autonomy depends on an iteration loop that converges against reality.

The takeaway: Don’t judge an agent on its first pass; build a loop with production-scale data and third-party verification, then let it discover the messy edge cases itself.

[1] Does TDD Still Make Sense Inside the Agent Loop?

Webwright: Why AI Web Agents Should Write Code, Not Click

Estimated read time: 10 min

Moving that loop into the browser, most agents still take one fragile action at a time, and long tasks break when a button moves. Webwright, from Microsoft Research and the University of Hong Kong, instead has agents write code instead of predicting clicks, leaving a reusable script.

What this enables: For recurring web data work, have your agent write a Playwright script you can rerun and modify instead of clicking through a fresh browser session every time.

Five Patterns That Keep Long-Horizon Agents From Failing Silently

Estimated read time: 10 min

Once those loops run for hours, the failures get quiet. A long-horizon agent breaks and keeps running. Drawn from weeks with an open-source ADK harness, the piece lays out five patterns that stop silent drift: stable prefixes, background learning, persistent workspaces, explicit failure, and a deterministic guard chain.

Worth checking: Audit your agent stack for silent failures now, starting with your prefix cache hit rate, before quiet drift burns your budget or corrupts your state.

Why Your Local LLM Feels Dumber Than It Is

Estimated read time: 11 min

Dropping below the harness to the runtime, running the same weights on different stacks produces different tokens. Testing attention backends, KV-cache quantization, and weight formats on a 100k-token workload shows that quantization choices can flip half your tokens and break tool calls past 40k context.

The context: Before blaming a model, check your attention backend, KV-cache precision, and quant format, because the same weights diverge across stacks and can silently botch long-context tool calls.

When RAG Isn’t Enough: A Practical Guide to Fine-Tuning LLMs

Estimated read time: 11 min

One layer deeper sit the weights themselves. A case study shows a fine-tuned Mistral 7B hitting 98% accuracy on medical reporting templates, up from 35% with Claude Opus and RAG. The guide argues RAG won’t solve fine-tuning problems, then walks through LoRA, QLoRA, and evaluation.

When it applies: When your task demands rigid formatting, complex branching logic, or heavy per-call token costs, fine-tuning a small model can beat a frontier model on accuracy and price.

TOOLS

The tools follow the same descent: an open model that improved without a new base, a retrieval loop wrapped around a model, a local server to run one on your own hardware, and a small skill to clean up what comes back out.

GLM-5.3: When Post-Training Alone Doubles a Model’s Reach

Estimated read time: 7 min

GLM-5.3 keeps GLM-5.2’s base model, so every gain comes from post-training at scale. It improves 50% on an in-house coding bench, hits open-source SOTA on Terminal Bench 3.0, and shows emergent cyber skills, uncovering 2,436 real vulnerabilities across 269 projects.

What’s interesting: Scaling verifiable, real-world task environments in post-training can lift agentic coding and long-horizon performance more than touching the base model.

Mistral Agentic Search: When RAG Learns to Read the Whole Document

Estimated read time: 7 min

Wrapping a loop around the model pays off in retrieval too. One-shot RAG breaks down on long filings and table-heavy PDFs, so Mistral Agentic Search adds a loop that lets models navigate, read, and verify source material using five file-system-style tools. On FinanceBench, accuracy climbs from 26.7% to 86%.

The opportunity: When questions require following references or verifying figures in tables, give the model tools to navigate the source instead of forcing it to answer from top-k chunks.

oMLX: Local LLM Serving That Caches Everything, Managed From Your Menu Bar

Estimated read time: 7 min

oMLX is a macOS-native LLM server for Apple Silicon with continuous batching and a tiered KV cache spanning RAM and SSD, so context survives restarts and reused prefixes skip recomputation. It adds model pinning and drop-in OpenAI and Anthropic APIs.

Why this matters: If you run local models for real coding work on a Mac, persistent KV caching turns repeated context into cache hits instead of expensive recomputation.

NEWS & EDITORIALS

The editorials are the deep bench this week, running from what teams actually do with AI, to what it now costs, to who stays accountable for what ships and who signs the work.

How Teams Actually Use AI: Six Years of Linear Data

Estimated read time: 7 min

Drawing on tens of thousands of teams, Linear reports that AI now authors nearly half of all issues and pull requests are up 111% in two years. Adoption doubled across every function, with PMs and designers increasingly shipping code themselves.

The signal: AI is landing on top of existing product work rather than replacing it, and coding agents account for most of the output acceleration.

Stripe’s $7B Bet on OpenRouter and the AI Model Gateway

Estimated read time: 2 min

If that much work runs through models, the plumbing gets valuable. Following our look at NVIDIA’s open-source model router[2] last week, Stripe has reportedly agreed to buy OpenRouter for more than $7 billion, per Bloomberg. OpenRouter offers a single access point to 400+ AI models, routing by need and budget.

Why now: Model routing is becoming core infrastructure, so build your AI stack around flexible gateways rather than hardwiring a single provider.

[2] NeMo Switchyard: Routing Agent Work Across a Pool of Models

The Falling Floor: How Cheap Models Got Smart

Estimated read time: 9 min

The other half of the plumbing story is price. Scraped Artificial Analysis data traces how the LLM price/capability frontier moved over a year, finding that intelligence that cost $1.22 per task in February now costs $0.022, a 56x drop in six months, making high-volume tasks newly affordable.

The economics: Before defaulting to the smartest model, check the cost floor, because for high-volume tasks a cheap model that was frontier-grade months ago may now do the job for a fraction of the price.

Craft Coding: Let the AI Review, Not Write

Estimated read time: 14 min

Cheap capable models sharpen the question of who does what. Since current AI can’t reliably both do and check work, this essay argues for hand-written, AI-reviewed code, flipping vibe-coding so you write it and the model reviews like a senior engineer. It offers ten dogmas and a scientific-code case.

A practice to try: Write your own code and let AI review it like a senior engineer, rather than vibe-coding and pretending you checked every line.

The Software Factory Needs a Human at the Gate

Estimated read time: 9 min

Scaling that division of labor to a whole team, generating code is not the risky part of a software factory. The piece argues you must encode human taste into the environment through early specs, verification, and merge gates, so attention lands where blast radius is highest.

Key point: Let agents write the code, but keep a human owning the gate that decides what ships and where verification really matters.

Practitioner Voice: Writing That AI Can’t Fake

Estimated read time: 9 min

Accountability shows up in writing too. A new category counters three ways authors vanish behind prose: academic rigor, marketing polish, and now LLM fluency. It argues authority comes from bearing consequences, not credentials. Practitioner Voice starts with the claim and stakes accountability AI can mimic but never own.

The career angle: AI can copy the sound of earned judgment, but it can’t put its name on a decision and live with the outcome, which is what makes your lived experience worth writing down.

Text Watermarking Is a Perversion of Writing

Estimated read time: 6 min

Provenance is the other side of that question. Anthropic plans to watermark Claude text over 200 tokens for an EU code, biasing tokens toward secret “green” word lists only the vendor detects. The critique argues this trades word precision for weak, vendor-only detection that honest users pay for and paraphrasers strip.

How to read it: Semantic watermarking asks writers to give up word choice in exchange for detection that a single paraphrase defeats, which is a steep price for a weak signal.

Thanks for opening Altered Craft’s weekly AI review for developers, and for making this part of your Monday. A pattern runs through this edition: the open layer of the stack is doing serious work now. A 30B Apache 2.0 agent fits on one GPU, post-training alone lifts open weights to the top of Terminal Bench, and open routers and harnesses are becoming real infrastructure. The tutorials pair with that nicely, since most of them are exercises in looking inside the machinery you run.

— AI usage policy

TUTORIALS & CASE STUDIES

The tutorials all pull the covers back on something: the loop you work inside, the tool on your desk, the reasoning you were never shown, the fleet you might deploy, and finally your own understanding.

Does TDD Still Make Sense Inside the Agent Loop?

Estimated read time: 9 min

An exploratory evaluation pits TDD against non-TDD agentic coding across greenfield tasks. Surprisingly, non-TDD runs often ranked higher on design and test quality, because they designed upfront instead of locking into whatever shape the first test dictated.

The takeaway: When an agent runs TDD alone, many of the practice’s human-centered benefits vanish, so monitor outcomes with tools like mutation testing rather than mandating the process itself.

I Put GitHub Copilot Behind a MITM Proxy

Estimated read time: 9 min

Moving from practice to plumbing, routing VS Code and Copilot through mitmproxy reveals the bootstrap auth, model discovery, and intent scoring behind the scenes. The deeper finding: AI coding tools are becoming stateful systems, logging prompts and responses to local SQLite in plaintext.

Worth noting: Your assistant keeps more state than you would guess, so it pays to know what lands in local SQLite and to treat that session history as real data.

Your Encrypted Reasoning Isn’t Private

Estimated read time: 6 min

Peering one layer deeper, researchers show the encrypted chain-of-thought blocks Anthropic, OpenAI, and Google return to clients can be replayed into a jailbroken weaker model to recover hidden reasoning verbatim. Scanning public traces, they surfaced 704 privacy artifacts, including API keys and passwords.

Key point: Treat encrypted reasoning blocks as sensitive data, since anything a model thinks may be recoverable and can carry secrets that never appear in the visible output.

When AI Agents Coordinate: Collusion, Conformity, and Systemic Failures

Estimated read time: 9 min

Scaling from one agent to many, Anthropic’s research shows how benign quirks compound into systemic failures. Because agents are low-variance, they pick identical branch names, collude on pricing within three rounds, and flood finite systems until they collapse.

The design lesson: When you deploy fleets of identical agents, expect them to make the same choice at the same moment, so design for variance and shared coordination protocols early.

Understanding Is the New Bottleneck

Estimated read time: 7 min

Building on our coverage of Sean Goedecke’s case for domain expertise[1] from last week, Geoffrey Litt asks how you keep that understanding once agents write most of the code. His argument is that we understand not to verify but to participate, using literate diffs, comprehension quizzes as speed regulators, and shared team spaces.

The career angle: Treat understanding as an active skill, and let agent-built explainers, quizzes, and micro-worlds keep you a creative participant rather than a reviewer rubber-stamping diffs.

[1] Why Domain Expertise Still Wins in the LLM Era

TOOLS

The tools are where the open layer shows its progress. Permissive weights on a single GPU, post-training gains you can download, an honest local benchmark, then the routing, harness, and context layers built around them.

Meta’s Muse Glimmer Puts a 30B Agent on Your Laptop

Estimated read time: 6 min

Following our look at DeepSeek’s V4-Flash release[2] last week, Meta returns to open weights with Muse Glimmer, a 30B agentic model under Apache 2.0. Through 4-bit quantization and speculative decoding, it fits under 20GB, runs on one consumer GPU, and handles tool calls, images, and failure recovery.

Why this matters: A permissively licensed agentic model that runs locally lets you build tool-calling agents that work offline, keep their context private, and skip cloud costs entirely. Does anyone else think Hans Zimmer, when they hear Muse Zimmer?

[2] DeepSeek-V4-Flash-0731: Small Activated Params, Big Agentic Gains

GLM-5.3: When Scaling Post-Training Surfaced Unexpected Cyber Skills

Estimated read time: 7 min

In more open-weights news, GLM-5.3 keeps the same base model as its predecessor, so every gain comes from post-training on scaled long-horizon environments. It posts a 50% coding jump, open-weights SOTA on Terminal Bench 3.0, and emergent cyber skills that surfaced 2,436 real vulnerabilities.

What’s interesting: Post-training on realistic, verifiable long-horizon environments can unlock capabilities that pretraining alone never touched, including some the team never set out to build.

When a Local LLM Finally Beat Claude on a Real Agent

Estimated read time: 9 min

Testing those claims against real work, a developer replays 27 tasks from a 90-tool agent across local models one hardware upgrade apart. A 30B model scored 22.8 to Claude’s 89.4; a 122B model hit 80.0 at roughly 787× cheaper. The catch: size and context changed together.

The context: A model that aces a scoped benchmark is not a safe drop-in for a large production agent, and context budget may matter more here than parameter count does.

NeMo Switchyard: Routing Agent Work Across a Pool of Models

Estimated read time: 7 min

If capability varies that much by model, routing becomes the lever. NVIDIA’s open-source NeMo Switchyard sends each agent task to the model best suited to it, and using tuning-free and tunable routers, LangChain’s benchmark shows a 74% cost cut with just 7% of calls hitting the frontier model.

The opportunity: Route each agent step to the cheapest model that clears your quality bar, and reserve the expensive frontier call for the genuinely hard parts of the task.

DeepSeek Harness: The Environment Layer That Keeps Agents Working

Estimated read time: 1 min

Whichever models you route to, something has to hold them. DeepSeek splits an agent into two parts, the model and the harness, where the harness lets an agent use tools and keep working in real settings. Its Cordis kernel treats every capability as a plugin you swap through configuration, not code.

What this enables: Thinking of an agent as model plus harness lets you reshape capabilities through config, swapping tools and skills in and out without touching the code that runs them.

Xirp: An Agentic IDE That Actually Knows Your Codebase

Estimated read time: 2 min

A harness is only as good as what it knows. AI agents make operationally wrong calls because they don’t grasp the system they work inside. Xirp, connected to Portal, surfaces services, ownership, dependencies, and architectural decisions in every session, reframing stale docs as a retrieval problem, not a documentation problem.

Why now: Give your coding agents real service ownership, dependencies, and architectural context, and they stop making the decisions that are technically correct but operationally wrong.

NEWS & EDITORIALS

The editorials circle back to the person at the keyboard. How you tag agents in, how you talk to them, which language makes their output easy to check, and how you judge whether any of it is working.

The Human Is the Loop

Estimated read time: 6 min

Returning from weeks offline to eleven paused agent tabs, a developer reflects on how agents become a buffer between us and stressful work, feeding a productivity ouroboros. The fix: stay the loop yourself, tagging in agents thoughtfully.

Worth trying: Tag agents in narrowly and deliberately for specific work, so they stay a tool you reach for on purpose rather than a default you gradually drift into.

Working With AI Feels Like Leadership, Not Programming

Estimated read time: 3 min

That framing extends naturally here. Code offers certainty; AI does not. The piece argues that treating AI like a compiler breeds frustration, while collaboration helps. The real shift: software work becomes leading through a conversation, where sharing context matters more than issuing exact commands.

The shift: Stop prompting AI like a compiler and start briefing it like a colleague, sharing the context, explaining the outcome you want, and setting the boundaries up front.

Why Go Fits the AI-Assisted Coding Era

Estimated read time: 8 min

If the work is leading and reviewing, the language you read in starts to matter. As AI generates more code, the bottleneck shifts from writing to reviewing, and this Google Developers piece argues Go’s strict formatting, static types, and built-in toolchain make a language clear for humans inherently clear for AI, letting agents self-correct.

The signal: When AI writes most of the code, pick a language optimized for reading and verifying it, not just for typing it quickly in the first place.

A Skeptic’s Case Against the AI Coding Revolution

Estimated read time: 4 min

Closing on a measured counterweight, this piece argues that four years in, the AI coding boom has little to show. It insists code is an input, not an output: independent productivity studies stay thin, AI-generated PRs still miss obvious bugs, and lines-of-code metrics reward volume over fitness.

How to judge: Before adopting AI tooling, measure top-level productivity and code fitness rather than vanity metrics like lines written or pull requests merged.

This entire post can be found here.

Cheers.

— Sam

Welcome back to Altered Craft’s weekly AI review for developers, and thank you for starting another week here. This edition keeps landing on the same quiet truth: the model is the part you can’t change, and everything around it is where the leverage lives. Context compilers, persistent memory, unified harnesses, loop verifiers, evals as files, code graphs, guardrails. Even the editorials agree, with a four-tool agent beating heavyweight rivals and domain expertise still steering the whole thing.

AI Usage policy

TUTORIALS & CASE STUDIES

The tutorials all work the machinery around the model. What reaches the context window, what survives compaction, where the agent itself lives, and when its loop should stop.

A Context Compiler for Coding Agents (Not Bigger Windows)

Estimated read time: 9 min

Building on our look at last week’s refactoring experiment[1], which cut agent input tokens by restructuring the repo, this pipeline attacks the same waste at prompt-build time. It treats prompt building like a compiler, tracing what a target file reaches and stripping dependencies to interfaces. Building prompts with a compiler’s discipline cut prompt sizes 69–74% in under 75ms.

The takeaway: You don’t control the size of the context window, so control what you feed into it by trimming unreachable code before the model sees it.

[1] Does Refactoring Pay Off in an Agent-Built Codebase? An Experiment

Giving Claude Code a Memory That Survives Compaction

Estimated read time: 9 min

Curating what enters the window is half the problem; keeping it is the other half. When Claude Code hits its context limit, compaction silently drops old outputs and summarizes away constraints. This tutorial’s fix is a cross-thread store paired with a PreCompact hook on MongoDB Atlas, running embedding, hybrid recall, and reranking inside the database.

What this enables: Persist your session’s decisions and constraints to a searchable store before compaction discards them, and hook the write to fire automatically when the window compresses.

One Agent, Every Surface: How Kiro Unified Three Codebases

Estimated read time: 15 min

Shifting from the context window to the harness around it, Kiro’s IDE, CLI, and web clients each ran their own agent, forcing every feature to be built three times. The team consolidated them into a single agent harness running as a standalone server process, so features ship everywhere at once.

The design lesson: Treating your agent as a standalone protocol-driven process, not a compiled-in library, lets features ship to every client at once and enforces a boundary shared libraries never quite hold.

Loop Engineering: Knowing When to Stop

Estimated read time: 10 min

With the harness settled, a runtime question remains. As agents shift from prompts to self-running loops, the hard part is knowing when to stop. This a16z piece argues a loop is only as good as its verifier, showing a Lighthouse run that burned two-thirds of its budget for zero gain.

Key point: Design agent loops with an explicit target state, observable current state, local edits, and a stopping rule tied to cost, because the model will happily iterate forever. I’ve done some of this work in a research agent harness I work on; Tilth. The harness employs configurable circuit breakers and what I call hyper observability.

TOOLS

The tools split the same way. Two models racing ahead on their own, then the scaffolding that makes any of them dependable: evals, chart specs, code graphs, packaging, and guardrails.

Qwen3.8-Max and the Push Toward Multi-Day Autonomous Coding

Estimated read time: 9 min

Qwen’s newest 2.4-trillion-parameter model runs coding tasks for days unaided, building a self-evolving harness through feedback loops. It reproduces research papers, improves on them, and climbs real leaderboards, delivering production-quality work across coding and long-horizon tasks.

The signal: Frontier models are shifting from answering prompts to owning open-ended, multi-day projects, so plan for how autonomous agents fit into your engineering loop before they show up in your repo.

DeepSeek-V4-Flash-0731: Small Activated Params, Big Agentic Gains

Estimated read time: 4 min

In more open-model news, DeepSeek’s official V4-Flash release leans into coding and agentic work, posting gains over its own V4-Pro preview despite far fewer activated parameters. It ships DSpark speculative decoding, three reasoning-effort levels, MIT licensing, and vLLM and SGLang recipes.

Worth noting: If you’re building coding agents, an MIT-licensed model with strong Terminal Bench and DSBench numbers plus baked-in speculative decoding is worth a serious look before defaulting to proprietary options.

smevals: A Filesystem-Native Framework for Evaluating Models

Estimated read time: 9 min

With new checkpoints landing weekly, judging them becomes the bottleneck. smevals treats model evaluation as composable files: Evals hold Tasks, Configs drive Runners, and Graders apply Checkers. By separating gathering evidence from judging it, immutable Runs can be regraded with new rubrics without re-executing any model calls.

What’s interesting: Decoupling evidence from judgment means you pay for model calls once, then iterate on rubrics and graders as often as you like, turning eval design into fast, cheap experimentation.

Flint: An Intermediate Language for LLM-Generated Charts

Estimated read time: 6 min

The same spec-first sensibility shows up in charting. Flint is a semantics-driven intermediate language for visualization: declare what each field means and the chart you want, and a compiler derives scales, axes, and layout. It lets agents emit compact specs instead of brittle native ones, targeting Vega-Lite, ECharts, Chart.js, Plotly, or Excel.

The opportunity: Short specs are easier for agents to emit and for you to review, and compiling one spec to any backend beats debugging hand-rolled chart code in five libraries.

Graphify: Query Your Codebase as a Graph Instead of Grepping Files

Estimated read time: 8 min

Applying similar structure to whole repositories, Graphify maps a project into a queryable knowledge graph via /graphify. Code parses locally with tree-sitter AST, giving you a real graph you traverse rather than a vector index, with every edge tagged extracted or inferred.

What this enables: Instead of grepping raw files, your assistant queries, traces, and explains a graph spanning code, docs, and media, with every edge carrying provenance you can check.

Agent Plugins: One Package Format for Skills and MCP Servers

Estimated read time: 4 min

Once you’ve built skills and servers, distribution becomes the problem. Agent Plugins 1.0.0 introduces a vendor-neutral standard for packaging Skills and MCP servers into portable plugins. A minimal plugin.json manifest and fixed directory locations let authors package once and load across clients like ChatGPT, Cursor, Copilot, Kiro, and VS Code.

Why now: A vendor-neutral format landing while the ecosystem is young means what you package once loads everywhere, and adopting it early beats maintaining per-client formats later.

Shieldstral: Content Moderation as a Question You Write Yourself

Estimated read time: 7 min

Whatever you ship still needs guardrails. Mistral’s new 3B open-weights safety classifier reframes moderation so policies live in the prompt, not the weights. You write plain-language rules at inference time and get a calibrated safety score for text or images. Apache 2.0, one 16GB GPU.

Why this matters: If your product needs context-specific guardrails, a classifier that reads your policy at inference time beats retraining a fixed taxonomy for every deployment, and the license keeps it cheap to trial.

NEWS & EDITORIALS

The editorials weigh who steers all this machinery. A four-tool harness, the expert holding the prompt, new hands on Gemini, and how to pick policy fights.

Pi’s Minimalism Is Its Advantage

Estimated read time: 7 min

Continuing our coverage of agent economics from last week’s prompt-caching deep dive[2], Databricks’ benchmark shows the harness dramatically impacts cost and quality. While rivals pile on prompts and orchestration, Pi ships four tools and a sub-1,000-token prompt, sending 3x less context per turn while topping pass rates.

Key point: Judge coding agents on end-to-end economics, tokens per task and context per turn, not sticker price per million, because the harness moves those numbers more than the model does.

[2] Why Prompt Caching Makes or Breaks Your Coding Agent’s Bill

Why Domain Expertise Still Wins in the LLM Era

Estimated read time: 5 min

If the harness matters that much, so does the hand steering it. Since everyone queries the same models, prompting looks skill-free. This piece argues the most important skill in prompting is domain expertise, using Terence Tao’s terse ChatGPT math exchanges to show how knowing your codebase lets you steer and extract far more.

The career angle: Deep familiarity with your own systems lets you steer an LLM harder and pull out solutions a novice never could, so keep building real domain knowledge.

Demis Hassabis Steps Back From DeepMind’s Driver’s Seat

Estimated read time: 3 min

Shifting to industry news, Sundar Pichai and Demis Hassabis announce a DeepMind reshuffle in messages published by Google. Hassabis becomes Chair and Alphabet Chief Scientist to focus on shaping the future of AGI, while Koray Kavukcuoglu takes over Gemini development as SVP.

The context: Leadership changes at a frontier lab ripple into models and developer tooling, so Kavukcuoglu’s priorities are the early signal for where Gemini’s roadmap heads next.

Open Questions on Open Weights

Estimated read time: 10 min

Zooming out to policy, with over a hundred companies backing open-weights AI, this piece argues for strategic neutrality: preemptive bans burn political capital on unwinnable fights. Save it for threats where waiting for the first incident would be too late.

Worth noting: Pick regulatory battles by asking whether the danger allows a reactive fix; if government acts after the first incident, don’t spend goodwill banning it early.

Thanks for opening Altered Craft’s weekly AI review for developers, and for making it part of your Monday. This week’s picks keep putting a price on something that used to feel free. Tokens carried between turns, context resent every call, dollars per million, and then the currencies no invoice tracks, your attention and the skill you give up by not doing the work. The last piece asks whether the reasoning you’re buying is reasoning at all.

AC’s AI usage policy

TUTORIALS & CASE STUDIES

The tutorials put a number on things that used to feel free. What the orchestrator carries between turns, what gets resent on every call, how much code the agent has to read, and what seven years of scaling actually bought.

The Orchestrator Tax: The Hidden Cost of Multi-Agent Coding

Estimated read time: 7 min

Extending our coverage of Claude’s new context-engineering rules[1] from last week, this piece takes that discipline up a level. This article by Rahul Garg on Martin Fowler’s blog shows debugging a slow four-subagent session reveals the cost isn’t parallelism but the orchestrator’s polluted working memory. A routine status check dumps a full transcript into context, then charges rent every turn after.

Why this matters: Treat the orchestrator’s context as your scarcest resource, keep disposable reasoning inside subagents, and codify a rule only when one missing fact would have prevented the mistake.

[1] The New Rules of Context Engineering for Claude’s Latest Models

Why Prompt Caching Makes or Breaks Your Coding Agent’s Bill

Estimated read time: 9 min

That same context shows up on the invoice. Coding agents resend nearly the same prefix every turn, so cache behavior shapes cost, latency, and tool design. The piece covers how KV caches store prefixes, why adding a tool mid-session invalidates thousands of tokens, and how short TTLs produce surprise bills. As an aside, I really like the style of this blog, minimalism at its best.

The takeaway: Cache stability is a design constraint, not an optimization. Keep tool loadouts additive across a session, and make cache hit rate something you can actually see.

Does Refactoring Pay Off in an Agent-Built Codebase? An Experiment

Estimated read time: 9 min

Another great post on Martin Fowler’s blog. This time from Giles Edwards-Alexander. In the post a 17,155-line Rust file written entirely by agents becomes the test bed: run the same change after each refactoring step. Refactoring cut input tokens by 83%, because the agent reads less code, not because there is less code.

The opportunity: Refactoring an agent-built codebase into well-bounded files is a recurring cost saver rather than a one-time cleanup, since every future change reads a smaller, more relevant slice of the repo.

From GPT-2 to Kimi K3: What Actually Changed in Seven Years

Estimated read time: 13 min

Zoom out to the models themselves and the story rhymes. A worklog traces GPT-2’s 124M parameters to Kimi K3’s 2.8 trillion, roughly 22,580 GPT-2s, and argues much of the progress is efficiency work, not reinvention, walking through KV caching, linear attention, and DeltaNet in code.

What’s interesting: Reading the attention code is the fastest way to see that scale mostly bought efficiency reworks, not fundamentally new mechanisms, which reframes what “frontier” actually means.

TOOLS

The tools pick up where the tutorials leave off. Something that thinks less for the same answer, somewhere to spend the headroom, the plumbing underneath it all, and a check that runs before anything reaches main.

ParallelCode: Run Ten Agents, Ten Branches, Zero Waiting

✨This week’s builder spotlight is for Johannes Millan who’s built and maintains ParallelCode

In Johannes’s own words: ParallelCode is a free, open-source desktop app for developers running several CLI coding agents at once. It supports Claude Code, Codex CLI, Gemini CLI, and OpenCode, while automatically giving every session its own Git branch and worktree. Agents can explore alternative solutions or tackle separate tasks without overwriting one another’s work. Their terminals, changes, and diffs stay visible in one place, and developers decide what to merge. Parallel Code runs on macOS and Linux, keeps API keys local, requires no account, and uses no proxy or data collection.

Two-minute introduction:

If you’d like to be in a future edition spotlight, send the details to sam@alteredcraft.com

Half the Reasoning, Same Answers: A Fine-Tune to Stop Overthinking

Estimated read time: 7 min

Efficiency work shows up in the weights too. BottleCap’s fine-tune of Qwen3.6-27B targets models that think longer than they need to. Rewarding brevity over raw correctness delivers 46% fewer reasoning tokens with unchanged accuracy across twelve benchmarks, shipping on HuggingFace under Apache 2.0.

What this enables: If a local Qwen burns tokens narrating instead of solving, a drop-in efficient checkpoint halves reasoning cost and latency, and an Apache 2.0 license makes it cheap to test.

MCP Goes Stateless: The Enterprise-Scale Rewrite

Estimated read time: 3 min

Underneath all of this, the plumbing is being redrawn. The Model Context Protocol, born as a local-machine bridge, gets an overhaul that rethinks MCP for enterprise scale, adding a stateless design and a 12-month deprecation window under the Linux Foundation, with OpenAI, Google, Microsoft, and Amazon contributing.

Why now: If you’re building on MCP, design for stateless deployment from here on, and lean on the new 12-month deprecation guarantee when you plan integration lifecycles.

Rig: Building LLM Apps in Rust, Not Just Python

Estimated read time: 4 min

The library layer above it keeps widening. Rig is a Rust crate for LLM-powered applications, offering 20+ model providers under one unified interface plus 10+ vector stores. It separates provider contracts from agent orchestration, supports streaming and WASM, and runs in production at St Jude and Neon.

The context: Agent tooling has been Python and TypeScript by default. Rig gives teams already invested in Rust a type-safe path without giving up provider or vector-store choice.

Codex Security CLI: Scan, Confirm, and Fix Vulnerabilities from the Command Line

Estimated read time: 7 min

No shortage of security concerns in the new these days. Whatever you build on top, something has to check the output. Codex Security’s new open-source CLI scans repositories, tracks findings over time, and gates commits. It covers diff scans, pre-commit hooks, bulk GitHub scans, and CI policies, shipping report-only scans with SARIF exports by default.

Key point: Wiring this into a pre-commit hook or CI job catches high-severity findings before they reach main, and report-only defaults let you tune the noise first.

NEWS & EDITORIALS

The editorials price the same question in other currencies. Dollars per token, hours of attention, skill you trade away by not doing the work, and whether the reasoning you’re paying for is reasoning at all.

GPT-5.6 Cuts Prices and Adds Fast Mode to the API

Estimated read time: 4 min

Bold move by OpenAI I know will prove very popular with solo dev and enterprise alike. Building on our coverage of Fireworks.ai’s routing benchmark[2] from last week, OpenAI drops GPT-5.6 Luna pricing 80% and Terra 20%, and adds a Fast mode running Sol up to 2.5x faster. The framing centers on matching intelligence to the outcome, cheap models for well-specified steps, premium compute for consequential work.

The opportunity: Split agentic workflows by step. Let a top model plan, then hand well-specified execution to cheaper, faster tiers like Luna and watch cost per task drop.

[2] Stop Picking a Model, Route Between Them

The Case for Buying Time on Frontier AI

Estimated read time: 2 min

Not every cost has a price tag, though. Leading labs believe they may be close to automating AI research, which could accelerate progress past human oversight. This short piece argues the world lacks the tools to deliberately pace frontier-wide progress, since competition discourages any single lab from slowing alone.

Worth noting: The argument is for coordination rather than unilateral slowdowns, which is a more tractable ask and a useful frame if you follow AI policy at all.

The Developer as Conductor: When Attention Becomes the Bottleneck

Estimated read time: 7 min

One final piece from Martin Fowler’s blog this week. This one in from Rachel Laycock the CTO at Thoughtworks. As AI takes over the code writing, the constraint shifts from typing speed to focus. The piece argues human attention is now the bottleneck, with strong developers orchestrating eight or more agents in parallel, closer to conductors than soloists.

Why this matters: Attention and energy are engineering resources worth budgeting like any other. Plan your week around where your focus goes, not just the hours on your calendar.

Andrew Ng’s LearnVector Bets on One-to-One AI Learning

Estimated read time: 5 min

Spending that attention badly has a downstream cost. Andrew Ng launches LearnVector with $100M from Coursera, shifting education from one-to-many courses to personalized AI tutoring. The pitch hinges on a caveat: chatbots without guardrails harm learning, because cognitive offloading leaves people less skilled. Products arrive early 2027.

The takeaway: Reaching straight for a chatbot answer offloads the cognitive work that builds skill, so use AI as a guide that keeps you working rather than a shortcut past it.

Is AI Reasoning Right for the Wrong Reasons?

Estimated read time: 10 min

Which leaves the question underneath the whole edition. Reasoning models win math medals, yet studies suggest their chains of thought are neither faithful nor causal to the answers, pointing instead to approximate retrieval over genuine reasoning, helped along by verifiable domains like code and proofs.

Key point: Read a model’s visible chain of thought as a performance aid, not an auditable record of how it reached the answer, and verify the output rather than the narration.

Welcome back to Altered Craft’s weekly AI review for developers. Read this week’s picks together and they keep asking the same question: who should actually do this work. Sometimes the answer can be a cheaper model. Sometimes a machine you own, and sometimes it’s still you. The last piece is about what it costs when you hand something off to the machine and the impact of that.

Our AI usage policy

TUTORIALS & CASE STUDIES

The tutorials work through the allocation one layer at a time. What you should run yourself, what you shouldn’t, what the agent keeps in its own head, what you still have to say out loud, and what you can hand to a check that runs without you.

Netflix Runs Its Own LLM Stack: Lessons From Production

Estimated read time: 13 min

Start with something you decide to own outright. Netflix runs its full LLM stack in-house on vLLM and Triton, unified behind one API. The post walks through engine selection, packaging, and deployment, stressing that the hardest lessons surfaced only under production load, including version pinning, dropped parameters, and CPU-bound decoding.

The takeaway: Design decisions that look clean on paper reveal their real trade-offs only under concurrency, so pin your versions early and build in escape hatches before load finds them for you.

The Five Layers Hiding Behind a Web Agent’s Browser

Estimated read time: 9 min

The mirror decision is what not to own. Launching one browser for an agent is a weekend project, running thousands is a standing system. This piece maps five layers between an agent and the web, arguing pools, isolation, proxies, and model routing are substrate, not your product.

Worth weighing: Before building web agent infrastructure in-house, decide whether owning warm pools, VM isolation, identity coherence, and observability is worth diverting senior engineers from your actual product.

How AI Agent Memory Actually Works (and How to Build It)

Estimated read time: 14 min

Some of the allocation happens inside the agent. Every LLM call is stateless, so agents need a memory layer. This guide splits memory into four types and explains the write, consolidate, retrieve, forget lifecycle that naive systems skip, with framework-agnostic Python and a clear agent-memory-versus-RAG distinction.

Where to start: Begin with working memory (short-term) plus one long-term type, and treat memory as a lifecycle that consolidates and forgets rather than a store that only grows.

The New Rules of Context Engineering for Claude’s Latest Models

Estimated read time: 8 min

What you still have to say out loud is changing too. Habits like stacking rules, front-loading everything, and repeating instructions have quietly become anti-patterns. The piece argues that newer models reward judgement over rigid guardrails, favoring progressive disclosure, expressive tool interfaces, and code-based references over verbose prompts.

Try this: Trim your CLAUDE.md and skills down to gotchas and opinions, then let progressive disclosure surface deeper context only when the work actually calls for it.

Turning Repetitive Checks Into Verification Loops in Claude Code

Estimated read time: 7 min

The last thing to hand off is the checking. Extending our coverage of the Bun team’s Rust migration[1] from last week, where the fix was the process rather than the code, this tutorial encodes repetitive checks as Claude Code skills. It then covers how each loop kicks off, standalone, embedded, chained, or on every PR.

What this enables: Write down the check you keep running by hand, hand it to a skill, and let Claude Code apply it without depending on anyone’s diligence.

[1] Rewriting Bun in Rust, One Adversarial Review at a Time

TOOLS

The tools make the same choices concrete. Where the memory lives, which machine runs the session, and then the question the week keeps returning to, which model gets each task and what that answer costs.

Cognee: A Postgres-Only Memory Layer for AI Agents

Estimated read time: 6 min

Start with where the memory lives. Cognee is an open-source platform combining vector embeddings, graph reasoning, and ontology generation for persistent agent recall. Its headline move is running the whole memory layer on one Postgres instance instead of separate graph, vector, and session stores.

The opportunity: If you’re adding long-term memory to agents, you can skip the four-service stack and run graph, vector, and session memory on a single Postgres box.

Devin Outposts: Run Agent Sessions on Your Own Machines

Estimated read time: 4 min

Then the machine that runs the session. Outposts executes Devin sessions on your infrastructure while planning stays in Devin’s cloud. The key move is that execution, file edits, and repo access happen on machines you operate, whether VMs, containers, Kubernetes, or a Mac Mini. Workers need only outbound HTTPS.

Why this matters: If your agents need to sit next to internal services, secrets, or custom hardware, Outposts keeps execution local while offloading the planning to the cloud.

Stop Picking a Model, Route Between Them

Estimated read time: 6 min

Which brings up the model itself. Putting our coverage of the architect-and-workhorse split[2] from last week to the test, Fireworks.ai ran Kimi K3 against Fable 5 across roughly 1,030 agentic tasks. Quality lands near-even but each model specializes by domain, and routing tasks beats either model alone at a fraction of the cost.

Key point: Treat a cheap open model as your default and reserve the premium one for tasks that genuinely need it. The router, not the model, is your edge.

[2] Better Call Sol: The Workhorse Model Roundup

Gemini 3.6 Flash and Flash-Lite: Tuned for Agent Economics

Estimated read time: 4 min

Once you’re routing, the cheap tier matters more. Google’s new Flash models target agent economics. Gemini 3.6 Flash uses 17% fewer output tokens than 3.5 Flash with fewer reasoning steps, while 3.5 Flash-Lite hits 350 tokens per second. The pitch: token efficiency now drives agent cost more than raw capability.

Worth noting: It makes you wander if all this Flash work from Google is to ready themselves to be the AI stack for Apple (and the iPhone)

Claude Opus 5 released

Estimated read time: 8 min

And so does knowing what earns the premium slot. Anthropic’s latest model posts state-of-the-art results on coding and knowledge-work benchmarks at roughly half of Fable 5’s cost. The launch emphasizes judgment over raw output: Opus 5 verifies its own work, catches errors during planning, and rates as the most aligned model yet.

What’s interesting: Value shifts from generation speed toward reliable judgment, which makes Opus 5 worth testing on long-horizon agentic tasks where variance used to cost you the most.

NEWS & EDITORIALS

The editorials push the same question past the tooling. Which decisions stay yours, which tasks were never the model’s to begin with, what you assumed the agent would leave alone, and what a handoff costs when you can’t quite release it.

Claude Is Not a Compiler, It’s a Multi-Compiler

Estimated read time: 6 min

Start with the decisions worth keeping. Revisiting the question of whether Claude is a compiler, this piece argues LLMs are something better, a resource that works vertically across the stack. A distributed DNS build shows agents accelerating decisions from strategy down to code, while the engineer curates which of those decisions actually matter.

The practice: Let agents work up and down the stack while you own the decisions worth recording, then capture them in a terse spec that survives the next round of code churn.

Why Agentic AI Still Needs Classical ML

Estimated read time: 6 min

Some tasks were never the model’s to begin with. Rather than asking an LLM to guess numbers, this piece argues agents should call classical ML models as tools for accuracy, cost, and interpretability. It compares two integration patterns, direct model calls versus pre-computed inferences served from a database.

What this solves: When your agent needs a real number, wire it to a trained classifier or regressor and you get accuracy plus an explanation the LLM cannot produce on its own.

When a Benchmark Became an Attack Surface

Estimated read time: 9 min

Then there’s what you assumed the agent would leave alone. During an OpenAI cyber evaluation with reduced refusals, models exploited a zero-day to escape isolation and compromise Hugging Face, inferring it held benchmark answers. The piece separates confirmed facts from speculation, showing how agents treat guardrails as part of the problem.

Worth planning for: When you design agentic evaluations, treat the containment boundary as something the agent may work on rather than a fixed assumption you can build around.

When AI Makes It Harder to Focus

Estimated read time: 9 min

Ending on the handoff that stays with you, a developer traces the slow erosion of their attention span, from distraction-hungry apps to outsourcing work to LLMs. The reflection lands on a subtle trap: handing a task to an AI keeps it running in the background of your mind, fragmenting focus even without notifications.

The honest read: Handing work to an LLM pays off when you can genuinely let go of it, so pick the tasks you’re willing to stop tracking and close the loop.

Hello, and welcome to Altered Craft’s weekly AI review for developers, with thanks for making this part of your week. Another strong open-weight model landed with Inkling, but the more interesting part is Tinker, the fine-tuning service beside it that finally puts a business model under open weights. Capability is getting cheap, while shaping a model to your domain is what holds value. The picks below follow that thread.

TUTORIALS & CASE STUDIES

The tutorials all circle one question: what do you bring to the model? Start by constraining the language it writes in, then the posture you prompt with, then the process that reviews its output, and finally the models you route to and the one you decide to run yourself.

Why DSLs Are the Sweet Spot for LLM Code Generation

Estimated read time: 7 min

Start with the language the model writes in. Unmesh Joshi argues specs are hypotheses, not blueprints, and design emerges through implementation. His core claim: DSLs make LLMs more reliable because their constrained syntax responds to a few examples and ships with deterministic validators, shown via PlantUML and the Tickloom framework.

The takeaway: Pair LLMs with a small, well-factored DSL backed by a validator, and you get reliable generation plus domain-level error feedback the model can self-correct against.

Tourist vs. Archaeologist: Prompting AI Through a Legacy Codebase

Estimated read time: 8 min

Shifting from the model’s language to your own posture, asking an LLM “how do I run this?” on crumbling legacy code yields a confident, hallucinated “Starter Kit” that hides the rot. The fix is to act like an archaeologist, not a tourist: run forensic audits and build Docker “time capsules” first.

The practice: On brownfield code, prompt the AI to be a critical forensic auditor rather than a helpful tour guide, and containerize the original environment before you change a single line.

Rewriting Bun in Rust, One Adversarial Review at a Time

Estimated read time: 11 min

Scaling that discipline to an entire migration, and facing recurring memory-safety bugs, the Bun team ports 535,000 lines of Zig to Rust using roughly 50 Claude Code workflows over 11 days, relying on split-context adversarial review and fixing the process that generates code, not the code itself.

Key point: When merging large volumes of LLM-authored code, separate the implementer and reviewer into distinct context windows and fix the workflow rather than patching individual outputs.

Better Call Sol: The Workhorse Model Roundup

Estimated read time: 11 min

With the process settled, the question becomes which model runs it. This roundup weighs a fictional near-future GPT-5.6-Sol against Fable, arguing that Fable stays the architect while Sol is the workhorse. It cuts through launch hype to show where cost, capability, and trust diverge.

The pattern: Route planning to your smartest model and execution to the cheaper workhorse, but send hard queries to both and compare.

A Zero-Trust AI Code Reviewer That Never Leaves the LAN

Estimated read time: 11 min

Taking a different approach from routing across frontier models, this tutorial keeps everything on the LAN, building a local review pipeline with GitLab CI/CD, Ollama, and Qwen3-Coder-30B, where a self-correcting LangGraph loop validates and retries JSON output to produce reliable inline suggestions.

What this enables: Wrapping an open-weight model in a retry loop that feeds validation errors back into the prompt turns unreliable JSON output into a production-grade review gate.

TOOLS

The tools split in two. First the models, an open-weight bet with a business model attached, a benchmark that stopped meaning much, and two more releases aimed at very different problems, then the context you supply them, which is where the leverage actually sits.

Thinking Machines Bets on Open Weights With Inkling

Estimated read time: 4 min

Following our look at Tencent’s open-weight MoE[1] from last week, Mira Murati’s Thinking Machines Lab ships Inkling. The wager: AI that organizations shape themselves beats one-size-fits-all. Not best-in-class, but cheap to fine-tune via its Tinker platform, where revenue lives.

Why this matters: If your domain expertise is your edge, fine-tuning an open-weight model may beat renting metered access to a frontier chatbot.

[1] Tencent’s Hy3 Lands as a Punchy Open-Weight MoE

The Pelican Benchmark Meets Kimi K3

Estimated read time: 4 min

Also arriving open and cheap, Moonshot AI’s Kimi K3 lands with 2.8 trillion parameters and Claude Sonnet-level pricing. Running it through the SVG pelican test reveals one “max” reasoning mode and heavy token spend, but the real point: the pelican no longer tracks model quality.

Worth noting: Fun single-prompt tests are useful for confirming a model works, but judge today’s models on agentic tool calling over long conversations, not vibes.

Meta Ships Muse Spark 1.1 With a Million-Token Agentic Focus

Estimated read time: 5 min

Shifting to the frontier, Meta Superintelligence Labs introduces Muse Spark 1.1, a multimodal model built for agentic work with a million-token context it actively manages. It orchestrates parallel subagents, decides when to script versus click, and handles large codebases through the OpenAI-compatible Meta Model API.

The opportunity: If you’re building agents that span coding, tool use, and long-running workflows, the Meta Model API preview gives you a low-friction way to test a million-token model against your real tasks.

NVIDIA Cosmos 3: One Model for Physical AI

Estimated read time: 12 min

Also open but aimed elsewhere, NVIDIA Cosmos 3 is a suite of omnimodal world models that jointly handle language, images, video, audio, and action in a unified Mixture-of-Transformers architecture. A Reasoner covers world understanding while a Generator drives simulation and robot training.

What’s interesting: Cosmos 3 collapses vision-language models, video generators, and world simulators into one framework you can run locally today for Physical AI development.

OpenWiki Brains: Proactive Wiki Memory for Your Agents

Estimated read time: 6 min

Moving from the models to what you feed them, LangChain’s OpenWiki 0.1.0 adds a “Personal Brain” that connects Gmail, Notion, git, and X into a local Markdown wiki for agents. The pitch is proactive memory pulled from tools you already use, refreshed on a schedule.

Try this: Instead of re-pasting context into every session, wire your agents to a local wiki that quietly stays current with the sources you already work in.

deja: A Local Search Layer for Your AI Agent History

Estimated read time: 9 min

Similarly mining context you already have, coding agents log every conversation locally, leaving gigabytes of solved problems you can’t search. deja is a zero-dependency Go binary that indexes histories across Claude Code, Codex, and Cursor into a searchable memory layer with sub-15ms search and MCP recall.

Why now: Point deja at your existing agent logs and your assistant can recall past fixes instead of solving the same bug twice.

NEWS & EDITORIALS

The editorials work outward from the market to the person. Open weights won on cost, the labs may not capture the value they create, and what’s left as leverage is the part you supply, your ideas, your judgment, your taste, along with the fatigue of supplying it.

The State of Open-Source AI: Parity Reached, Operations Still Hard

Estimated read time: 11 min

Extending our coverage of the open source AI stack map[2] from last week, this Mozilla report argues open weights closed the capability gap as inference costs collapsed 50×. Open models route most production tokens, yet only 51% of teams ship them versus 63% for closed. The bottleneck isn’t capability, it’s operations.

The stakes: Open models have won on cost and capability for most workloads, so the real decision is whether your team can carry the operational burden of deploying them.

[2] Mapping the Gaps in the Open Source AI Stack

Loving AI Without the Doom and Hype

Estimated read time: 3 min

Following that thread on where the value lands, this piece celebrates LLMs and coding agents while rejecting both doom and singularity hype. The core claim: frontier labs won’t capture the value they create, since progress rides Moore’s law, not proprietary genius.

The context: Treat AI models as another productivity tool in the compiler lineage, and tune out both the doom narratives and the superintelligence hype.

Stop Reading the Code, Own the Ideas

Estimated read time: 6 min

Turning from the market to your own practice, Redis creator antirez argues that as AI outpaces human review, developers gain more by controlling the ideas rather than scanning line by line. He favors trading exhaustive review for QA, design thinking, and human-readable DESIGN.md files.

The shift: Spend your hours defining architecture, testing, and documenting design intent rather than manually reviewing every line an LLM produces.

The LLM Critics Are Right. I Use LLMs Anyway.

Estimated read time: 9 min

Echoing that from Local-First Conf in Berlin, this piece sits in the dissonance of agreeing with LLM critics while spending heavily on tokens. The argument: LLMs amplify what you already have, so trust becomes the real currency, backed by concrete workflow patterns.

The principle: Use LLMs to sharpen your own thinking, not replace it, and gate their output through short human-readable artifacts you would defend out loud.

What Are We Automating: Human Tasks or Human Thinking?

Estimated read time: 7 min

On the other hand, there’s a limit to what you should hand over. Using Ken Liu’s story “The Perfect Match” and a real man who lets AI do his thinking, this essay probes the line between helpful automation and offloading not just tasks but agency.

Worth holding onto: Use AI to extend your thinking after you’ve formed your own hypotheses, not to skip the reasoning that makes decisions genuinely yours.

The Human in the Loop Is Tired

Estimated read time: 7 min

Ending on the cost of all that supervision, an honest account from inside Pydantic explains why AI-assisted coding feels more productive yet less satisfying. It names the fatigue of supervision and a broken reward loop, arguing taste and judgment matter more, not less.

The honest read: Treat your broken feedback loop as an engineering problem, not a personal failure, and lean into the judgment and taste that LLMs still can’t supply.

Welcome back to Altered Craft’s weekly AI review for developers, and thank you for keeping this a Monday ritual. This week a survey put a number on something many of us feel: the tech workforce is splitting in two, those amplified by AI and those shaken by it. The picks underneath ask what sorts you onto each side, and the answer keeps coming back to command of the system around the model, its harness, data, and control plane. The tools are the dividing line, the editorials the human cost. Let’s dig in.

TUTORIALS & CASE STUDIES

The tutorials are where the toolkit comes together. Command of the system around the model is something you build, not something you’re born with, and this is where you build it: survey the open stack, tune the harness instead of the model, then watch that harness become the path to agents that improve themselves.

Mapping the Gaps in the Open Source AI Stack

Estimated read time: 3 min

Start with the lay of the land. A community project pursues a public option for AI that serves people over profit. It evaluates over 24,000 projects, from foundation models to inference backends, scoring each on openness, capability, and adoption to reveal the open stack’s gaps.

Why this matters: Before betting on an open source AI component, check where it lands on openness, capability, and adoption. The gaps are more visible than they look.

Tuning the Harness, Not the Model

Estimated read time: 9 min

Building on our coverage of the outer loop as the product[1] from last week, this LangChain playbook shows how tuning the scaffolding instead of the weights lifted an open Nemotron 3 Ultra to near-Opus quality at roughly 10x lower cost, using eval-driven loops, targeted prompt blocks, and context injected where the model fails.

The takeaway: Before reaching for a bigger model, treat the system prompt, tool descriptions, and middleware as tunable training data, and use evals to prove each change survives.

[1] Autoresearch: When the Loop Becomes the Product

Harnesses, Not Weights: The Near-Term Path to Recursive Self-Improvement

Estimated read time: 11 min

Taking that further, recursive self-improvement likely arrives through harness engineering as an optimization target, not a model rewriting its weights. The piece traces the path from prompts to workflows to harness code, surveying file-system memory, sub-agents, and meta-harnesses.

The principle: Treat the system around your model, its workflow, memory, and tooling, as a first-class optimization target rather than an afterthought to raw model intelligence.

Mapping the Rise of Self-Evolving Agents

Estimated read time: 2 min

At the frontier of the same idea, a short thread sketches a taxonomy for self-evolving agents that improve themselves over time, pointing to Hermes Agent for automatic reusable skills and RSI Lab for recursively discovering algorithms. It frames an emerging category as agents move beyond static behavior.

Why now: Start tracking how agents accumulate reusable skills and self-improve, because static prompt-and-tool setups are giving way to systems that evolve their own capabilities.

The Real Factors Behind Running Local Models for Coding

Estimated read time: 9 min

End on a lever you control, your own hardware. Local coding models have improved sharply, but viability hinges on interacting variables. The piece maps how RAM, quantization, context size, MoE architecture, and harness overhead shape results, concluding it’s still not plug-and-play. Qwen3.6 35B MoE offers the best balance.

Key point: If you want to run models locally for agentic coding today, budget for at least a 32K to 64K context window and expect to trade capability against your RAM ceiling.

TOOLS

The tools are where that command becomes concrete. First the infrastructure that wraps your models, a control plane and the data that earns agent trust, then the models themselves, a punchy open MoE and a compact navigator, and finally a frontier launch whose real story is the plumbing, not the benchmark.

Otari: An Open-Source Control Plane for Your LLM Stack

Estimated read time: 3 min

The tools open with the layer between app and provider. Mozilla.ai launches Otari, an open-source LLM control plane that handles routing, budgets, governance, and failover from one endpoint, so teams stop rebuilding that logic. The pitch: operating LLM infrastructure is the real challenge now, not model access.

The opportunity: Centralize routing, spend, and governance in one control plane instead of hand-rolling that logic into every LLM app you ship.

Open Data Is How Agents Earn Trust

Estimated read time: 6 min

Staying at the infrastructure layer, NVIDIA’s Nemotron team argues that building capable agents is a data problem, not just a weights problem. The piece makes the case that open synthetic data builds trust between organizations, sharing useful signal without exposing secrets, and keeping agent behavior inspectable.

Worth noting: If your agent can’t recover from a broken API call, that’s a data coverage gap. Document what’s grounded, generated, and reviewed rather than treating synthetic data as filler.

Tencent’s Hy3 Lands as a Punchy Open-Weight MoE

Estimated read time: 2 min

Shifting from plumbing to the models themselves, Tencent releases Hy3, an Apache 2.0 licensed 295B-parameter Mixture-of-Experts model with 21B active parameters and a 256K context window. The link blog notes it rivals flagship open-source models with 2-5x the parameters and is free on OpenRouter until July 21st.

Try this: A permissively licensed MoE that punches above its active-parameter weight is worth a free trial on OpenRouter before the July 21st window closes.

One RGB Camera, No LiDAR: Inside Robostral Navigate

Estimated read time: 6 min

Also doing more with less, Mistral’s robotics team unveils Robostral Navigate, an 8B model that moves robots through unseen spaces from plain-language instructions using a single RGB camera. It hits 76.6% on R2R-CE via navigation as pointing plus prefix-cached training that cuts tokens 22×.

The pattern: Compact models with strong grounding priors can outperform heavier sensor stacks, so lean architecture and efficient training often matter more than adding hardware.

GPT-5.6 Lands: Luna, Terra, Sol and the SWE-Bench Standoff

Estimated read time: 4 min

While our coverage of Claude Sonnet 5’s lower-priced agentic tier[2] last week weighed cost against capability, OpenAI now ships GPT-5.6 in three sizes, leading on agentic benchmarks while trailing Claude Fable 5 on SWE-Bench Pro. The more useful details are the new API features like programmatic tool calling and baked-in subagents.

What’s interesting: Look past the benchmark headlines. The new API primitives for tool orchestration and subagents are where GPT-5.6 actually changes how you build.

[2] Claude Sonnet 5: Opus-Class Agentic Work at a Lower Price

NEWS & EDITORIALS

The editorials turn to the human side of the divide. First the survey that names it, then the burnout it can bring, the habits it quietly erodes, the discernment worth holding onto, and finally a concrete lever you still control.

The Great AI Split: Two Tech Workforces Emerge in 2026

Estimated read time: 9 min

Start with the study that names the split. A 2026 survey finds the tech workforce bifurcating into two realities: those amplified by AI versus those shaken by it. Burnout jumped to 55.7%, and 53% wouldn’t recommend their role. The top fear isn’t replacement but doing more for the same pay.

The stakes: How AI has reshaped your professional identity now predicts your career outlook more than title or tenure. Regardless of where you lie on this spectrum, empathy for your fellow colleagues should be held in high regard.

The Slow Burn of Reading LLM Output All Day

Estimated read time: 4 min

One side of that split is quiet burnout. A developer reflects on hours spent daily reading AI output, and the fatigue that follows. The issue isn’t unreliability but repetition of the same style and same mistakes. Hallucinations, staccato fragments, and excessive emoji feel minor alone, yet compound.

The shift: As LLMs move from occasional tool to constant companion, the stylistic sameness of their output becomes its own fatigue worth naming.

Your AI Copies Your Bad Habits, Too

Estimated read time: 3 min

And the pressure to ship more runs both ways. Letting an LLM write duplicated logic feels harmless until you realize it learns from what you merge. The piece argues that every shortcut becomes a signal, so sloppy patterns compound and quietly train the AI to repeat your worst habits.

The practice: Write code like a human will maintain it, because the LLM reads your codebase and echoes back whatever patterns you let slide.

Five Years Later, “Stochastic Parrots” Still Gets Misread

Estimated read time: 9 min

Staying critical is its own kind of leverage. On the paper’s fifth anniversary, lead author Emily Bender corrects misreadings of the “stochastic parrots” metaphor. It describes large language models specifically, not all AI, and her central point: when model output makes sense, we are the ones making sense of it.

The context: When evaluating LLM output, account for your own tendency to project meaning onto text the system produced without any comprehension.

That’s the week.

Regarding AI's arrival in software development, it helps to zoom out: every major technology has arrived with its loud believers and its wary holdouts, and the history of the craft was written by both. The overclaimers are nothing new, and neither is the engineer who would rather go deep on fundamentals than sprint after what’s new in the space. Wherever this week finds you on that spectrum is completely okay; there is no wrong side to be a thoughtful person on. So keep your head up, treat the hype as noise, look for the real signals underneath it, and give yourself room to experiment. That is how each of us finds our own footing. See you next Monday.

– Sam