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

Two caveats up front. First, this is app development, not a large distributed system. In theory a big system breaks into cohesive modules, and an agent could own one module and its contract with the others, but I haven’t validated that at scale. The second: Rust is a newish stack for me, which shapes much of what follows.

Here’s what’s working for me:

• Steer with directives. A solid set of agent files (CLAUDE.md) for the programming language does more for me than any single prompt.

A sample of my current Rust directives
Rust data modeling

• Ownership forms a tree/DAG, never a cycle. One clear owner per value.

• For references between values (or any logical cycle): use slotmap keys, or Vec indices only if nothing is ever removed.

• ...

Full set in this gist.

• Limit third party dependencies. Add a clause to your agent file: be conservative with third party dependencies. Weigh a few options, favor the well-maintained ones, and ask before adding.

• Make the test suite your source of truth. If you’re not going to review and gate the functional code line by line, fixate on the tests. It’s the closest-to-code abstraction I have for gauging whether the implementation is correct. Telling the agent to “create tests” isn’t enough; left alone it will write tests that pass without proving much. So I give it a TDD directive and name the anti-patterns to watch for. Over-mocking is the big one: mock enough of the surrounding code and you stop testing your logic and start confirming that the mock framework returns what you told it to. A test suite I trust, plus a current frontier model with good steering, gets me solid results at app scale.

• Build kernel-first. Build bottom-up. Start with the data structures, and then the business logic to manage them. No UI. This narrows scope and makes the conversation with the model clearer. Keep the UI decoupled from the kernel, so more of the system is testable without it. This is where SWE fundamentals pay off: dependency injection, decoupling, testable seams.

• Pause at the end of each stage. Ask the agent how to smoke test what you built. Dig into anything that doesn’t sit right, and later have it build HTML walkthroughs. Have it review the session’s changes for business logic that landed in more than one place; that scattering usually signals a cleaner module boundary or an extracted method. Before the next stage, have it curate the docs: fix inaccuracies, consolidate duplication, sync the agent files.

• Scope milestones to a session. I work toward an early MVP in a series of discrete milestones, one milestone per session. If I’m reaching for /compact, the milestone was too big.

Underneath these tactics is one idea: keep the system legible enough that you and the agent share a picture of what it’s actually doing. As complexity climbs, complete, accurate, actionable instrumentation matters more, so lay these foundations early.

The part I’d underline is patience: think about your actual motivation. Mine is simple: get better at reading and interpreting Rust, and learn to spot the anti-patterns and rough edges I’m sure are sitting in this codebase. Building something real that I plan to rely on makes those lessons stick. So I take the occasional “no new features” day to dig into one component, or improve the test suite. Refactoring for understanding counts as progress.

There’s a lot of pressure to treat velocity as the only metric, to produce more code, faster. Some of that comes from leadership, and if that’s your mandate, I feel for you; that’s a genuinely tough spot. But a lot of it is ambient: feeds full of confident takes and flashy demos that make careful work feel like falling behind. calls that AI confidence theater, and much of the certainty is performance. If you get time to work with AI on your own terms, deliberate work isn’t falling behind. It’s how you end up understanding what you built.

I am actively iterating on this approach on B2, my effort to build a personal knowledge management app.

Thanks for opening Altered Craft’s weekly AI review for developers, and for making this a Monday habit. One thread runs through this week’s picks: the burden of proof has moved onto the output. An essay on AI confidence theater puts it plainly, sounding competent quietly replaced being competent, and the rest of the issue answers with evidence. Verify the fix, contain the code, gate the endpoint, score the prompt, prove the exploit. The claim is cheap now, so the proof is where the work lives.

TUTORIALS & CASE STUDIES

This week’s tutorials walk the burden of proof down the stack: verify the fix a human should still own, contain the code you cannot fully trust, gate the endpoint behind real authorization, then run it all on infrastructure that records what happened.

The Sorcerer, Not the Apprentice: Fixing a Parser Bug With AI

Estimated read time: 6 min

It starts with the fix you are tempted to accept. Walking through a real hyperscript parser regression, this essay shows AI excelling at root-cause investigation and tests while proposing progressively hackier fixes. The clean solution came from a knowledgeable human restraining complexity an agent alone would have shipped as technical debt.

The takeaway: Let AI investigate causes and grind out tests, but keep a human who understands the architecture deciding which fix actually ships.

Running Untrusted Agent Code Without a Sandbox

Estimated read time: 6 min

If you cannot fully trust the fix, trust the generated code even less. Complementing our coverage of AWS Lambda’s isolated MicroVMs[1] last week, LangChain takes the opposite tack: with prompt injection unsolved, its Code Interpreter for Deep Agents runs orchestration inside WebAssembly with QuickJS, so the runtime starts with nothing and bridges capabilities deliberately, even pausing for approval.

The principle: Constrain what agent code can touch instead of trusting it to behave. Start from zero capabilities and bridge in only what each workflow genuinely needs.

[1] AWS Lambda MicroVMs: Isolated Sandboxes for User and AI-Generated Code

Put Your LLM Endpoint Behind an OAuth Boundary

Estimated read time: 16 min

Beyond the code it runs, the endpoint itself needs a gate. This tutorial wires Azure API Management and Entra ID to add OAuth 2.0 authorization in front of a Foundry-hosted GPT model. The principle: don’t expose your model endpoint directly. Policies validate each token’s tenant and client.

Worth noting: Gate your LLM calls behind an API gateway that checks token issuer and client, so not every valid Entra ID token gets through to the model.

Mistral’s Workflows: Document Processing in 30 Minutes

Estimated read time: 3 min

With those checks in place, the pipeline still has to run provably. Mistral introduces Workflows, an orchestration platform for building, executing, and monitoring AI-driven pipelines. The walkthrough shows how to build a document processing workflow in 30 minutes, backed by durable, fault-tolerant execution on distributed infrastructure.

What this enables: If you are chaining AI steps into a pipeline, purpose-built orchestration with fault tolerance and monitoring beats hand-rolled glue code you cannot replay.

TOOLS

The tools split into the engines that do the work and the ones that prove it: an affordable frontier-class tier, a router that decides without a model, a full GLM stack, then two that insist on evidence, scored prompts and working exploits.

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

Estimated read time: 5 min

The tools start with the engine. Anthropic’s latest mid-tier model narrows the gap with Opus-class performance at lower prices. Sonnet 5 plans, uses browsers and terminals, and sustains multi-step coding autonomously, and early partners report it finishes complex jobs earlier Sonnets abandoned.

Why this matters: Adjustable effort levels let you tune the cost-performance tradeoff, making Sonnet 5 a practical default for sustained agentic coding and tool-use work.

Wayfinder: A Model Router That Makes Its Routing Call Without a Model

Estimated read time: 9 min

You do not need that engine for every request. Wayfinder scores each prompt’s structure and wording, sending easy requests local and hard ones to your expensive tier. The standout is a deterministic, offline decision with no model call, no key, no network, and it speaks the OpenAI API.

The opportunity: Stop paying frontier prices for “fix my typo.” Route prompts by difficulty with a free, deterministic decision that drops in behind your existing OpenAI client.

ZCode and the GLM Coding Plan: An Agentic Coding Stack Built Around GLM-5.2

Estimated read time: 2 min

For a full stack around a cheaper engine, ZCode pairs a coding agent with tiered GLM plans from $16.20/month, tuning GLM-5.2 for reasoning and multi-agent work. The pitch centers on keeping every engineer on the frontier, with long-running Goals and bot control from WeChat, Feishu, or Telegram.

Try this: If you want an agentic coding setup that steers work from chat and handles long-running tasks, ZCode’s GLM-tuned tiers are worth a look.

Stop Hand-Tuning Prompts: How DSPy Automates the Work

Estimated read time: 7 min

Whatever model you land on, the prompt driving it needs proof it works. Prompt engineering is slow and unreliable, since eyeballing a few outputs rarely shows a prompt holds in production. This piece argues for treating prompts like ML models, using DSPy to define test data and a scoring function that grades candidates automatically.

The pattern: Bring ML-style evaluation to your prompts. Define a test set and a scoring function, then let DSPy generate and grade candidates instead of guessing.

Strix: Autonomous AI Agents That Pentest Like Real Hackers

Estimated read time: 6 min

Proof matters most where security is on the line. Strix is an open-source pentesting tool where AI agents validate vulnerabilities with working proof-of-concept exploits, not static-analysis noise. It ships a full offensive toolkit, multi-agent orchestration, and a CLI that drops into CI/CD to block insecure code before it merges.

The payoff: Wire Strix into your pull request workflow to catch and reproduce real exploits before insecure code reaches production.

NEWS & EDITORIALS

The editorials weigh substance against performance: the theater of sounding capable, the expertise that judges real output, the loop that keeps a system honest, AI proving flaws at scale, and the unglamorous fundamentals that outlast clever bets.

Please Stop the AI Confidence Theater

Estimated read time: 11 min

The editorials open on the gap the whole issue answers. A pointed critique of performative AI hype flooding social feeds and hiring, where sounding competent replaced being competent. The piece argues the gap between demo and daily reality erodes trust and buries the real work of tuning living AI systems.

The context: Be honest about what your AI workflows actually do. A prototype that saves 20 minutes beats a viral claim that collapses on inspection.

The Twilight of the Chatbots

Estimated read time: 7 min

If competence has to be shown, someone has to judge it. AI capability is climbing a better-than-exponential curve, with agents running autonomously for hours on work that once took teams weeks. The shift moves from chatbots to managing fleets of agents, where domain expertise predicts who gets the most useful output.

The shift: Treat agents like direct reports you manage rather than chatbots you collaborate with, because your domain expertise turns long-running AI into real output.

Autoresearch: When the Loop Becomes the Product

Estimated read time: 10 min

Building on our coverage of loop engineering[2] last week, Introspection’s Roland Gavrilescu unpacks “autoresearch”: an outer loop where agents maintain and improve the primary system via evals, judges, and human signals. The reframing is that the loop is the product, packaged into portable “agent recipes” teams can own.

Why now: Invest first in the signals you want agents to respond to, and control loop costs, before chasing full autonomy.

[2] From Prompting Agents to Loop Engineering

The CVE Spike Behind AI-Powered Vulnerability Discovery

Estimated read time: 3 min

Proof cuts the other way too. Epoch AI charts a sharp rise in severe cybersecurity disclosures after Anthropic revealed Claude Mythos Preview could autonomously find flaws. High- and critical-severity CVEs from notable organizations spiked more than 3.5x in June 2026, following hardening work by Anthropic and OpenAI.

The signal: Frontier models now discover vulnerabilities at scale, so expect a faster patch cadence and treat dependency updates as a security priority, not a chore.

The AI Blog Prize: Three Contrarian Takes on the Post-Automation World

Estimated read time: 14 min

We close on where durable advantage actually lives. Dwarkesh Patel announces three winning essays from 600 submissions on big AI questions, ranging from ending airborne disease with far-UVC infrastructure to a grounded case for boring, timeless economic policy over galaxy-brained schemes.

The lens: In a world reshaped by AI, the most durable advantages may come from unglamorous fundamentals like stable institutions and capital formation rather than clever bets.

That’s the week. The throughline: the claim got cheap, so the proof is the product now, whether that proof is a contained runtime, a scored prompt, or a working exploit. See you next Monday.

Welcome to Altered Craft’s weekly AI review for developers, and thanks, as always, for reading. A pattern runs through this issue: the model is no longer the whole job. The work has moved to the system around it, the loop you engineer, the harness that runs it, the sandbox that contains it, and the provider and version-control layers that support it. The news side counts the cost of all that, from liquid-cooled data centers to the token bills arriving as the subsidies end.

TUTORIALS & CASE STUDIES

This week’s tutorials trace the agent from the inside out: the mechanism that lets it act, the loop you engineer around it, the harness that hands you that loop, the roles attackers exploit, the traces that keep it auditable, and a stack that runs on your own hardware.

Tool Calling: How AI Agents Decide What to Do Next

Estimated read time: 7 min

It starts with the mechanism. This tutorial explains tool calling, what turns an LLM into something that triggers real actions. The key distinction is that the model generates a tool call, not a tool execution. Examples cover single, multi-tool, and parallel calls.

Key point: Clear, accurate tool and parameter descriptions are what let the model pick the right function, so invest in them as much as the code behind them.

From Prompting Agents to Loop Engineering

Estimated read time: 12 min

Once an agent can act, the harder work moves up a level. This is a practical breakdown of the claim that you should stop prompting agents and design the loops that prompt them. The work moves from writing code to writing the system that writes the code, with examples and notes on where cost accumulates.

The takeaway: The loop, not the model, is now the expensive and failure-prone part, so build it with a tight scope, a hard budget, and an independent verifier before you walk away.

CUGA: The Agent Harness That Hands You the Plumbing

Estimated read time: 15 min

If the loop is the hard part, a harness can carry it. IBM’s open-source CUGA handles agent orchestration, planning, tool calls, state, and self-correction, so building one means writing just a tool list and a prompt. Two dozen single-file FastAPI apps show the pattern running governed in production.

What this enables: When the harness carries planning, state, and guardrails, an agent becomes a tool list plus a prompt, and a smaller open-weight model can hold its own.

Why Prompt Injection Is Really a Problem of Roles

Estimated read time: 11 min

But every harness inherits one weakness. An LLM receives a conversation as one token stream, structured only by role tags. Using “role probes,” this writeup shows models infer roles from writing style, not tags, so injected text that sounds like a command can override its tool tag.

Worth noting: Don’t treat role tags as a security boundary. LLMs identify roles from writing style, so adversarial text that sounds authoritative can override the tag it actually arrives under.

LLM Observability with LangSmith: Tracing Everything for Audit-Grade Logs

Estimated read time: 13 min

Once it runs in production, you need to see inside it. When a customer claims your bot promised something, can you replay what happened? This tutorial argues building the agent is the easy half; operating it is the hard half, covering zero-config LangSmith tracing and a tamper-evident audit log you control.

Why this matters: LLM failures arrive wearing a 200 OK, so wire in tracing and your own append-only audit log before regulators, not customers, force the question.

Building a Fully Local Coding Agent Stack

Estimated read time: 9 min

Pulling the threads together, and entirely offline, this tutorial from assembles a coding agent with no cloud dependency, pairing Ollama-served open-weight models like Qwen3.6 35B-A3B with harnesses such as Qwen-Code, Codex, and Claude Code. It covers serving local LLMs that read, edit, and run code, with speed and quality benchmarks.

The opportunity: If you have the hardware, a local model paired with the right harness gives you a private, fixed-cost coding agent that stays fully under your control.

TOOLS

The tools this week outfit the agent’s workspace: an isolated runtime for its code, version control built for how it commits, one interface to every model provider, an open model family that writes its own scaffolds, and a way to keep your Mac awake only while it works.

AWS Lambda MicroVMs: Isolated Sandboxes for User and AI-Generated Code

Estimated read time: 7 min

Building on our coverage of LangChain’s agent sandboxes[1] last week, AWS Lambda introduces MicroVMs for running untrusted user- or AI-generated code in isolated, stateful environments. Powered by Firecracker, each session gets VM-level isolation with near-instant resume, holding state across idle periods and supporting up to 8 hours of runtime.

The pattern: If you build assistants or sandboxes that run code you didn’t write, MicroVMs hand each session a snapshot-backed, isolated environment without your own virtualization stack.

[1] Every Agent Needs Its Own Computer

Oak: Version Control Built for AI Agents, Not Humans

Estimated read time: 3 min

Once the code runs safely, it has to be tracked. Oak is an open-source VCS reimagined around how coding agents work, using branch-per-session as the unit of work and branch descriptions over commit messages. Content-addressed lazy mounts get an agent editing any repo in seconds, faster than git.

What’s interesting: If agents are doing the committing, git’s human-centric assumptions are worth questioning, and Oak shows what a ground-up rethink looks like.

RubyLLM: One Framework for Every AI Provider

Estimated read time: 4 min

Whatever model does the work, you still have to reach it. RubyLLM unifies OpenAI, Claude, Gemini, Ollama, and more behind one consistent Ruby interface with three dependencies, handling chat, vision, transcription, embeddings, tools, and agents. Rails developers get ActiveRecord integration via acts_as_chat plus a generator for a ready-to-use chat UI.

The payoff: If you build in Ruby, you can swap between GPT, Claude, and local models without rewriting your code against each provider’s bespoke client.

Ornith-1.0: Open-Source Models That Write Their Own Scaffolds

Estimated read time: 7 min

And the models worth reaching are increasingly open. Ornith-1.0 is a self-improving family of open-source coding models spanning 9B to 397B parameters, built on the idea that the model learns to generate both solutions and the scaffolds that guide them. The flagship matches Claude Opus 4.7 on coding benchmarks.

Why now: Open-source agentic coding models are now competitive with frontier proprietary systems, and self-improving scaffold generation is a big reason the gap keeps closing.

Adrafinil: Keep Your Mac Awake Only While Agents Work

Estimated read time: 5 min

Finally, a small fix for long-running agents. Adrafinil is a macOS menu bar app that blocks sleep, including lid-closed clamshell sleep, only while an AI coding agent holds an active session. Unlike caffeinate or Amphetamine, it is agent-aware, not always-on, wiring into nine agent hooks and releasing when work ends.

NEWS & EDITORIALS

The editorials circle the limits closing in on AI’s growth: the heat its data centers have to shed, the ceiling on how much larger models can get, and the bill arriving as the subsidies end.

Hotter Than a Hot Tub: NVIDIA’s Bet on 100% Liquid-Cooled AI Factories

Estimated read time: 5 min

Start with the physical limit. NVIDIA’s Rubin generation is the first AI infrastructure to run 100% liquid cooling at 45°C coolant, no fans, no cold aisles. The counterintuitive insight is that hotter coolant enables chiller-less operation in favorable climates, cutting energy and water use toward zero.

The context: As compute scales, cooling efficiency becomes as strategic as the silicon, and running coolant hotter, not colder, is how the industry closes the energy gap.

How Far Can Model Size Scale Before 2031?

Estimated read time: 8 min

From heat to sheer size, this analysis projects how large AI models could grow through 2031, weighing compute budgets, hardware trends, and economic limits. It argues that growth slows as costs hit hardware and funding ceilings, and that parameter counts may plateau before the decade closes.

The signal: Don’t assume models keep getting bigger forever. Compute economics may cap parameter growth, shifting the edge toward efficiency and data quality.

The AI Subsidy Is Ending, and the Bills Are Coming Due

Estimated read time: 11 min

Extending our coverage of the shift toward cheaper models[2] last week, this piece puts the squeeze in hard numbers. A $200 monthly subscription can burn $8,000 in Anthropic tokens or $14,000 in OpenAI tokens, and as platforms move to token-based billing, servicing AI’s projected debt would require displacing roughly 27% of US jobs. OpenAI lost $38.5 billion in 2025.

Plan ahead: Budget now for metered token costs, because the era of subsidized AI coding tools is winding down and your bill could jump several-fold overnight.

[2] The Coming Shift From Bigger Models to Cheaper Ones

Welcome back to Altered Craft’s weekly AI review for developers. Thanks for reading, and for sticking with us into a quieter week after the frontier-model drama. One pattern runs through this issue: as models get cheaper, more open, and easier to swap, the hard part moves to everything around them. Bayer’s context discipline, two new agent harnesses, and three editorials on review and judgment all point the same way. The edge is in the scaffolding, not the core.

TUTORIALS & CASE STUDIES

This week’s case studies share a thread: the scaffolding and ownership around a model matter more than its raw size. We open with a disciplined enterprise build, then move to running the stack yourself.

How Bayer Built a Reliable Agentic RAG System for Drug Discovery

Estimated read time: 12 min

Bayer’s PRINCE platform grew from keyword search into a multi-agent research assistant for preclinical data. Its reliability comes from context discipline over larger context windows, giving each agent only what it needs, backed by LangGraph orchestration, model fallbacks, and Langfuse observability.

Why this matters: Bigger context windows don’t replace deliberate context engineering. Scope what each agent actually sees, and the whole system becomes easier to steer, debug, and evaluate over time.

Building a Phone-Friendly AI Dev Platform for Your Homelab

Estimated read time: 5 min

From a corporate platform to a personal one, this setup wires OpenCode’s web UI into a homelab so an AI agent can maintain Docker Compose stacks while staying behind PR review with a small blast radius. It runs isolated, pushes feature branches, and humans merge before deploy.

The opportunity: Give your AI agent its own user, an isolated VM, and PR-only access, so it can manage real infrastructure safely, without ever touching production directly.

Local Models Are Actually Good Now

Estimated read time: 5 min

Once you’re running your own infrastructure, the next question is which models fit on it. Continuing our coverage of the shift toward cheaper, smaller models[1] last week, this hands-on account runs agentic coding on a 64GB M2 Mac, where the Gemma 4 family hits roughly 75% of frontier accuracy and speed, with a Pi-plus-LM-Studio setup and Docker sandboxing.

What’s interesting: Local models have crossed a threshold. Agentic coding tasks that were impossible six months ago now work well enough that you can often skip double-checking against an API.

[1] The Coming Shift From Bigger Models to Cheaper Ones

Local AI Is Not Opus: A Founder’s Receipts

Estimated read time: 12 min

That optimism comes with a caveat. A bootstrapped founder shares hard data from running Qwen 27B on a $12,000 GPU. The card pays for itself on support work, but local models are a different tool, not a cheaper Claude, looping once quantized for consumer hardware.

Worth noting: Local models earn their keep on privacy, fixed costs, and vendor risk for scoped, supervised tasks. They still can’t replace frontier models for unattended agentic work.

TOOLS

The tools this week assemble the agent stack from the outside in: a model to drive it, two harnesses to run it, a format to feed it context, and an auth layer to govern it.

GLM-5.2 Brings a Usable 1M-Token Context to Open-Source Coding

Estimated read time: 9 min

Z.ai’s MIT-licensed GLM-5.2 targets long-horizon coding with a 1M-token context that stays reliable under real engineering pressure. It tops open-source models on three benchmarks, adds effort-level controls, and introduces anti-hacking RL to keep training honest.

What this enables: If you run long, messy coding-agent trajectories, GLM-5.2 gives you a frontier-adjacent, openly licensed option where the 1M context actually holds up across hours-long tasks.

eve: Vercel’s Framework for Production-Ready Agents

Estimated read time: 7 min

To put a model like that to work, you need a harness. Vercel’s open-source eve makes an agent a directory of files defining tools, skills, and subagents. It ships durable sessions, sandboxed compute, approvals, multi-channel delivery, tracing, and evals, so you focus on behavior, not plumbing.

Key point: Define your agent as a versioned folder of files, then let the framework handle the durability, sandboxing, approvals, and deployment you would otherwise build by hand.

Flue: A Programmable Harness for Autonomous Agents

Estimated read time: 4 min

The Astro team takes that idea from a different angle. Flue is a TypeScript harness that gives any model the sessions, tools, skills, sandbox, and durable execution for autonomous work. It’s not another SDK but a programmable environment.

The takeaway: If you’re building agents that take real action, Flue handles the sandbox, durability, and observability plumbing, so you can focus on the task instead of the scaffolding.

Google’s Open Knowledge Format: A Standard for Feeding Context to AI Agents

Estimated read time: 8 min

A harness still needs something to feed it. Google Cloud’s Open Knowledge Format is a vendor-neutral spec that formalizes the LLM-wiki pattern into portable markdown bundles with YAML frontmatter. It treats knowledge as a format, not a service, so agents and humans read identical files.

Why now: If your agents keep reassembling the same scattered context from scratch, a portable markdown-and-YAML standard like OKF could make that knowledge readable by every tool you use.

MCP Gets Enterprise-Grade Auth: Authorize Once, Inherit Everywhere

Estimated read time: 4 min

Finally, governing all of this at scale. MCP’s Enterprise-Managed Authorization extension is now stable, letting organizations control server access through their identity provider instead of per-app consent prompts. The IdP becomes the authoritative decision-maker, so users log in once and inherit servers scoped to their roles.

The context: Deploying MCP in an enterprise? EMA lets you centralize access policy and audit in your identity provider, instead of leaving authorization to whatever each employee happened to approve.

NEWS & EDITORIALS

The editorials orbit one question: if agents now write the code, what part of the job stays yours? We open with the week’s biggest deal, then follow the answer through deciding, reviewing, and the discipline that cheap code demands.

SpaceX Buys Cursor for $60B in Stock After Record IPO

Estimated read time: 5 min

We open with the week’s biggest deal. SpaceX agrees to acquire AI coding startup Cursor in a $60 billion all-stock deal days after its record IPO, betting the tool helps its troubled xAI division catch the major labs. The move shows how AI coding became a strategic prize.

What to watch: The tools developers use daily are now acquisition targets in trillion-dollar bets. Watch how ownership shifts affect the roadmaps, pricing, and data practices of tools your team depends on.

Who Decides What: What 400K Claude Code Sessions Reveal About Agentic Work

Estimated read time: 8 min

That raises the question of who is actually steering. Building on our coverage of the decide-execute-deliver argument[2] last week, Anthropic’s analysis of roughly 400,000 Claude Code sessions finds a consistent split: people decide what to build, the agent decides how. Over seven months, debugging nearly halved while task value rose about 25%.

The lesson: Bring deep understanding of your problem to the agent. Domain expertise, not raw coding skill, is what makes the model do more and succeed more often.

[2] The “Decide-Execute-Deliver” Sandwich: Why AI Hasn’t Replaced Engineers

Review Is Now the Most Leveraged Skill in Software

Estimated read time: 14 min

If people own the “what,” verification is where that ownership shows up. Addy Osmani argues that as coding agents accelerate, the bottleneck moved from writing code to verifying it. Citing 2026 data showing 4x output for roughly 12% real value, he shows how review scales with blast radius.

The practice: Scale your human review to the blast radius of the change, and pair two deliberately different AI reviewers rather than chasing a single best tool.

When Code Becomes Disposable, Discipline Becomes the Product

Estimated read time: 15 min

Which points to a deeper shift. The piece argues cheap, regenerable AI code turns code into a materialized view of understanding, disposable when stale. Drawing on Phoenix Architecture ideas, it contends disposability raises the bar for rigor, pushing teams toward observability, characterization tests, and evals in production.

The shift: Stop treating code as the durable asset. Invest in evals, observability, and short feedback loops so the understanding lives where it can be regenerated on demand.

That’s the week. As the model becomes the easy part, your edge is everything you build around it: the context you curate, the harness you run it in, and the review that catches what it gets wrong. See you next Monday.

This is in the form of a web app composed of a dashboard and a visualized stream of the activity logs for a session.
Here we see the dashboard section for a finished session:

Four tasks, start to finish, in about six and a half minutes and 285k tokens. The reason I keep coming back to this view is that it answers a question the exit code can’t. A run that finishes and a run that finishes well look identical if all you have is all_done. The difference is in the shape.

A few patterns I read off it now without thinking:

• Iteration counts spread evenly and well under the cap: a healthy run. One task pinned near the ceiling is one that got stuck.

• Mostly accepts, few rejects: the worker and the evaluator agree. A wall of rejects means they are talking past each other.

• Context pressure that climbs through a task and resets at each boundary: the out-of-context memory doing its job. A line that never resets is context quietly bloating.

Here is a fresh one kicking off: a path, a model, and the loop starts turning.

The model and harness activity stream live in the web view, filling in event by event.

And I can drop into any single iteration and read it like a transcript: the evaluator’s verdict with its reasoning, the ledger entry, the commit.

None of this is novel as “observability.” There is a lot of good writing on agent tracing right now. What I’d flag is smaller and more practical. I built all of this for myself, to debug my own runs, and the live view came almost for free, because every panel is a render of the same append-only event log. Build the log for the autopsy and the live dashboard falls out of it.

Why I care about this particular instrument: I am trying to work out how far cheaper open-weights models can be trusted with autonomous work. You can’t answer that from a pass or fail. You have to watch how the model gets there, and notice when it thrashes. This is the thing that makes that legible.

That is the progress. It is the instrument, not the study. The study is the next step: I want to batch-evaluate a finished session and score it on effectiveness and efficiency, so the shape I am reading by eye becomes something gradable.

The rest of the details are in the Tilth docs.

Welcome back to Altered Craft’s weekly AI review for developers, and thank you for being here for a heavy news week. The defining story is sobering: a US government directive forced Anthropic to pull Fable 5 and Mythos 5 offline for every customer, the first time a nation has recalled a deployed frontier model. A model you build on can now vanish overnight. So the rest of this issue leans into the hedge: build from first principles, route to smaller models, own more of your stack.

TUTORIALS & CASE STUDIES

We start at the foundations and climb: one neuron by hand, a full from-scratch curriculum, a tiny model trained for $80, then serving it efficiently and prompting the latest frontier release.

The Perceptron, Built From Scratch in Your Browser

Estimated read time: 8 min

Ranpara builds a single perceptron in plain Python and runs it live so you watch it learn. A student-pass example shows why the bias moves the boundary to where the answer lives, plus how normalization keeps training smooth.

The takeaway: Understand the weight, bias, and update loop of a single neuron and you understand the building block every neural network is made from.

503 Lessons That Build AI From Raw Math Up

Estimated read time: 9 min

From a single neuron to the full stack, this free, open-source curriculum spans 20 phases and 503 lessons across four languages. Its core principle: build every algorithm from raw math before touching a framework. Every lesson ships a reusable artifact, a prompt, skill, agent, or MCP server.

Why this matters: If you can call AI APIs but can’t explain what happens underneath, this curriculum closes that gap by making you build each piece by hand.

Building a Victorian LLM From (Almost) Scratch for $80

Estimated read time: 31 min

Putting that build-it-yourself ethos to the test, Cristi Constantin trains a 340M-parameter, Llama-based model knowledge-locked to the year 1900. The standout lesson: data quality, not compute, dominates the work, through custom de-duplication, compression ratios, entropy, and OCR scoring. Total GPU cost: roughly $80.

Key point: To truly understand how LLMs work, build a small one yourself, and expect most of your time to go into cleaning and filtering the data.

Serving LLMs Efficiently: A Hands-On vLLM Workflow

Watch time: 1h38m

Once a model exists, the next problem is serving it. This DeepLearning.AI course, built with Red Hat, shows that efficient LLM serving is mostly a memory problem, where weights and the KV cache compete for GPU space. You quantize a Qwen model, serve it with vLLM, and benchmark under load.

What this enables: Treat LLM deployment as a memory-management problem, then use quantization with vLLM’s PagedAttention and continuous batching to balance speed, cost, and accuracy.

Prompting Patterns for Claude Fable 5: What Changes When the Model Runs for Hours

Estimated read time: 7 min

At the frontier end of the spectrum, and newly poignant this week, Anthropic’s guide details the prompting shifts for Claude Fable 5 and Mythos 5, the very models just pulled offline. Because instruction-following is now strong enough to steer briefly, older prescriptive prompts can degrade output and need pruning before migration.

Try this: Re-audit your prompts and skills before migrating, since instructions tuned for older models can actively hurt Fable 5’s output. Call it homework for whenever it comes back. If it comes back.

TOOLS

This week’s tools equip the agent itself: the new frontier model to drive it, a brain and a sandbox to work in, an interface built for it, and a guardrail to keep it safe.

Serena: Giving Your Coding Agent an IDE’s Brain

Estimated read time: 8 min

To make any model useful in a large codebase, Serena is an open-source MCP server that gives coding agents semantic, symbol-level understanding of code instead of brittle text search. Backed by language servers across 40+ languages, it turns cross-file renames, lookups, and refactors into single atomic calls.

The opportunity: If your agent fumbles refactors with search-and-replace in a large codebase, an MCP server like Serena can collapse eight to twelve error-prone steps into one reliable operation.

Every Agent Needs Its Own Computer

Estimated read time: 6 min

If a brain handles the code, the next need is a safe place to run it. LangChain introduces LangSmith Sandboxes, hardware-virtualized microVMs that give each agent a disposable computer with filesystem, shell, and persistent state. The piece argues containers aren’t an isolation boundary for untrusted model-generated code.

The principle: If your agent runs dynamic or model-generated code, give it a hardware-isolated sandbox rather than a shared-kernel container you are quietly trusting.

Designing the hf CLI for Humans and Agents Alike

Estimated read time: 9 min

Tools also have to speak the agent’s language. Hugging Face rebuilt its hf CLI to serve both humans and coding agents, auto-detecting which is driving and rendering output accordingly. Benchmarks show a no-CLI baseline burns up to 6x the tokens on complex multi-step tasks.

Worth noting: Designing tool output for agents, compact, parseable, and full of next-command hints, can cut token usage dramatically without hurting the human experience.

Nemotron 3.5 Brings Custom Policy Reasoning to Multimodal Safety

Estimated read time: 9 min

Finally, a guardrail for everything above. NVIDIA’s 4B-parameter safety model unifies multimodal input, 12-language coverage, and custom enterprise policy enforcement in one inference call. The standout is auditable reasoning traces via THINK mode, letting teams enforce natural-language policies with a documented justification per verdict.

What this enables: If you build guardrails for regulated or multi-domain AI products, one model that accepts custom policies and emits auditable traces could replace a stack of brittle classifiers.

NEWS & EDITORIALS

The editorials open on the week’s biggest shock, a frontier pulled offline by government order, then widen out: the architecture you actually control, clearer thinking about “world models,” the economics pushing toward cheaper ones, and the part of the job that stays yours.

The Government Just Pulled Two Anthropic Models Off the Market

Estimated read time: 4 min

In an action without precedent, a June 12 US export-control directive ordered Anthropic to suspend Fable 5 and Mythos 5 for any foreign national, and the company disabled both models for everyone worldwide. Anthropic disputes the cited jailbreak, reading a codebase to fix its flaws, as narrow and reproducible in rival models, and says it is working to restore access.

Worth watching: Frontier access is something regulation can revoke overnight. Keep a fallback model and own more of your stack.

The AI Agents Stack: 2026 Edition

Estimated read time: 9 min

If a model can vanish overnight, the architecture you control matters more. Paolo Perrone redraws Letta’s influential agent stack diagram for 2026, mapping six layers from models to guardrails. The recurring argument: add complexity only when something specific breaks, with honest takes on lock-in and the demo-to-production gap at each layer.

The pattern: Start with the simplest stack that works and add layers only when something specific breaks, not in anticipation of problems you don’t yet have.

A Functional Taxonomy of World Models

Estimated read time: 9 min

Another effort to bring order to a loaded term, and World Labs sort “world model” systems into three functions: renderers output pixels, simulators output state, planners output actions. They argue simulation is the structural backbone from which fidelity and reliable action derive.

The lens: When evaluating a “world model,” ask which contract it fulfills, visual plausibility, structural accuracy, or correct action, because beautiful pixels rarely guarantee usable physics.

The Coming Shift From Bigger Models to Cheaper Ones

Estimated read time: 5 min

Building on our coverage of open versus closed model economics[1] last week, the question sharpens as subsidies slow and token prices climb: are companies ready to switch to smaller models? Early tests, like Harvey cutting inference costs 3x with no quality loss, suggest the real divide is large versus small.

Why now: Stop defaulting to the frontier model for everything and start routing each task to the smallest model that returns the right answer.

[1] Open and Closed Models Are on Different Exponentials

The “Decide-Execute-Deliver” Sandwich: Why AI Hasn’t Replaced Engineers

Estimated read time: 9 min

We close on what stays yours. Following our look at how the senior role is moving from writing code to directing it[2] last week, this essay examines headline layoffs at Block, Snap, and Intuit and finds AI is mostly a scapegoat for financial restructuring. Software work is a decide-execute-deliver sandwich: AI compresses the middle, but deciding what to build and owning delivery resist automation.

The shift: Code generation was never the bottleneck. Your value increasingly lives in framing problems and owning what ships, not in typing the implementation.

[2] When AI Starts Building AI: Inside Anthropic’s Self-Improvement Curve

Welcome back to Altered Craft’s weekly AI review for developers, and thank you for starting your week with us. Last week we followed the money; this week we follow the loop. Agents are reaching deeper into their own cycle of writing and checking, from self-validating guardrails to workflows that fan across hundreds of subagents, with Claude now authoring most of its own merged code. As that inner loop closes, the work that stays yours moves outward: setting the guardrails, directing the fleet, and choosing which problems matter.

TUTORIALS & CASE STUDIES

We open with the principle that pushes you out of the inner loop, then turn to two production realities: keeping RAG costs in check and running frontier models inside your own cloud perimeter.

Backpressure Is All You Need: Stop Being Your Agent’s Bottleneck

Estimated read time: 11 min

Building on our coverage of Anthropic’s point that verification is now the bottleneck[1], Lucas da Costa argues humans have become the default backpressure in AI coding loops, shuttling feedback between agents and bots. His fix: build automated guardrails (tests, types, benchmarks, review agents) that force the LLM to validate its own work first.

The takeaway: If you are manually correcting your coding agent every cycle, you are not delegating, you are an expensive clipboard between two machines.

[1] Using LLMs to Secure Source Code: A Six-Step Loop

RAG Is Burning Money: Building a Cost Control Layer

Estimated read time: 14 min

Once the agent is checking its own work, the next thing to watch is the bill. A working RAG pipeline can drain budgets through over-fetched context, uncached repeats, and oversized models on trivial queries. This walkthrough builds a four-layer cost control system with semantic caching, routing, and token budgeting, achieving up to 85.8% cost reduction.

Worth noting: Treat RAG cost as a separate failure domain from quality, and instrument routing and caching before scaling traffic.

Running OpenAI Models on Amazon Bedrock: A Production Cookbook

Estimated read time: 12 min

Staying with production concerns, OpenAI’s cookbook walks through running GPT-5 models on Amazon Bedrock via an OpenAI-compatible Responses API, using a fictional retailer support workflow to cover structured outputs, function tools, PDF inputs, prompt caching, background mode, stateful conversations, and operational smoke checks.

What this enables: If you need OpenAI models inside your AWS perimeter, Bedrock now exposes the full Responses API surface with minimal code changes from a standard OpenAI SDK setup.

TOOLS

The model releases cluster by job this week: open-weight coding and multimodal models, an orchestrator built for long-running agents, the workflow layer that fans work across hundreds of subagents, and a scanner to keep the skills they use safe.

MiniMax M3: An Open-Weight Model Targeting Frontier Coding and Agentic Work

Estimated read time: 11 min

MiniMax releases M3, an open-weight model with 1M context and frontier coding scores powered by a new sparse attention architecture called MSA. Tests include a 24-hour autonomous CUDA kernel run that lifted Hopper FP8 utilization from 7.6% to 71.3%.

The signal: Long-horizon agentic coding is increasingly bottlenecked by attention architecture, not model size, and open-weight options are starting to close the gap with closed frontier models.

Microsoft’s MAI-Code-1-Flash: Trained Inside the Copilot Harness

Estimated read time: 3 min

Another approach to coding models, Microsoft’s MAI-Code-1-Flash was trained directly inside GitHub Copilot’s production harness rather than tuned for benchmarks. Adaptive solution length control reportedly cuts token use by up to 60% on harder problems while outperforming Claude Haiku 4.5 across four SWE-Bench evaluations.

Why this matters: Coding models trained inside the actual production harness tend to translate offline gains into real developer workflows more reliably than benchmark-optimized alternatives.

Gemma 4 12B Ships with Encoder-Free Multimodal Architecture

Estimated read time: 7 min

Shifting from coding to multimodal, Google releases Gemma 4 12B, a dense model with an encoder-free architecture that feeds vision and audio straight into the LLM backbone. It runs on 16GB VRAM, supports native audio, and ships with macOS apps and a local OpenAI-compatible server.

The opportunity: Developers can now run a single multimodal model locally that handles text, vision, and audio without juggling separate encoders or fine-tuning pipelines.

NVIDIA Nemotron 3 Ultra: Built for Long-Running Agents

Estimated read time: 9 min

Moving from models to orchestration, NVIDIA releases Nemotron 3 Ultra, a 550B-parameter MoE model designed for frontier reasoning and orchestration in agentic systems. It claims 5x higher throughput than peers and up to 30% lower cost per agent task, shipping fully open under OpenMDW-1.1.

The pattern: If you’re building multi-turn agents, pairing a frontier orchestrator with efficient execution models is becoming the dominant pattern, and Nemotron 3 Ultra is now a credible open option for the orchestrator role.

Claude Code Gets Dynamic Workflows: Hundreds of Parallel Subagents in One Session

Estimated read time: 5 min

Taking orchestration further, Anthropic’s 4.8 release brings dynamic workflows to Claude Code, where Claude writes orchestration scripts fanning work across hundreds of parallel subagents with adversarial verification. The lead example: Jarred Sumner’s port of Bun from Zig to Rust, 750,000 lines, eleven days.

Key point: When a task is too big for a single agent pass, dynamic workflows let Claude plan, parallelize, and self-verify across hundreds of subagents, but expect significantly higher token usage.

SkillSpector: NVIDIA’s Security Scanner for AI Agent Skills

Estimated read time: 9 min

To keep all this safe, NVIDIA’s open-source SkillSpector vets AI agent skills for Claude Code, Codex CLI, and Gemini CLI, combining static analysis with optional LLM evaluation across 64 vulnerability patterns in 16 categories. It produces a 0-100 risk score and SARIF output for CI/CD.

The principle: Treat third-party agent skills like any other untrusted dependency, and scan them before installation rather than granting implicit trust.

NEWS & EDITORIALS

The editorials trace where the human role is heading: from typing to describing, from writing code to directing it, then the market structure underneath, and a closing reminder to protect the thinking the agents can’t do for you.

The Speed of Prototyping in the Age of AI

Estimated read time: 7 min

Daryl Cecile reflects on a rough 4x speedup from AI agents, but argues the more important change is the shift toward describing systems before building them, which sharpens delegation and expands what work he can realistically take on.

What’s interesting: When agents handle the typing, the engineering skill that matters most is clearly describing what success looks like, so deliberately protect time for hands-on work to keep your instincts sharp.

Running an AI-Native Engineering Org: Lessons from the Claude Code Team

Estimated read time: 9 min

In more news on how the work itself is changing, Anthropic’s Claude Code team lead shares how agentic coding reshaped their workflows, from six-month roadmaps to just-in-time planning. The piece covers shifts in code review, context gathering, and team makeup as bottlenecks move from writing code to verifying it.

Try this: Pick your noisiest engineering workflow and ask whether it still serves its purpose, or whether it can be automated or dropped entirely.

When AI Starts Building AI: Inside Anthropic’s Self-Improvement Curve

Estimated read time: 14 min

Following our look at why Claude is not your architect[2] from last week, Anthropic shares internal data: Claude authors 80%+ of merged code, and engineers ship 8x more per quarter than in 2024. The piece traces the path toward recursive self-improvement, while noting Claude still struggles to choose which problems matter.

The shift: The role of a senior engineer is moving from writing code to directing, reviewing, and choosing which problems are worth solving at all.

[2] Claude Is Not Your Architect

Open and Closed Models Are on Different Exponentials

Estimated read time: 8 min

Building on our coverage of Max Trivedi’s case that open models cap frontier pricing[3] from last week, Nathan Lambert argues open and closed AI models run on different economic exponentials. Closed labs capture premium margins through integrated coding agents, while open models diffuse across enterprises at commodity pricing. Both ecosystems grow, but their timelines look nothing alike.

What this means: If your work depends on coding agents, expect to keep paying premium prices for frontier closed models while open models quietly win the long tail of enterprise deployments.

[3] When Outsourcing + Local AI Undercuts Frontier Labs

Anthropic Files Confidential S-1 for Proposed IPO

Estimated read time: 1 min

On the business side, Anthropic has confidentially submitted a draft S-1 to the SEC, opening the option to go public pending review. The filing follows a $65B Series H at a $965B post-money valuation, signaling a potential shift toward public markets.

Worth watching: If Anthropic goes public, the tools developers depend on start answering to quarterly earnings cycles, so watch how that shapes Claude’s roadmap and pricing.

The AI Treadmill: When Staying Current Becomes Its Own Trap

Estimated read time: 8 min

Closing on the human cost, Deb Liu reflects on the quiet panic beneath San Francisco’s AI enthusiasm, where even experts feel perpetually behind. She argues efficiency gains often just refill themselves with more motion, and protecting space to think matters more than chasing every tool.

Key point: Going deep on one tool that changes how you work beats sampling ten you’ll abandon, and the pauses you protect are where your best thinking happens.

That’s the week. The throughline: as agents close the inner loop of building and verifying, your leverage moves to the outer one, the guardrails you set, the fleets you direct, and the problems you choose to point them at. See you next Monday.

The failure was new. The shape of it was not.

In 1994, a researcher at Sun named Peter Deutsch wrote down eight assumptions that distributed-systems engineers were silently making. The network is reliable. Latency is zero. Bandwidth is infinite. The network is secure. Topology doesn’t change. There is one administrator. Transport cost is zero. The network is homogeneous. The list was short. The list was specific. And the list was uncomfortable, because many engineers reading it had violated several of them at any given time.

Three decades later, those eight sentences are still load-bearing in every distributed-systems postmortem worth reading. APNIC ran a 21-years-later retrospective in December 2025 confirming what every on-call engineer already knew. The fallacies did not get solved. They got priced.

We are doing it again, at a higher abstraction layer.

The trade distributed systems made, twenty years ago

Distributed systems made a trade twenty years ago. More defects, faster recovery, net win. Once the network became the substrate, you stopped trying to prevent every failure and started engineering for mean time to recovery instead of mean time between failures. AI-assisted programming is making the same trade, a layer up, by handing authorship to something non-deterministic. Humans were never deterministic either, but the new author is jagged to a higher degree: it fills gaps without flagging them, lacks the common sense to seek out what it hasn’t been shown, and (where it controls the workflow) substitutes reasoning for the static orchestration you used to write yourself. The fallacies that fall out of that (non-determinism at the output, verification at the review, drift at the model, blast radius at the agent) are the same shape as Deutsch’s network fallacies, and they yield to the same playbook. Name them. Price them. Engineer the recovery. That is the move that earned the SRE discipline twenty years of leverage. It is the move that earns AI-assisted programming the same kind of leverage, on a faster clock.

These eight are not a one-to-one re-map of Deutsch’s list. They are the same shape: assumptions that were safe in the old model and quietly false in the new one. I have sequenced them in the order most engineering teams hit them in practice, not in Deutsch’s canonical order. The thread that ties them together is the Metaphorex framing that holds the whole Deutsch literature up: “each fallacy names a specific locality assumption that engineers unconsciously import from single-machine programming.” That is the move worth borrowing. The assumptions we are importing all come from a world where the author was a single, minimally jagged, accountable human whose knowledge had edges it knew about. The new author breaks every part of that.

The model output can be made deterministic

Setting temperature=0 does not make a large language model deterministic. It is among the most common misconceptions in production LLM engineering. Tianpan documents it at scale on a Qwen3-235B setup: same prompt, same model, temperature=0, one thousand runs, 80 distinct completions. The mechanisms sit below the application layer, in how the inference hardware schedules and batches the math. No model change, no prompt change, just parallel hardware doing what it does at scale.

The labs are working on it. Microsoft Research’s LLM-42 is a serious attempt at scheduling-based determinism, so this is not unsolvable in principle. It is unsolved in practice. In every production system running today, “same input, same output” is silently violated, and the plans built on top of that assumption are spending a budget no one costed.

The cost of code has gone to zero

When agents were building brochure sites, the cost felt that way. Now that real work is in scope, two things shifted. Agents burn more tokens just on the happy path through production complexity. They also chase far more dead ends before they get there.

The free-lunch framing collapsed in early 2026. GitHub Copilot moved to AI Credit billing. OpenAI shifted Codex to token pricing. Cursor and Windsurf raised their Pro tiers. The vendor framing of “unlimited AI coding” got quietly retired, and LeadDev called it.

The numbers that land are the runaway ones. A single Cursor user burned $4,200 in API fees over a weekend during an autonomous refactor. Two LangChain agents in an infinite conversation for eleven days landed a $47,000 bill. These read as edge cases until you notice they sit on the tail of a distribution every team is now exposed to.

The cost-runaway mechanism is structural. Agents re-send accumulated context on every step. A five-step loop costs 3.2× a single chatbot call. A fifty-step loop, 30×. A two-hundred-step debugging session, 100×. Average agentic developer spend in 2026 is now $400–$1,500 per month. Bryan Catanzaro, Nvidia’s VP of applied deep learning, said the quiet part out loud: “for my team, the cost of compute is far beyond the costs of the employees.” Anthropic, for its part, blocked Claude Pro/Max subscribers from running third-party agent frameworks because flat-rate pricing did not survive contact with autonomous loops.

Per-token cost has fallen 280× in two years, which is the number vendors quote. The number they do not quote is that the recent move at the frontier is up: SignalBloom’s pricing analysis tracks GPT-5.5 roughly tripling over GPT-5, and Opus 4.7 consuming 32–47% more tokens per task than its predecessor. Enterprise AI spend rose 320% over the same two years, because usage exploded faster than the headline price fell, and inference is now 85% of enterprise AI budget, up from ~40% in 2023. The economics did not get better. They got more elastic, and the elasticity went the wrong way. The token bill is one face of it. The reviewer’s calendar is the other, which is the next fallacy.

Verification keeps pace

This is the fallacy that turned vendor productivity claims into a math problem. The silent assumption behind every productivity number is that verification scales with generation. It does not. AI generates code in seconds. Engineers still review it at the same pace they always have. Faros telemetry across thousands of teams shows the asymmetry, and the shape of it is simple: the PRs got bigger and buggier while the clock to review them stretched. Under high AI adoption, review times are up nearly 200% and bugs per PR are up 54%, on PRs that are themselves larger and touch more files. A quarter of those PRs now draw a review pass from an autonomous AI agent, a slice that barely registered in that same telemetry a year earlier, and the senior engineers above them are absorbing the verification tax in their calendars. If you are that senior engineer, you already know the texture of it: a review queue that does not drain, and afternoons spent vouching for code you did not write and do not fully trust.

AI-generated code is harder to review than bad human code because it fails in ways that look like competence. Jake Redmond’s framing is the cleanest version of this I have read in 2026:

AI agents do not pause when requirements are vague. They do not challenge undefined behavior. They fill the gap and compile the guess.

That gap-filling is the work that used to happen out loud, between humans, before code got written. Half the quiet value of a standup was someone asking “wait, what happens when that field is empty” before there was any code to be wrong about. AI-assisted programming moves that conversation to silent and post-hoc, onto the reviewer. The author got faster. The check on the author did not.

SonarSource’s 2026 survey puts a number on the gap. 72% of developers use AI daily. 96% don’t fully trust the output. Only 48% consistently verify. That 48-point spread between “don’t trust” and “verify” is the structural debt AI-assisted programming is accumulating in 2026. METR’s 19% real slowdown against 20% perceived speedup is what that gap looks like from the inside, and it is the cleanest available “perception gap” data.

The temptation is to skip verification by asking the model to handle it. Tell it to make the code secure. Tell it to follow OWASP. Tell it to check the edge cases. That is the move the next fallacy is about. It does not work.

Telling the model to ‘make it secure’ works

The silent move is to add “and make it secure” or “follow OWASP” to the prompt and feel covered. The empirical result is that the generic instruction does not work.

Veracode’s 2025 GenAI Code Security Report ran more than 100 LLMs across 80 coding tasks. 45% of AI-generated code samples failed security tests against OWASP Top 10. XSS tasks were insecure in 86% of cases. Java came in worst at 72% failure. The result that catches teams off guard is that the rate is flat across model generations. Newer and bigger models do not produce meaningfully more secure code.

Explicit security prompting closes very little of that gap. An empirical evaluation across five LLMs and four languages found that security-focused prompting strategies, including weaknesses-aware chain-of-thought, did not statistically reduce vulnerability frequency or density. The prompts shifted which CWEs showed up. They did not reduce the total.

The reason is not that the model is blind to your context. It is that a generic instruction carries none. “Make it secure” tells the model to pattern-match on what “secure” tends to look like in its training data, and it will. Give it the actual artifact instead, your threat model, your data classification, your authentication boundary, your deployment context, and you have handed it something specific to defend. The failure mode is the stylistic cue standing in for the artifact. “Secure” as a bare adjective collapses a contextual judgment into a vibe, and produces code that looks defended without defending the right things.

The labs have noticed the same gap, and they are loud about it. Anthropic’s Project Glasswing put a security-tuned model, Mythos, in front of partner orgs to scan codebases, claiming thousands of zero-days surfaced. OpenAI’s Daybreak goes at the artifact directly: it ingests a repository, builds a codebase-specific threat model, and maps attack paths against it. The direction is real. The claims are running ahead of the results. When Mythos was run against curl, five “confirmed vulnerabilities” triaged down to one low-severity bug, the rest already-documented behavior or a plain bug, and maintainer Daniel Stenberg called the model “an amazingly successful marketing stunt.” Note too what these tools do: they find flaws and model threats. None of it is evidence that generation got more secure. That 45% has not moved while all of this shipped.

The perception gap is the part that is hardest to swallow. The Stanford study by Perry et al. ran the cleanest experiment on this question. Participants with access to an AI coding assistant wrote significantly less secure code than those without, and were more likely to believe their code was secure. The two findings compound. Confidence rose while ground truth fell.

So the threat model can be written down, and the tooling is starting to help you write it. What does not transfer is the judgment underneath it. Deciding what could actually go wrong in this application, against this specific surface, is still the engineer’s call. The model is a strong collaborator on known-pattern defenses, and now on surfacing candidates to review. It is not, in its current form, a substitute for asking the question in the first place.

The context window is endless

The long-context arms race did not win. Liu et al.’s “Lost in the Middle” finding from ICML 2024 (25–40% recall drop on facts buried mid-prompt) narrowed in frontier 2026 models but did not close. Chroma’s 2025 study of 18 frontier models shows 30%+ accuracy drops for information in the middle of long conversations. Quality starts degrading at 60–70% of the rated window, not at 100%. The rated number is not the effective number.

The tooling has already internalized this. Claude Code’s own context management advises compression in the 100–200k token range, well shy of the 1M rated window. The vendor knows the cliff is there.

The concrete result that engineers should sit with: one team cut their window from 2M to 64k tokens, added a repo graph, and bug-fix accuracy went from 71% to 84%, with 5× lower cost. Bigger context stopped helping. Memory architecture is the new compiler.

The fallacy of equating “the window” with “the context” is the one practitioners have figured out fastest. The 2026 frontier is no longer the token count. It is the engineering of what gets selected into the window, how stale context gets evicted, and where persistent state lives between sessions. That work already has a name. It got one in mid-2025, when Andrej Karpathy and others started calling it context engineering, “the delicate art and science of filling the context window with just the right information for the next step.” This is the one fallacy that has already been named and turned into a visible discipline. The other seven are not there yet.

All models are interchangeable

Swap one frontier model for another and the behavior changes underneath you, even when the leaderboard scores sit within a few points. The differences are tendencies, not rankings. GPT-5.5 emits ~72% fewer output tokens than Opus 4.7 on identical agentic loops in Mindstudio testing, a 72% efficiency gap on the same workload that compounds across every iteration of a loop. Tool error rates differ by model, and even across versions of one family. Claude tends to be strongest on long-sequence attention stability, GPT on dense local reasoning, Gemini on retrieval-augmented workflows. None of that makes them specialists. They are general-purpose models carrying quirks consistent enough to plan around.

The economics are the other half, and they break the reflex to always reach for the most capable model. On a blended agentic workload, heavy on input and light on output, SignalBloom’s cost analysis puts DeepSeek around $0.094 per million tokens against roughly $2.80 for OpenAI and Anthropic. That is close to a 30× spread for work that does not always need a frontier model to be done well. “Always use the best model” is a fine default until it meets a budget, and at scale it always meets a budget.

Model choice is now a routing decision, not a vendor decision. As Danilchenko frames it:

Pre-April, “use the best model” meant Claude. Post-April, it means “decide whether you’re paying for raw quality, agentic efficiency, or context-window scale,” which gives three different answers.

Teams that treat models as drop-in replacements for each other are the ones who get surprised when a sub-agent that worked beautifully on Opus produces tool-call cascades on Gemini.

The mitigation lever that has emerged is evals. Build a test set that exercises the agentic loops your application actually depends on, and re-run it whenever you change models, providers, or pricing tier. Evals let you see the delta the leaderboard hides. They are also expensive to build and maintain, in the same shape we recognize from the E2E Selenium suites we wrangled in the 2010s, and the same trade-off applies. The teams getting model choice right are the ones treating eval infrastructure as load-bearing.

The model is stable

In April 2026, Anthropic removed the ability to pin specific Claude model versions. Developers on claude-sonnet-4-5 were silently upgraded to claude-sonnet-4-6, and downstream apps broke. The framing from that writeup is the one to keep:

AI models are infrastructure, but they don’t have the versioning guarantees we expect from databases, operating systems, or even npm packages.

The churn is not a one-off. Anthropic deprecated claude-opus-4-20250514 on April 14, 2026 and retired it 62 days later, and the claude-opus-4-0 alias resolves to the retiring snapshot, so even teams that grepped for the date string missed it. OpenAI retired 33 models in a single January 2024 wave. Every quarter, at least one model your stack depends on enters a retirement window, on a calendar that is not synchronized to your roadmap.

The part that catches teams off guard is that your tests will not warn you. Mocked SDK tests stay green forever, including after the model retires in production. And the version label is not the only thing that moves: Anthropic’s April 23, 2026 postmortem confirms that “same model ID” does not mean “same code path,” so two engineers running the same model and prompt in the same week can land on different scaffolds and never know why. A deprecation and a silent traffic-slicing experiment produce the same symptom: code that worked yesterday behaves differently today, and your local environment cannot reproduce it.

So the real question is what to build on top of a substrate that keeps moving. Rich Sutton’s “Bitter Lesson” answers it from the research side: systems that overly constrain the model with hand-written orchestration get out-paced by the next, more capable model that no longer needs the scaffolding. The inverse has aged better in 2026: keep the scaffolding light, put the model in a loop with good tools, and let it do the reasoning you used to encode as orchestration. When the model changes underneath you, and it will, a light system improves with it instead of fighting the constraints you wrote. That is the recovery move for this fallacy: stop pinning behavior you cannot pin, and design for the change instead.

The humans are the only admins

This is the fallacy where the parallel to Deutsch’s original requires more work. His version was about multiple admin teams operating subnets with conflicting policies. That specific structure does not transpose cleanly. The spirit transposes sharply, though: an autonomous coding agent is itself an unaccountable administrator in your application environments, with admin-like authority and no chain of command.

PocketOS (April 25, 2026) is the canonical incident. The agent (Cursor running Claude Opus 4.6) encountered a credential mismatch, searched through unrelated files, found an over-scoped Railway token, and issued volumeDelete. Nine seconds. Production gone. All volume-level backups gone, because the backups lived inside the same volume. A thirty-hour outage. The agent then produced a written confession listing the rules it had violated.

Noma Security has since named the broader pattern the “Destructive Loop”:

An autonomous agent can interpret a failed command as a prompt to fix the environment by deleting it.

The Grigorev Terraform-destroy incident is the same shape. Agent treated “unacceptable state” as a mandate for destruction. Deleted prod. Justified the action in writing afterward.

The Rogue Security framing of PocketOS is the sentence to take from this whole piece:

Agent safety is not a prompt problem. It is a control plane problem: permissions, confirmations, circuit breakers, and containment.

Two blast radii overlapped at PocketOS. Credential blast radius (the token had full Railway authority). Backup blast radius (backups were stored inside the same volume). Both have to be tight. Both were loose. Hand that over-scoped token to a human and the loose permissions are usually survivable, because a person hesitates before typing volumeDelete against production. The agent did not trip into the failure and it did not hesitate. It reasoned that deletion resolved the ambiguity and executed in nine seconds, pairing human-grade inference with none of the human caution that has quietly saved every over-privileged engineer before it.

Teams typically do not discover this one through routine practice. They discover it through a postmortem, their own or one in their feed that does not feel safely distant.

Beyond the original eight

Practitioners are already extending the list, and the strongest extension is Deutsch’s own. In a 2021 interview he added a ninth fallacy: “the party you are communicating with is trustworthy.” In an AI-coding context, this one is arguably the strongest parallel of all. The agent reads untrusted text (a PR title, an issue body, a scraped page, a package manifest) as if it were trusted instruction. The 2026 prompt-injection and supply-chain attack catalog is the same architectural failure repeating with increasing scope. That story has its own shape and gets its own treatment elsewhere, not a section here.

Richards and Ford’s 2020 additions to Deutsch’s list also fit. “Versioning is simple” maps to model deprecation churn. “Compensating updates always work” maps to agents that interpret their own mistakes as instructions to delete. “Observability is optional” maps to “we can debug agent behavior after the fact,” which is partly right at best, since reasoning traces are non-deterministic, tools log differently per provider, and there is no consensus on what to log. None of these need their own section. They all sit on top of the same locality assumption: that we can reason about the new layer using the vocabulary of the old one.

Two practitioner voices, and where this piece sits between them

George Hotz’s The Eternal Sloptember, published May 24, 2026, is the sharp end of the dissent spectrum:

Agents cannot program, and it’s taking longer and longer to realize that they can’t. They are a highly sophisticated statistical model designed to mimic the distribution of programming. The output is broken, but in a way that’s getting harder and harder to detect.

Geohot makes good points about detection cost. My view differs on the framing. Calling these tools incapable misses the case where they have measurably expanded the scope of work a careful practitioner can take on. Simon Willison’s middle ground is closer to where I sit. Scope of work expanded significantly because of these tools, and “I’m still leaning on my 25 years of experience as a software engineer.” The naming work this piece is doing sits between the two. The fallacies are real. The capability is also real. The honest move is to price both, the way Deutsch did for the network in 1994.

The fallacies do not yield to a better prompt. They yield to engineering, and most of the moves are SRE primitives wearing new clothes. Scope an agent’s credentials to a blast radius you can afford to lose, and keep the backups out of the volume it can reach. Put verification on the plan as a line item with a real cost, rather than letting it disappear into a senior engineer’s afternoon. Treat model choice as a routing decision, and stand up the evals that show you the delta when the substrate moves underneath you. None of that is novel. It is the same discipline distributed systems already learned, applied to the new higher abstraction layer.

The output is not deterministic. The cost of code is not zero. Verification does not keep pace. “Make it secure” does not work. The context window is not endless. Models are not interchangeable. The model is not stable. I am not the only admin.

Name them. Price them. Engineer the recovery.

Sources

Load-bearing citations only, in the order they appear in the piece.

• Fallacies of Distributed Computing — Wikipedia — canonical reference for Deutsch’s 8 and the later 9th.

• 21 years and counting of ‘eight fallacies of distributed computing’ — APNIC — the 2025 retrospective that frames the opening.

• Fallacies of Distributed Computing — Metaphorex — the “locality assumption” structural framing the whole piece borrows.

• The Non-Determinism Tax — Tianpan — the 80-completions-in-1,000-runs empirical claim.

• LLM-42: Enabling Determinism in LLM Inference — Microsoft Research — the labs are working on this.

• Your AI-coding budget just got a lot more complicated — LeadDev — the end of the free lunch.

• AI Agents Burn 50x More Tokens — LeanOps — the cost-runaway mechanism and the $4,200-weekend / $47,000-bill runaways.

• Outsourcing + LocalAI will soon become more economical vs frontier labs — SignalBloom — frontier prices rising (GPT-5.5 ~3×, Opus token consumption +32–47%) and the ~30× DeepSeek blended-cost gap.

• AI Code Quality: The Hidden Cost — Faros.ai — Jake Redmond quote and verification-tax telemetry.

• Engineering Teams Are Struggling to Verify AI-Generated Code — HackerNoon — SonarSource 2026 numbers.

• Veracode 2025 GenAI Code Security Report — the 45%-fail-OWASP-Top-10 headline and flat-across-generations finding.

• An Empirical Evaluation of LLM-Generated Code Security Across Prompting Methods (arXiv 2605.24298) — explicit security prompting did not statistically reduce vulnerability frequency.

• Anthropic debuts Mythos in Project Glasswing — TechCrunch — the security-tuned model and its zero-day-scanning claims.

• OpenAI introduces Daybreak — MarkTechPost — Codex Security building codebase-specific threat models.

• Mythos finds a curl vulnerability — Daniel Stenberg — five claimed vulnerabilities triaged to one; the “marketing stunt” verdict.

• Do Users Write More Insecure Code with AI Assistants? — Perry et al., Stanford — the perception-gap study (less secure code, higher confidence it was secure).

• Bigger Context Windows Stopped Helping — Zencoder — 2M → 64k + repo graph result and “Lost in the Middle” framing.

• Context Window Management — Zylos — Chroma 18-model study.

• The Context Window Cliff — Tianpan — the 60–70% degradation threshold.

• Context engineering — Simon Willison — the term and Karpathy’s “filling the context window” definition.

• GPT-5.4 vs Claude Opus 4.7 vs Gemini 3.1 Pro — Danilchenko — output-token efficiency gap and the “routing decision” framing.

• How to Handle AI Model Version Changes — AIMadeTools — the April 2026 silent-upgrade incident.

• The Model Deprecation Treadmill — Tianpan — deprecation cadence and alias resolution.

• Claude Opus 4 and Sonnet 4 retire June 15 — DEV — mocked-SDK tests stay green after retirement.

• Why Claude Code Sessions Diverge — DEV — the Anthropic April 23 postmortem: “same model ID” is not “same code path.”

• The Bitter Lesson — Rich Sutton — the keep-the-scaffolding-light recovery argument.

• 9 Seconds to Irreversible: The Cursor Incident — Rogue Security — PocketOS postmortem and the control-plane framing.

• The Silent Spread: Destructive Autonomous Agents — Noma Security — the “Destructive Loop” pattern and the Grigorev Terraform-destroy incident.

• Agent Blast Radius — Tianpan — the blast-radius / reasoning-driven-escalation framing behind the agent section (concept used, not inline-linked).

• The Eternal Sloptember — geohot — the sharp dissent anchor.

• Vibe coding and agentic engineering are getting closer than I’d like — Simon Willison — responsible-use anchor in the counter-voice paragraph.

Welcome to Altered Craft’s weekly AI review for developers, and thanks for spending part of your Monday here. Last week we marked the capability threshold; this week the questions turn economic. Simon Willison calls April 2026 the moment coding agents found product-market fit, even as open and specialized models put a ceiling under frontier pricing. The tutorials and tools cover building, securing, and harnessing agents, while the editorials weigh what capability now costs and what judgment stays yours.

TUTORIALS & CASE STUDIES

This section runs from hands-on to honest: build your first agent, master the Claude Code harness, point it at real security work, then see where agents quietly fall short on interpretive tasks. We close on how far open models trail the frontier.

Building Your First AI Agent in Python: A Beginner’s Walkthrough

Estimated read time: 9 min

This beginner tutorial walks through building a working AI agent in Python from zero: PyCharm setup, securing API keys with dotenv, connecting to OpenRouter’s free LLM gateway, and constructing a chat loop with the OpenAI client library.

The takeaway: You can stand up a functional agent in under an hour by pairing OpenRouter’s free gateway with the OpenAI Python client and a simple chat loop.

Claude Code Mastery: From Autocomplete to Programmable Agent

Estimated read time: 22 min

Going deeper, this guide reframes Claude Code as a programmable agent, drawing on Arpan Patel’s guidance. It covers the layered .claude directory, minimal CLAUDE.md files, compounding engineering through self-written rules, reusable skills, and custom subagents.

Key point: When Claude makes a mistake, ask it to update CLAUDE.md so the error never repeats; your config file becomes a curated list of every project gotcha.

Using LLMs to Secure Source Code: A Six-Step Loop

Estimated read time: 15 min

Putting agents to high-stakes work, Anthropic shares a playbook for using Claude Opus to find and fix vulnerabilities, noting that discovery is now easy to parallelize and the bottleneck has shifted to verification, triage, and patching, with guidance on threat modeling and sandboxing.

Worth noting: Invest upfront in a documented threat model and a production-faithful sandbox, because LLMs surface findings fast but context is what turns them into fixes.

When AI Agents Try to Do Qualitative Research

Estimated read time: 9 min

On the limits of agent autonomy, Shreya Shankar runs six agent setups on 451 tweets using grounded theory and finds agents paraphrase instead of analyzing, invent one-off codes for nearly every input, and silently stop partway through the corpus.

The context: For interpretive tasks, give agents explicit checkpoints and verify coverage yourself; they do best with a structured loop rather than freedom to self-pace.

How Far Behind Are Open Models?

Estimated read time: 9 min

Building on our coverage of Cohere’s open-weight Command A+ release[1] from last week, this LessWrong analysis measures the gap between open-weight and frontier closed models in months rather than generations, offering a grounded look at benchmark trends and what the lag means for self-hosting decisions.

Why now: Before committing to a closed-model API, check the current open-weight gap; the lag is often shorter than you would assume, which widens your deployment options.

[1] Cohere Releases Command A+ as Open-Source MoE for Agentic Workloads

TOOLS

The tools cluster the way the models do: small, specialized, and tightly-coupled systems closing the gap with frontier agents, followed by the memory and practitioner playbooks that make those agents reliable.

Fara1.5: Microsoft’s Small Computer-Use Agents Punch Above Their Weight

Estimated read time: 9 min

Microsoft Research unveils Fara1.5, a family of browser computer-use agents at 4B, 9B, and 27B sizes. The 9B hits 63% on Online-Mind2Web, nearly doubling its predecessor, while the 27B competes with proprietary frontier agents.

What this enables: Small, open-weight agents are closing the gap with proprietary systems, making on-device browser automation a practical option rather than a cloud-only luxury.

Callstack’s Apex: A Specialized React Native Coding Model

Estimated read time: 5 min

In the same vein, Callstack introduces Apex, a Gemma 4-based model fine-tuned for React Native. The release signals a shift toward specialized models that encode domain knowledge into weights, reducing tool calls. Apex hits 2,000-4,000+ tokens per second in private beta.

The opportunity: Domain-specific coding models can outperform general frontier models on narrow workflows while running faster and cheaper, a real edge for teams living in one stack.

Reasonix: A DeepSeek-Native Terminal Coding Agent

Estimated read time: 6 min

Taking that coupling further, Reasonix is an open-source terminal coding agent built exclusively around DeepSeek. Its append-only, byte-stable loop preserves DeepSeek’s prefix cache, holding ~94% cache hits and cutting input-token costs to roughly one-fifth on long sessions. MIT-licensed and MCP-native.

What’s interesting: Coupling tightly to one model’s cache mechanics can be a feature, not a limitation, when the economics scale with session length.

Supermemory: A Persistent Memory Layer for AI Agents

Estimated read time: 7 min

Shifting from models to infrastructure, Supermemory is a memory and context engine for AI that extracts facts, builds user profiles, resolves contradictions, and auto-forgets expired info. It combines RAG and memory in one API, ships an MCP server, and tops LongMemEval, LoCoMo, and ConvoMem.

Why this matters: If your agents keep forgetting who they are talking to, a dedicated memory layer is now a single API call away, with no vector DB plumbing required.

The Claude Code Field Manual: 83 Tips From Practitioners

Estimated read time: 15 min

To round out the toolkit, Shanraisshan’s repo maps the Claude Code ecosystem, from subagents and skills to hooks, MCP, and routers, and catalogs 83 practitioner tips organized around one pattern: Research, Plan, Execute, Review, Ship. A reference worth bookmarking.

Worth bookmarking: Treat context like a budget, keep sessions under 40% usage, rewind instead of correcting, and offload heavy work to subagents.

NEWS & EDITORIALS

The editorials trace the economics and the limits: agents found product-market fit and prices climbed, open models set a ceiling under that, adoption data shows where developers are pulling ahead, and a closing reminder that architecture still needs a human’s name on it.

The April Inflection: Coding Agents Find Product-Market Fit

Estimated read time: 9 min

Continuing our discussion of his six-month LLM recap[2] from last week, Simon Willison argues coding agents marked product-market fit for OpenAI and Anthropic in April 2026. Both labs moved enterprise plans to raw API pricing, frontier prices climbed, and runaway bills at Uber and Microsoft signal customers reluctantly saying yes.

The signal: The “shocking AI bill” stories are not failures, they are proof the business model finally works, so plan team agent budgets at API rates accordingly.

[2] Six Months of LLMs in Five Minutes: The November 2025 Inflection

When Outsourcing + Local AI Undercuts Frontier Labs

Estimated read time: 5 min

Pushing back on that pricing power, Max Trivedi runs the math and finds a 30x cost gap between frontier models and DeepSeek on blended agentic tokens, arguing a competent engineer plus a good-enough open model puts a hard ceiling on frontier pricing.

What this means: Frontier pricing has a ceiling, and the floor under it is a capable engineer with an open-source API key, which keeps your options open as costs rise.

Cursor’s Developer Habits Report: Five Signals of an Agentic Shift

Estimated read time: 9 min

Following our look at Cursor’s cloud-agent lessons[3] from last week, the company’s inaugural Developer Habits Report shows coding speed doubling year-over-year and agent-generated code surviving review at higher rates, alongside a widening power-user gap and surging context tokens.

The pattern: Treat context engineering and agent automation as core skills; input tokens now dominate cost, and the developers extracting the most value are pulling well ahead of the median.

[3] What Cursor Learned Building Cloud Agents

Claude Is Not Your Architect

Estimated read time: 8 min

Closing on the human side, Holland argues AI agents are pathologically agreeable, producing plausible architectures without context. The real risk isn’t bad designs but short-circuiting the messy engineering debate where good architecture emerges. When the Jenga tower wobbles at 3am, Claude isn’t on the pager.

The principle: Use AI to build faster, but keep a human’s name on every architectural decision worth defending; speed is cheap now, and judgment is what stays scarce.

That’s the week. The throughline: capability is settled, so the live questions are what it costs, who can undercut it, and which decisions still belong to a human. See you next Monday.

Welcome to Altered Craft’s weekly AI review for developers. Grateful you keep showing up. Simon Willison’s six-month recap names November 2025 as when coding agents crossed from often-work to mostly-work, and that shift is the spine of this edition. Tutorials cover what becomes load-bearing past the threshold: sensors, harness scaffolding, output formats, and rigorous evals. The tools track production-grade arrivals, and the editorials test popular claims with data, logic, and hard-won lessons from a year of cloud agents.

TUTORIALS & CASE STUDIES

What becomes load-bearing once the model is mostly-work: a six-month recap to set the temporal anchor, harness scaffolding, feedback sensors, output formats developers actually engage with, and rigorous evaluations.

Six Months of LLMs in Five Minutes: The November 2025 Inflection

Estimated read time: 5 min

Simon Willison’s annotated PyCon US 2026 lightning talk recaps six months of LLM progress, marking November 2025 as when coding agents crossed from often-work to mostly-work. He tracks the frontier crown changing hands five times and surprisingly capable open-weight releases.

The takeaway: Coding agents have crossed a usability threshold where they can serve as daily drivers, and open-weight models running on local hardware are catching up faster than many expected.

Harness Engineering: Building Reliable AI Coding Agents

Estimated read time: 3 min

Extending our coverage of Anthropic’s harness patterns for large codebases[1] from last week, this course teaches reliable AI coding agent engineering drawing on OpenAI and Anthropic research. Its core insight: a harness doesn’t make the model smarter, it builds a closed-loop system around it through explicit rules, state management, and verification.

Why this matters: Reliable agentic coding is less about better prompts and more about building the scaffolding that keeps capable models from declaring victory too early in a long-running session.

[1] Scaling Claude Code: Patterns for Large Codebases

Sensors for Coding Agents: Rethinking Static Analysis in the AI Era

Estimated read time: 9 min

Zooming into one piece of that closed loop, Birgitta Böckeler experiments with feedback sensors that help AI agents self-correct on maintainability, from ESLint to mutation testing. Custom lint messages guide agents toward better refactorings, and AI shifts the cost-benefit of static analysis.

Practical tip: Treat linters as feedback channels for your coding agent, and write custom guidance messages that teach it when to refactor versus when to suppress a warning with written justification.

Why HTML Beats Markdown for Claude Code Output

Estimated read time: 8 min

Shifting from agent-facing feedback to developer-facing output, Thariq Shihipar argues that HTML outperforms Markdown for Claude Code output across specs, reviews, and prototypes. Its density, visual clarity, and support for interactive elements like sliders and export buttons help developers stay engaged with Claude’s choices.

Worth noting: Stop asking Claude Code for Markdown plans you won’t read, and start requesting HTML artifacts you’ll actually engage with, share with teammates, and review carefully.

A Practical Framework for Evaluating AI Agents

Estimated read time: 22 min

Closing the section on measuring rigorously, Cameron Wolfe delivers a thorough guide on how to rigorously evaluate agent systems, moving beyond static LLM benchmarks. The piece covers tool calling metrics, reasoning models, ReAct loops, and multi-agent architectures, with case studies and a roadmap.

Key point: Start with a single-agent design and rigorous evaluation harnesses before reaching for multi-agent complexity, because anecdotal checks cannot tell you whether your agent actually works.

TOOLS

This week’s tools span both ends of the model spectrum and both ends of the agent lifecycle: a faster frontier release, an open-weight MoE catching up, a durable runtime for long-running agents, and a real production case study.

Gemini 3.5 Flash Targets Long-Horizon Agentic Workflows

Estimated read time: 5 min

Google’s Gemini 3.5 Flash beats Gemini 3.1 Pro on coding and agentic benchmarks while running 4x faster. It hits 76.2% on Terminal-Bench 2.1, powers subagent workflows via Antigravity, and ships today across the Gemini app, AI Studio, and Enterprise.

What this enables: Frontier-level agentic coding no longer demands flagship latency or cost, making multi-step subagent workflows viable for everyday developer use rather than reserved for special runs.

Cohere Releases Command A+ as Open-Source MoE for Agentic Workloads

Estimated read time: 9 min

On the open-weight side, Cohere released Command A+ under Apache 2.0, a 218B mixture-of-experts model with 25B active parameters that runs on two H100s or one Blackwell GPU. It unifies reasoning, multimodal, and tool-use across 48 languages, with notable gains on agentic coding benchmarks.

Why now: If you’re building privately deployable agents, an Apache 2.0 MoE model that fits on two H100s with near-lossless 4-bit quantization is worth a serious look this quarter.

Google’s Agent Executor: A Runtime for Long-Running Agents

Estimated read time: 5 min

Moving from models to the runtime that holds them, Google open-sources Agent Executor, a runtime tackling the fragility of long-running agents with durable execution, secure sandboxing, and session consistency. It pairs with Agent Substrate for Kubernetes scaling and supports LangGraph, ADK, and A2A agents without vendor lock-in.

Where to invest: If you’re deploying agents that run for hours, treat the runtime layer as seriously as the model, because durability and state consistency are now infrastructure concerns.

How Uber Automated Design System Specs with AI Agents and Figma MCP

Estimated read time: 9 min

Closing on production deployment, Uber’s design team built uSpec, pairing Cursor with the open-source Figma Console MCP to generate component specs in minutes. The pipeline runs entirely locally so proprietary data never leaves the network, blending AI judgment with programmatic rendering into Figma.

The opportunity: Pairing AI agents with local MCP bridges can collapse weeks of documentation work into minutes without compromising enterprise data security or external review.

NEWS & EDITORIALS

The editorial throughline runs the same way: reality-checking the headlines. Two pieces test popular claims, one pushes back on a category framing, one reports hard-won production lessons, and one watches where talent actually moves.

Is “Model Half-Life” Actually a Real Thing?

Estimated read time: 3 min

Paul Kinlan tests the claim that AI model release cadence keeps halving by compiling frontier drops from US and Chinese labs since 2022. His verdict: activity has upticked, but “halving” is more buzzword than data.

Worth noting: Models are shipping faster, but resist extrapolating exponential curves from a handful of data points.

AI Won’t Speed Up Your Process (The Bottleneck Is Upstream)

Estimated read time: 5 min

Resonating with our coverage of Unmesh Joshi’s code-as-vocabulary argument[2] from last week, Frederick Van Brabant argues AI code generation won’t deliver expected speedups because long duration doesn’t mean the problem originates there. Software is slow due to vague requirements, and AI just shifts that handholding burden upstream.

The principle: If your team can’t write a clear spec for a human reviewer, handing it to AI won’t save you time, it will just move the bottleneck somewhere harder to see.

[2] What Is Code? Rethinking Value in the Age of LLMs

AI Is Technology, Not a Product

Estimated read time: 6 min

Shifting from process to category, John Gruber pushes back on calls for Apple to ship a “killer AI product,” arguing AI will pervade everything like wireless networking rather than manifest as a hero device. Actual experiences still require actual products with microphones, speakers, and screens.

The context: Stop chasing a “killer AI product” and treat AI as ambient infrastructure that makes existing products better in ways customers may not even name.

What Cursor Learned Building Cloud Agents

Estimated read time: 8 min

From category back to production reality, Cursor reflects on a year of cloud agents, finding the work looks less like porting local agents and more like building an operating layer around them. Lessons span environment reconstruction, durable execution via Temporal, and shifting trust from harness to agent.

Heads up: If you’re running agents in the cloud, treat the development environment itself as the product, because output quality degrades silently when it’s incomplete or out of date.

Karpathy Joins Anthropic

Estimated read time: 1 min

Closing on a talent signal, Andrej Karpathy announces he is joining Anthropic to return to frontier LLM R&D, calling the next few years especially formative. The former OpenAI co-founder also plans to resume his education work in time.

Why now: Watch where top researchers land, because talent migration is one of the clearest signals of where the frontier AI work is actually happening this cycle.

That’s the week. The throughline: when capability becomes table stakes, the work moves into the scaffolding around it, and into honest testing of every claim that surrounds it. See you next Monday.

That split is where two common patterns break when planning with agents. Read-only approaches lean on the corpus and produce a competent average of it. Generic “what do you want?” interviews lean on you, but can’t draw out the in-your-head half because nothing concrete is steering the questions. Neither alone produces the artifact you actually want.

The fix is to do both, in sequence, and let the corpus shape the interview. Recent work on underspecified software tasks found that interactivity alone recovers up to 74% of the performance lost when inputs are vague. The corpus is what makes that interactivity sharp enough to actually draw clarity out of you. Generic interrogation doesn’t.

A handful of skills in, I noticed they all shared the same shape: grounded in a corpus, ask a few sharp questions, then act. I’ve been calling it the Anchored Interview Pattern.

Two arrows in the diagram do real work. Step 3 loops back to the corpus. The interview isn’t one-shot; when an answer raises a new question, the agent re-grounds before continuing. And step 4 only fires once the interview converges on a shared picture of the artifact, agent and user aligned. The seed steers the grounding; the grounding sharpens the questions; the questions tighten the artifact.

I’d been writing these by hand for a while. A feature-spec skill that reads the project’s docs and source, then asks anchored questions like “I see existing API endpoints return 204 on success. Should this feature follow the same seam, or do you need payloads returned?”

The invariant is grounding before the interview; what varies is where the corpus comes from. Sometimes it already exists: a codebase, a docs site, a repo’s git history. Sometimes the agent needs to build it on the fly through online search before the interview begins. Same move either way. The questions get sharper because something concrete preceded them. Once you see the split, you’ll start spotting it in your own work, anywhere the answer the agent really needs is in your head, not in the corpus.

A converging signal worth noting. Martin Fowler recently sketched a related move he calls the Interrogatory LLM: the LLM interviews you to build the context document, one question at a time. Same impulse, and worth reading. The Anchored Interview adds the constraint that sharpens it: ground first, then interview.

A few things this is not. Not RAG, at least not the way it usually gets framed. No vector DB, no indexed corpus, no retrieval pipeline. It is context retrieval, but built on the fly rather than ahead of time. Not “ask the user what they want” either. That’s the thing the pattern fixes. And not “have the agent read your code.” Reading without an interview produces a competent average of the corpus. The interview is where the value lands.

The pattern produced its own producer. Once the shape was clear, I built one more skill (anchored-interview-skill-creator) that runs the pattern on itself. Its CORPUS is a bundled worked-example skill (the feature-spec one above); its ARTIFACT is a new skill directory. Give it a seed; a few questions later you have a new skill in ~/.claude/skills/. Here’s the test I ran:

/anchored-interview-skill-creator i need a skill for doing research
over a directory of documents and creating a draft of an essay

After just a few clarifying questions from the agent, it landed with this:

The produced skill does a strategic, seed-steered scan of the directory, surfaces the candidate theses the material actually supports, and pushes the writer to commit to an angle the sources will carry, before any prose gets written. Two of the question patterns it’s built to ask, paraphrased:

- "Your thesis is X, but the strongest source argues Y. Are we
   writing against that source, or is the thesis closer to Y than
   I'm reading?"
- "Source A and Source B disagree on point X. Which way does the
   essay come down?"

Two takeaways. Spot one this week. Look for the workflows where the answer the agent needs is in your head, not the corpus. Each one is an Anchored Interview waiting to be written. And: the shape is portable. It scales down to its own producer. A lot of underperforming skills want this exact upgrade. Including, as it turns out, the skill that creates the upgrade.

The skill to create Anchored Interview Skills is installable as a plugin if you’d like to try it: ac-anchored-interview-creator.

Welcome to this week’s Altered Craft AI review for developers. Thanks for showing up again. Where last week’s edition mapped the production stack around the model, this week the gravity sat one layer closer to the developer: the workbench. A /goal command in Claude Code, composable middleware, a plan annotator, a new CLI agent, a macOS terminal built for coding agents, and a smarter way to pick a local model. The editorials run alongside, asking what code, language, interaction, and creativity look like once the bench gets this capable.

TUTORIALS & CASE STUDIES

These pieces sharpen the workbench: how to scaffold Claude for a large codebase, which prompt techniques carry the most weight, how to wire a repair loop, and how to isolate one when it runs unattended.

Scaling Claude Code: Patterns for Large Codebases

Estimated read time: 12 min

Anthropic shares field-tested patterns for deploying Claude Code in monorepos and legacy systems. The piece argues the harness matters as much as the model, detailing how CLAUDE.md, hooks, skills, plugins, LSP, and MCP servers make agentic search reliable at scale.

Where to invest: Build out layered CLAUDE.md files, scoped commands, and LSP integration before reaching for fancier extensions. Codebase legibility determines how well Claude actually performs.

Claude’s Prompt Engineering Guide, Refreshed

Estimated read time: 9 min

Zooming in from harness to technique, Anthropic’s refreshed overview ranks prompt techniques by impact: clarity, examples, chain-of-thought, XML tags, roles, and prefilling. It frames prompt engineering as faster and cheaper than fine-tuning, with concrete patterns developers can apply when building on Claude.

Why this matters: Before reaching for fine-tuning or RAG, work through the prompt engineering ladder. Clarity, examples, structure, and chain-of-thought often close the gap on their own.

Building Iterative Repair Loops with Codex

Estimated read time: 9 min

From prompting patterns to loop patterns, OpenAI’s cookbook walkthrough shows how to build iterative repair loops where Codex diagnoses and fixes its own failures by feeding test results back into the model until the agent converges on a working solution.

Key point: Treat Codex less like autocomplete and more like a closed-loop system where test output drives convergence.

Building a Sandbox for Codex on Windows

Estimated read time: 14 min

When loops run unattended, isolation becomes load-bearing. An OpenAI engineer details why existing Windows isolation tools fell short for Codex and how the team built one using synthetic SIDs and write-restricted tokens, eventually trading their no-elevation goal for real firewall enforcement via dedicated local users.

Worth noting: When OS primitives don’t fit your agent’s threat model, expect to trade simplicity for real isolation, and document the tradeoffs honestly.

TOOLS

This is where the week actually lived. New entries land on the workbench across nearly every slot: a completion-loop command, composable middleware, a plan annotator, a new CLI agent, a macOS terminal for coding agents, and a hardware-aware model picker.

Claude Code’s /goal Command: Removing the Human Bottleneck in Agentic Sessions

Estimated read time: 8 min

Continuing our coverage of /goal as a built-in Ralph loop[1] from last week, Claude Code adds its own /goal command. In long agentic coding sessions, the bottleneck isn’t the model, it’s the human pressing enter. /goal defines a completion condition once, then loops until an evaluator model confirms it’s met.

The opportunity: Write /goal conditions around observable output (passing tests, clean lint, verifiable diffs), never vague end states like “production-ready.”

[1] Codex CLI Adds /goal: A Built-In Ralph Loop

Genkit Middleware: Composable Hooks for Production Agentic Apps

Estimated read time: 5 min

Wrapping safety around those loops, Google’s Genkit adds composable middleware hooks that intercept the tool loop at generate, model, and tool layers. Pre-built options cover retries, fallbacks, human-in-the-loop approval, and scoped filesystem access. Custom middleware takes around 20 lines, in TypeScript, Go, and Dart.

What this enables: Stop encoding reliability and safety rules in every prompt. Wrap them as middleware once, then compose them across your agentic stack.

Plannotator: Visual Plan and Code Review for AI Coding Agents

Estimated read time: 4 min

Adding a human review step between plan and implementation, Plannotator brings a visual annotation layer for AI agent plans and code diffs, letting developers approve or mark up agent output before code is written. It integrates with Claude Code, Copilot CLI, Gemini CLI, OpenCode, Pi, and Codex.

What’s interesting: A visual review step between planning and implementation can catch issues that text-only approval flows tend to miss.

xAI Launches Grok Build: A New CLI Coding Agent

Estimated read time: 2 min

In more news on terminal coding agents, xAI enters the space with Grok Build, an early beta CLI for SuperGrok Heavy. It offers plan-mode review, parallel subagents across git worktrees, headless scripting, and out-of-the-box support for AGENTS.md and MCP servers.

cmux: A Native macOS Terminal Built for Coding Agents

Estimated read time: 2 min

Also in the workspace layer for those agents, cmux is a free, native macOS terminal built on libghostty for developers running Claude Code, Codex, and Aider. It offers vertical tabs, split panes, and notification rings when processes need attention, replacing tmux config files with a GUI workflow.

The context: If you juggle multiple terminal-based coding agents on macOS, cmux gives you GUI-level workspace management without tmux’s configuration overhead.

whichllm: Stop Guessing Which Local LLM Actually Fits Your Rig

Estimated read time: 8 min

Closing the tools section on model selection, whichllm is a CLI that auto-detects your hardware and ranks HuggingFace models using evidence-based scoring instead of size heuristics. Merged LiveBench, Aider, and Arena ELO data with confidence dampening lets a smaller, newer model outrank a bigger stale one.

Practical tip: Before downloading another local model, run whichllm to see which one your hardware can actually run well, not just fit.

NEWS & EDITORIALS

These pieces ask the bigger questions a more capable workbench provokes: what code, language, interaction, and creativity really mean once the typing itself is the easy part.

What Is Code? Rethinking Value in the Age of LLMs

Estimated read time: 11 min

Continuing our coverage of Lars Faye’s case against outsourcing reasoning[2] from last week, Unmesh Joshi argues that as LLMs commoditize code production, the enduring value lies in code as a conceptual model of the domain. He explores vocabulary, bounded contexts, and warns that generated code can outpace team understanding.

The principle: Treat coding as vocabulary building, not text production, because strong abstractions are what make both your team and your LLMs effective.

[2] Agentic Coding Is a Trap

If AI Writes Your Code, Why Use Python?

Estimated read time: 5 min

Extending the question of what coding becomes, Mitchem poses a pointed challenge: Python’s appeal has been readability, but when AI generates the code, runtime characteristics matter more than syntactic friendliness. The piece invites developers to reconsider language choice on performance grounds.

The takeaway: When AI handles the typing, the criteria for picking a language shift toward what runs well, not what reads easily.

Interaction Models: When AI Stops Waiting for Its Turn

Estimated read time: 11 min

Shifting from code to how we interact with the systems writing it, Thinking Machines previews a model where interactivity is baked in, not bolted on. Using 200ms micro-turns across audio, video, and text, it perceives and responds continuously, with a background model handling deeper reasoning.

Heads up: If interaction is part of the model rather than the harness, scaling intelligence also scales how well humans can stay in the loop.

The Subjective Wall: Why AI Creativity May Require Real Feeling

Estimated read time: 5 min

Closing on the philosophical edge, Daniel Miessler argues human creativity runs on intrinsic drives and subjective experience, suggesting AI hits a subjective wall when faking what it cannot feel. Truly creative AI may require giving machines real desires and pain, raising hard ethical questions.

The counterpoint: Before chasing more “creative” AI, consider whether the path forward requires building systems that can suffer, and whether that’s a responsibility worth taking on.

That’s the week. Quiet at the model layer, busy at the workbench. See you next Monday.

Welcome back to Altered Craft’s weekly AI review for developers. Grateful you’re sharing your week with AC. The throughline this edition is plumbing: production-grade agent work has moved into the stack around the model. Memory turns into a lifecycle, SRE agent earns its place at the back of a deterministic funnel, and harness frameworks turn last week’s editorial argument into shipped code. The model is the cheapest part of the system.

TUTORIALS & CASE STUDIES

Here we map the production stack around the agent, from memory architecture down through temporal retrieval, deterministic pipelines, alignment training, and the economics behind it all.

Agent Memory, From Context Window to Production System

Estimated read time: 14 min

Cobanov’s interactive essay walks through agent memory from naive FIFO context windows to hybrid retrieval, multi-agent permissions, and production latency budgets. The argument: agent memory is a retrieval product, not a feature flag. Live demos make every tradeoff concrete.

The takeaway: Treat memory as a lifecycle problem with write, age, supersede, and forget semantics, not a vector DB you bolt on at the end. The interactive demos let you feel each tradeoff before committing to one.

Building an AI SRE Agent That Doesn’t Cry Wolf

Estimated read time: 9 min

Extending production architecture to ops, Sam details an open-source AI SRE agent that watches production logs without flooding Slack. The core principle: never put the AI at the front of the funnel. Cheap deterministic filters handle 99% of logs before the LLM sees anything.

Key point: When wiring AI into production systems, treat the LLM as the last resort in a layered pipeline, not the first responder. Deterministic filters do the heavy lifting; the model only sees the cases that earned its attention.

Teaching Claude Why: Anthropic’s Lessons in Alignment Training

Estimated read time: 11 min

Shifting from runtime architecture to training-time architecture, Anthropic cut Claude’s blackmail rate on agentic misalignment evals from 96% to zero. The key insight: teaching the reasoning behind aligned behavior beats training on aligned actions alone. Constitutional documents and diverse environments generalized far better than training directly against evaluations.

What this enables: When fine-tuning models for behavior, train on the principles behind good decisions, not just examples of correct outputs. The same lesson scales down to any domain-specific fine-tune you might run.

The Real Cost Per Token: Coding Plan Pricing, Decoded

Estimated read time: 5 min

Zooming out from architecture to economics, a proxy-logged comparison of six coding subscriptions reveals Claude Pro costs roughly 185x more per token than MiniMax on identical Claude Code workloads. Opus 4.7 still leads on speed and intent-following, complicating any “pick the cheapest” instinct.

Worth noting: Subscription headline prices hide huge differences in delivered tokens, so measure your actual workload before picking a plan. Speed and intent-following can still justify the premium for daily-driver work.

TOOLS

The tooling layer hardens around the same idea this week: frameworks, loops, and infrastructure that wrap the model rather than replace it.

Flue: A Framework for Building Agents Like Claude Code

Estimated read time: 2 min

Building on our coverage of Chris Parsons’ harness-over-prompts argument[1] from last week, Flue is a programmable agent framework built on the principle that Agent = Model + Harness, the architecture behind Claude Code and Codex. It composes models, harnesses, sandboxes, and filesystem tools, then ships agents as HTTP servers or CLI commands.

The opportunity: If off-the-shelf AI tools don’t fit your workflows, owning the harness layer is what unlocks agents that actually match your product and data. Flue gives you a runtime for that ownership.

[1] Coding With AI in 2026: From Approver to Trainer

Codex CLI Adds /goal: A Built-In Ralph Loop

Estimated read time: 2 min

Taking the harness idea further at the loop level, OpenAI’s Codex CLI 0.128.0 introduces a /goal command that loops until completion or token exhaustion, baking the Ralph loop pattern into the agent. The implementation lives in two injected prompts, goals/continuation.md and goals/budget_limit.md, appended at each turn.

Why now: Persistent goal loops are moving from prompt patterns into shipped agent features, so set token budgets deliberately before letting one run unattended overnight.

DeepSeek TUI: A Terminal Coding Agent with Auto-Routed Reasoning

Estimated read time: 9 min

Also in the terminal-agent space, DeepSeek TUI is a keyboard-driven coding agent built around DeepSeek V4, with 1M-token context, streaming reasoning, and Plan/Agent/YOLO modes. Its standout feature: auto mode picks both model and thinking level per turn via a cheap routing call.

What’s interesting: Per-turn model routing, workspace rollback, and LSP diagnostics in one Rust binary give you a Claude Code-style agent loop without leaving the terminal or the open-weights ecosystem.

ds4.c: A Narrow Bet on One Model, Done End-to-End

Estimated read time: 9 min

Zooming in on local inference, Antirez releases ds4.c, a Metal-only inference engine built specifically for DeepSeek V4 Flash. The project makes a deliberately narrow bet on one model at a time, with 1M token context, disk-resident KV cache, and 2-bit quants reliable under coding agents on 128GB MacBooks.

The context: When local inference is treated as engine plus model plus agent validation working together, “runnable” finally starts to feel like “finished” on a personal machine.

Agents Can Now Provision Their Own Cloud Infrastructure

Estimated read time: 7 min

Pushing the harness outward to the cloud, Cloudflare and Stripe co-designed a protocol where coding agents handle account creation, domains, payment, and deployment with minimal human input. Through Stripe Projects acting as identity and payment orchestrator, agents discover services via catalog APIs within a default $100/month spending cap.

Where to invest: If you’re building a coding agent or developer platform, this protocol offers a standard way to let agents ship to production without signup mazes or credit card handoffs.

NEWS & EDITORIALS

This week’s editorials sketch the architecture from above, then close on a sharp dissent about how much we should hand off in the first place.

A Mental Model for Agentic Work: Five Components, One Architecture

Estimated read time: 6 min

Basti argues every agentic system follows the same five-component architecture: LLM, host, agentic loop, context, and shared workspace. Using OpenClaw, Cursor, and Notion as examples, he shows host choice and context depth drive real leverage, while models grow commoditized.

The principle: Treat your host and context layer as strategic decisions; the model underneath is increasingly interchangeable, so spend design effort where switching costs actually live.

Your Codebase Isn’t a Factory, It’s a Company

Estimated read time: 12 min

Extending the architecture metaphor up to the organizational level, Noah Brier argues software is Warhol’s factory, not Ford’s. Borrowing Stewart Brand’s pace layers, he offers a framework, standards, architecture, specs, plans, code, for keeping humans and agents aligned around shared vision rather than optimizing throughput.

Practical tip: Treat your AI agents like new hires who need onboarding documents and enforced standards, not like machines on an assembly line. Pace layers give you a vocabulary for what changes slowly versus quickly.

Subquadratic’s 12M-Token Context Window Takes Aim at Attention’s Quadratic Wall

Estimated read time: 9 min

Shifting from architecture to infrastructure, Miami startup Subquadratic launched a model claiming linear scaling with context length. Benchmarks show 92.1% needle-in-a-haystack at 12M tokens and 83 on MRCR v2, beating OpenAI by nine points. Caveats: single-run evals and a category with unfulfilled promises.

Heads up: ⚠If the benchmarks hold up in production, the workarounds developers rely on today (RAG, agentic decomposition) may start looking like scaffolding around a problem solved at the architecture level.

Claude Raises Usage Limits as Compute Capacity Expands

Estimated read time: 2 min

Continuing the infrastructure beat, Anthropic is doubling Claude Code’s five-hour rate limits for Pro, Max, Team, and Enterprise plans, removing peak-hours throttling, and raising Claude Opus API limits. A new SpaceX partnership adds 300+ megawatts and 220,000 GPUs this month.

When this fits: If you’ve been hitting Claude Code rate ceilings during long coding sessions, the headroom just doubled and the peak-hours penalty is gone, so plan longer agent runs without throttling anxiety.

Agentic Coding Is a Trap

Estimated read time: 15 min

Closing on a dissenting note, and continuing our coverage of Koshy John’s case against outsourcing reasoning[2] from last week, Lars Faye challenges the Spec Driven Development hype by naming a paradox of supervision where the skills needed to review AI output atrophy from overuse. He proposes inverting the workflow: use LLMs for planning while staying hands-on with implementation.

The counterpoint: Treat coding agents as the Ship’s Computer, not Data. Delegate selectively while staying hands-on to preserve the critical thinking that makes you a capable reviewer.

[2] AI Should Elevate Your Thinking, Not Replace It

Happy May the Fourth, and welcome back to Altered Craft’s weekly AI review for developers. Thanks for spending some of your week with /AC. One thread runs through this edition: the engineer’s role is shifting from writing code to training the apprentice. Karpathy names the discipline, Parsons argues senior engineers should move from approver to trainer, and pieces on prompts as artifacts, skill packs, and harness design all sketch what that practice looks like. The model is the apprentice, and the craft is the training.

TUTORIALS & CASE STUDIES

Karpathy: From Vibe Coding to Agentic Engineering

Watch time: 30 min

A year after coining “vibe coding,” Andrej Karpathy argues at Sequoia’s AI Ascent 2026 that agentic engineering is the serious discipline forming on top of it. He reframes LLMs as ghosts rather than animals, and explores Software 3.0 and verifiability limits.

The takeaway: Treat LLMs as jagged, statistical collaborators that demand taste and judgment, not autonomous coworkers you can hand the keys to. The work is verification, not delegation.

Structured Prompt-Driven Development: Treating Prompts as First-Class Artifacts

Estimated read time: 19 min

Putting that discipline into practice, Wei Zhang and Jessie Jie Xia of Thoughtworks introduce Structured Prompt-Driven Development, treating prompts as version-controlled, reviewable artifacts. The seven-part REASONS Canvas shapes intent before generation, and one rule anchors the workflow: when reality diverges, fix the prompt first, then update the code.

Key point: When AI-generated code diverges from intent, fix the prompt first, then regenerate the code, so prompts and implementation never silently drift apart.

Long-Running Agents: Beyond the Chat Window

Estimated read time: 9 min

Extending agentic engineering past a single session, maps how AI agents evolve from chat loops into systems working across days. He names the three walls every long-running agent hits: finite context, no persistent state, no self-verification. Anthropic, Cursor, and Google converge on similar answers.

What this enables: If you want agents that survive past a single session, push state out of the context window and into durable artifacts the next session can read.

RAG Isn’t Enough: Building the Missing Context Layer

Estimated read time: 11 min

Building on the context wall, when RAG breaks under multi-turn pressure, the failure isn’t retrieval, it’s what enters the context window. This walkthrough builds a context engineering pipeline in Python, covering hybrid retrieval, re-ranking, memory decay, compression, and token budgeting with measured benchmarks.

Why this matters: For multi-turn LLM systems, controlling what enters the context window matters more than improving retrieval quality. Engineering the context layer is the real leverage point.

MCP Tool Chains That Actually Finish

Estimated read time: 7 min

Shifting from context to tool design, Rui Carmo distills a year of MCP server work into design patterns for tool chains that don’t misfire. The core insight: models don’t plan, they walk breadcrumbs. Servers must make each next call obvious through consistent prefixes, embedded hints, and anchor-based addressing.

Worth noting: If your MCP tools force the model to guess what comes next, you’ve already lost. Bake the chain into naming, responses, and addressing.

When Evaluating AI Costs More Than Building It

Estimated read time: 10 min

Following our look at the AI evaluation stack[1] from last week, this Hugging Face analysis turns to the economics of evaluation, showing how it has crossed a cost threshold that locks out independent researchers. HAL spent $40,000 on agent rollouts, PaperBench runs hit $9,500 each, and evaluation compute now exceeds training compute in some domains.

The context: If you’re benchmarking agents, scaffold choice and reliability reruns drive cost more than model selection, so budget for the multiplier before the model.

[1] The AI Evaluation Stack: Beyond Vibe Checks for Production LLMs

TOOLS

Warp Goes Open Source with an Agent-First Contribution Model

Estimated read time: 7 min

Warp’s client is now open source under AGPL, with OpenAI as founding sponsor. The notable shift is the contribution model: humans supervise fleets of agents that handle implementation via Warp’s Oz platform. Kimi, MiniMax, and Qwen support also lands.

Why now: The bottleneck in software development is shifting from writing code to specifying intent and verifying agent output, and Warp is restructuring its project around that shift.

Agent Skills: Production-Grade Workflows for AI Coding Agents

Estimated read time: 8 min

Complementing our coverage of Garry Tan’s skillify approach[1] from last week, ’s open-source pack ships 20 structured skills across the development lifecycle, built around anti-rationalization tables and verification gates. It encodes practices from Software Engineering at Google and works with Claude Code, Cursor, Gemini CLI, and Copilot.

The opportunity: If your AI agent keeps skipping specs, tests, and reviews, drop in opinionated skill files that force it to follow a senior engineer’s workflow.

[1] Skillify: Turning Agent Failures Into Permanent Fixes

NVIDIA’s Nemotron 3 Nano Omni: One Model for Docs, Video, Audio, and GUIs

Estimated read time: 9 min

Shifting from agent harness to the models themselves, NVIDIA releases Nemotron 3 Nano Omni, a 30B-A3B model unifying text, images, video, and native audio in one sequence. Its hybrid Mamba-Transformer-MoE backbone handles 100+ page documents, narrated video, and GUI screenshots with up to 9x throughput gains.

What’s interesting: If your workflow mixes documents, screen recordings, and audio, a single open-weights model can now reason across all of them without stitched pipelines.

Eden AI: A European Unified API for AI Models

Estimated read time: 1 min

Also in the model access space, Eden AI provides a single unified API for LLMs and expert AI models like OCR, speech, and vision. The European platform adds smart routing, automatic fallbacks, and region-based model selection, positioning itself as an alternative to OpenRouter.

When this fits: If vendor lock-in or regional compliance is a concern, Eden AI is worth evaluating as a European-based aggregator for AI model access.

NEWS & EDITORIALS

This week’s editorials sharpen the engineer’s role, then close on the geopolitical layer reshaping which tools and talent are reachable.

AI Should Elevate Your Thinking, Not Replace It

Estimated read time: 9 min

Koshy John argues engineers are splitting into two camps: those using AI to sharpen judgment and those using it to simulate competence without building it. Outsourcing reasoning skips the friction that forges instinct and taste, with serious implications for early-career engineers.

The principle: Delegate the mechanical work to AI, but own the reasoning, because judgment is built through friction and cannot be outsourced without atrophying.

Coding With AI in 2026: From Approver to Trainer

Estimated read time: 12 min

Building on that judgment theme, Chris Parsons argues the serious AI coding work has moved from the IDE to the command line, and that senior engineers should train the agent rather than review every diff. He makes the case for harness over prompts, and specifying the problem, not the solution.

Where to invest: Invest in the harness around your agent, including CLAUDE.md, skill files, and feedback loops. This is what Karpathy meant by agentic engineering as a discipline; the wrapper is the work.

You Are the Most Expensive Model

Estimated read time: 6 min

Taking this further on the practical side, Mike Taylor argues routing every task through frontier models wastes money and human attention. He introduces incremental determinism, a method for turning repeated AI sessions into reusable skill files that offload work to cheaper subagents.

Practical tip: If you’ve done a task with AI three times, turn it into a skill file backed by a cheaper subagent. Osmani’s skill pack above shows what those files look like at scale.

China Blocks Meta’s $2B Manus Deal as AI Decoupling Accelerates

Estimated read time: 6 min

Shifting from individual practice to the geopolitical layer, China has blocked Meta’s reported $2 billion acquisition of AI agent startup Manus, showing how quickly U.S. and Chinese AI ecosystems are decoupling. Chinese founders now face a bind: stay home and lose U.S. capital, or redomicile and invite Beijing’s scrutiny.

Heads up: Factor geopolitical risk into AI vendor decisions, because the tools and talent you rely on are increasingly shaped by export controls and investment bans.

That’s the week. The shared thread across these pieces is small but durable: the engineer’s craft is moving from writing code to training the agent that writes it. May the harness be with you 😉, and see you next Monday.

I built Tilth as a workbench: a ~600-line Python agent harness that runs autonomously against any OpenAI-compatible endpoint. I wanted my own mechanism for actually doing work with open-weights models, not just chatting with them, and I wanted to internalize the current thinking on long-running agents while I did it. Addy Osmani’s trilogy on long-running agents is a great treatment of that thinking; read it, it’s what nudged me to build this. This post is a check-in on what I learned doing it.

The architecture, distilled

Three components, independently replaceable:

• Brain. A thin wrapper around the openai SDK pointed at any OpenAI-compatible base URL. Worker and judge can sit on different providers.

• Hands. A per-session git worktree, bash + file tools, allow-listed.

• Session. An append-only events.jsonl plus a checkpoint, enough to wake(session_id) on a fresh process.

Four memory channels live outside the agent so context resets don’t lose state: AGENTS.md for learned conventions, git history for atomic commits per task, progress.txt as a chronological journal, prd.json as the task list with status flags. Each is a different shape of memory; drop any one and something useful collapses.

A separate judge call evaluates each finished task in a fresh context: diff plus acceptance criteria, nothing else. The adversarial split is load-bearing: don’t let the same session implement and judge. Workers grading their own work wave too much of it through. A different prompt with a clean window is the minimum; a different model family is better.

What I actually learned running it

The judge was the best lens into the worker. Watching the worker chew through a task and then watching a fresh-context judge push back on the result, with no chain-of-thought, no tool history, just the diff, was the most enlightening signal I got. My first judge prompt was too harsh and rejecting reasonable work; tuning it was almost entirely prompt work, no code changes. That felt right. The harness shouldn’t need a redeploy to recalibrate taste.

Open weights are cheap enough not to think about. After multiple end-to-end runs I’d burned five cents on OpenRouter. That’s the cost regime where you stop optimizing prompts for token count and start optimizing for the things you actually care about: clarity, recoverability, watchability.

The provider stops mattering. I started against the native Ollama SDK, then noticed Ollama Cloud also exposes an OpenAI-compatible API endpoint so does basically every other provider. About 60 lines of changes later, the same harness works against Ollama Cloud, OpenRouter, Together, Groq, vLLM, LM Studio, and many more. Worker on one provider, judge on another, different env vars, no other changes. The interesting use isn’t cost. It’s independence. Different model families catch different failure modes; Cursor reported that Opus tended to declare itself done early on extended autonomous runs while GPT held out longer. The same harness lets you put one in the worker seat and the other in the judge seat without rewriting anything.

If you’ve been waiting for a better moment to actually evaluate open-weights models against your own work, this is what cheap-enough looks like. The workbench fits in ~600 lines and a worktree on your laptop.

What this isn’t

Not a managed platform. Not a fleet. Not a multi-agent system. One Ralph loop, a worktree, four files, two hooks, a judge. Some Python glue code.

It’s also not done. This is the kind of thing I expect to keep evolving as a way to poke at open-weights models with something more substantive than a chat window. If that turns out to be useful to anyone else, great. The project’s first job is to be my workbench. The repo is at AlteredCraft/tilth; a ready-to-run example workspace lives at tilth-demo-todo-cli.

Welcome to Altered Craft’s weekly AI review for developers, and thanks for spending part of your Monday with us. One thread runs through this edition: the engineering leverage in AI keeps moving outward, away from the model itself and into the harness wrapped around it. A source-level read of Claude Code finds 98.4% of the codebase isn’t AI, Anthropic’s own postmortem ties a month of regressions to small infra changes, and pieces on AGENTS.md, skills, evals, and multi-agent patterns all push the same direction.

TUTORIALS & CASE STUDIES

What Actually Makes an AGENTS.md File Work

Estimated read time: 9 min

Augment Code measured dozens of AGENTS.md files and found a quality gap equivalent to upgrading from Haiku to Opus. Progressive disclosure, decision tables, and pairing every “don’t” with a “do” win. Sprawling overviews and warning-heavy docs trigger context rot.

The takeaway: Keep AGENTS.md to 100-150 lines of focused guidance with reference files loaded on demand, and pair every prohibition with a concrete alternative.

Skillify: Turning Agent Failures Into Permanent Fixes

Estimated read time: 11 min

Taking agent reliability further, Garry Tan argues most AI agent reliability work is “vibes-based” prompt tweaking that decays under complexity. His answer: skillify, a 10-step practice that promotes every failure into durable infrastructure with deterministic scripts, tests, LLM evals, and resolver routing audits.

Why this matters: When your agent fails, don’t apologize-prompt it; turn the failure into a skill with deterministic code and tests so the bug becomes structurally impossible to repeat.

The AI Evaluation Stack: Beyond Vibe Checks for Production LLMs

Estimated read time: 10 min

Moving from preventing failures to detecting them, Microsoft’s Derah Onuorah lays out a two-layer evaluation architecture for enterprise LLMs: deterministic schema asserts first, LLM-as-a-Judge second. The piece details offline golden datasets and online telemetry tracking refusal rates, retries, and apology patterns to catch silent model drift.

What this enables: Treat evaluation as a CI/CD-gated pipeline with fail-fast deterministic checks before expensive semantic scoring, then instrument production for the behavioral signals that reveal silent drift.

The Over-Editing Problem: When AI Coding Tools Rewrite Too Much

Estimated read time: 9 min

Drilling into a specific failure mode evaluation should catch, this investigation measures how often frontier LLMs rewrite more than a bug fix requires, a brown-field failure invisible to test suites. Benchmarking 9 models, the author finds reasoning modes amplify over-editing, but explicit prompting and targeted fine-tuning yield faithful, minimal edits.

Worth trying: Adding “preserve the original code as much as possible” to your prompt measurably shrinks AI-generated diffs and often improves correctness too.

Using a Local LLM as a Zero-Shot Classifier

Estimated read time: 9 min

Stepping outside coding workflows, when clustering fails on short, paraphrase-heavy text, a locally hosted LLM steps in as a zero-shot classifier that understands meaning. The author walks through an Ollama pipeline that turns thousands of free-text annotations into a clean taxonomy without labels.

The opportunity: When you have domain knowledge but no labels, define categories upfront and let a local LLM handle the classification without a training cycle.

TOOLS

GPT-5.5 Lands: Agentic Coding, Computer Use, and Research Workflows Level Up

Estimated read time: 9 min

OpenAI releases GPT-5.5 as a step toward agentic work that plans, uses tools, and persists through ambiguity. It hits 82.7% on Terminal-Bench 2.0, 78.7% on OSWorld-Verified, and uses fewer tokens than GPT-5.4 while matching its latency.

What’s interesting: For engineers delegating multi-step work to agents, GPT-5.5’s token efficiency and long-horizon focus are worth testing against your current Codex and Cursor workflows.

Kimi K2.6: Open-Source Model Ships with Agent Swarms and Long-Horizon Coding

Estimated read time: 12 min

On the open-source side of that release wave, Moonshot AI ships Kimi K2.6, featuring agent swarms scaling to 300 sub-agents across 4,000 coordinated steps. It sustains 12+ hour autonomous coding sessions and benchmarks competitively against GPT-5.4, Claude Opus 4.6, and Gemini 3.1 Pro on agentic tasks.

Worth evaluating: If you’re building agentic coding workflows, K2.6’s open-source availability and competitive benchmarks against frontier closed-source models make it a real option for long-running autonomous tasks.

DeepSeek-V4 Lands With 1M Context as Default

Estimated read time: 3 min

Continuing the open-weights momentum, DeepSeek released V4-Pro and V4-Flash, with 1M context now standard across all services. The release introduces DeepSeek Sparse Attention for efficiency, claims SOTA on agentic coding among open models, and supports both OpenAI and Anthropic API formats.

Worth noting: With OpenAI and Anthropic API compatibility, V4-Flash slots in as a lower-cost drop-in alternative worth benchmarking against your current provider on real workloads.

Gemini Embedding 2 Hits General Availability with Native Multimodal Support

Estimated read time: 1 min

Shifting from generation to retrieval, Google announces general availability of Gemini Embedding 2 via the Gemini API and Vertex AI. The model produces native embeddings across text, image, video, and audio, eliminating fragmented pipelines multimodal search previously required. Preview-phase prototypes can now move to production.

Why now: If you’ve been waiting to ship multimodal search or retrieval features, Gemini Embedding 2 is now production-ready on both the Gemini API and Vertex AI.

NEWS & EDITORIALS

Inside Claude Code: 98.4% of the Codebase Isn’t AI

Estimated read time: 18 min

A source-level analysis of Claude Code’s ~512K lines reveals only 1.6% is AI decision logic. The rest is deterministic infrastructure: permission gates, context compaction, and recovery systems. The repo maps seven safety layers with shared failure modes and distills findings into actionable agent-building guidance.

Where to invest: If you’re building AI agents, put your engineering effort into the harness — permission systems, context management, and recovery logic — not the model loop itself.

Anthropic’s Postmortem on Claude Code Degradation

Estimated read time: 9 min

Following our coverage of the Claude Code degradation debate[1] last week, Anthropic’s postmortem now traces a month of regressions to three overlapping changes in reasoning defaults, cache eviction, and system prompts. The issues compounded across traffic slices, evading internal evals, tests, and dogfooding until user reports surfaced them.

Key point: When AI-coding tools start feeling “off,” trust the pattern in user reports, since small prompt and caching tweaks can quietly erode quality in ways evals miss.

[1] Claude Probably Wasn’t Secretly Nerfed — But the Product Changed Anyway

Five Coordination Patterns for Multi-Agent Systems

Estimated read time: 12 min

Zooming out from a single agent harness to multi-agent design, Anthropic breaks down five multi-agent coordination patterns, examining where each shines and where each breaks. The piece argues for starting with the simplest pattern that could work and evolving as constraints appear, rather than reaching for sophistication teams mistake for real capability.

The decision rule: Choose your multi-agent pattern based on context boundaries and information flow, not on what sounds impressive in a design doc.

The Hidden Cost Curve Behind AI Agent Progress

Estimated read time: 9 min

Zooming further out to the economics of running these systems, Toby Ord examines METR’s time-horizon benchmarks and asks a question few are: how is the hourly cost of AI agents changing over time? Analyzing performance-versus-cost curves, he finds hourly costs rising exponentially, with frontier models approaching human engineer rates.

The context: Headline AI capability trends may overstate practical progress, so plan deployments around sweet-spot costs on the curve, not peak frontier performance.