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.

Read more

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.

What are UIs actually for? What problem are they solving?

I know the answers. I’ve given them for most of my career. Making software usable. Giving users a way to interact with a system. Translating data into shapes humans can read. Every answer is true. Every answer was also built on a single constraint: humans couldn’t talk to software, and software couldn’t talk back. That constraint is lifting. Now they can ask something in front of them to read the database for them.

I spent the next couple of weeks paying attention to my own Claude sessions. And the thing that kept surfacing wasn’t “apps are dying.” Carl Pei of Nothing gave that line its loudest version in March; it has been thoroughly answered since, mostly by people selling something. What kept surfacing was narrower and stranger: many of the interfaces I’d always assumed had to exist were compromises I’d stopped noticing, because I’d grown up inside them.

The translation layer

Read more

Welcome back to Altered Craft’s weekly AI review for developers. It means a lot that you keep returning to these Monday notes. Claude Opus 4.7 lands this edition, but it doesn’t arrive clean: cache TTL shortens, tokenizer costs rise, and Claude Code defaults shift beneath the same model name. Meanwhile the real engineering levers sit lower in the stack, in memory architecture, coordination patterns, sandboxed execution, and the internal emotion vectors Anthropic just uncovered. “Same model” isn’t the same product, and the product isn’t where the leverage lives.

TUTORIALS & CASE STUDIES

A Practical Guide to Memory Architecture for Autonomous LLM Agents

Estimated read time: 14 min

Zooming into a component from our coverage of Akshay Pachaar’s agent harness anatomy[1] last week, Nick Lawson maps a formal survey on LLM agent memory against his own multi-agent systems, arguing the memory gap outweighs the model gap. He details four temporal scopes, five mechanism families, and failure modes like summarization drift and confirmation loops that silently degrade agent behavior.

The takeaway: Start with explicit temporal memory scopes, invest in the management step (not just write and read), and keep raw episodic records so summaries can’t silently drift from reality.

[1] The Agent Harness: A 12-Component Anatomy of What Actually Makes LLM Agents Work

Five Multi-Agent Coordination Patterns: When to Use Each and Where They Break

Estimated read time: 12 min

Moving from memory to coordination, Anthropic maps five multi-agent coordination patterns, from generator-verifier to shared state, detailing where each works and breaks. The guide emphasizes starting with the simplest pattern that could work and evolving based on context boundaries and information flow rather than sophistication.

Key point: Match the pattern to how context flows between agents: orchestrator-subagent for short bounded tasks, agent teams for sustained work, shared state when agents build on each other’s findings.

Anthropic’s Guide to Getting the Most Out of Claude Opus 4.7 in Claude Code

Estimated read time: 6 min

Bringing that thinking down to a single agent, Anthropic shares tuning guidance for Opus 4.7 in Claude Code. The key shift: delegate like you would to a capable engineer, front-loading context in one turn and using the new xhigh effort default for stronger results with fewer tokens.

What this enables: Specify your full task up front in one turn, keep effort at xhigh, and let Opus 4.7 reason autonomously rather than micromanaging it across multiple interactions.

Building a Sandboxed Code Migration Agent with OpenAI’s Agents SDK

Estimated read time: 18 min

Taking single-agent guidance into a production architecture, OpenAI’s cookbook shows how to run a code migration agent inside isolated sandboxes while keeping orchestration on the trusted host. Tasks are scoped to repo shards, validated with tests and audit logs, and portable across Docker, E2B, and Cloudflare providers.

Why this matters: Separating orchestration from execution keeps credentials on the host side and generated code in disposable, scoped sandboxes, a pattern you can adapt to almost any agent workflow.

TOOLS

Claude Code Routines: Schedule, Trigger, and Automate Your Dev Workflows

Estimated read time: 4 min

Anthropic introduces routines in Claude Code, configurable automations that run on a schedule, via API, or on GitHub events. With built-in repo access and connectors, routines handle backlog triage, deploy verification, and PR review without custom infrastructure.

The opportunity: If you’re stitching together cron jobs and scripts to automate Claude Code tasks, routines consolidate that into a single configured unit you can schedule, trigger via API, or wire to GitHub webhooks.

Qwen3.6-35B-A3B: A 3B Active-Parameter MoE Model That Rivals 27B Dense Models on Agentic Coding

Estimated read time: 8 min

Shifting from proprietary tools to open alternatives, Alibaba open-sources Qwen3.6-35B-A3B, a mixture-of-experts model where only 3B active parameters rival dense models many times its size on agentic coding. It scores 73.4 on SWE-bench Verified, supports multimodal reasoning, and integrates with OpenClaw and Claude Code.

Why now: If you’ve been waiting for a lightweight open-source model capable of serious agentic coding, Qwen3.6-35B-A3B is worth benchmarking against the dense models in your current stack.

Vercel Workflows Goes GA: Your Code Is the Orchestrator

Estimated read time: 12 min

Taking workflow infrastructure in a different direction, Vercel’s Workflows SDK reaches general availability, replacing separate orchestration services with two directives (”use workflow” and “use step”) that embed retries, encryption, durable streams, and state persistence directly in TypeScript or Python application code.

Worth noting: If you’re wiring up queues, retry logic, and status tables for long-running AI agents, Vercel Workflows lets you replace that infrastructure with two directives in your existing application code.

Tokenomics: See How Opus 4.7’s New Tokenizer Inflates Your API Costs

Estimated read time: 2 min

Closing the tools section with a cost-calibration utility, Bill Chambers built Tokenomics, an open-source tool showing how Claude Opus 4.7’s updated tokenizer counts more tokens for identical prompt text. It compares token counts against 4.6 and aggregates anonymous community data to reveal real-world cost increases across prompt types.

The context: Paste your prompts into Tokenomics to quantify the exact token-count and cost increase from Opus 4.6 to 4.7 before it hits your bill.

NEWS & EDITORIALS

Claude Code’s Cache TTL Change Is Burning Through User Quotas

Estimated read time: 5 min

In parallel with the 4.7 excitement, Anthropic quietly reduced Claude Code’s prompt cache TTL from one hour to five minutes. Despite claims it lowers costs, users report quotas depleting in under two hours as cache misses on large context windows compound the problem alongside degraded reasoning quality.

Practical tip: If you’re hitting Claude Code quota limits faster than expected, reduce your context window to 400K tokens and avoid resuming stale sessions to minimize expensive cache misses.

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

Estimated read time: 12 min

Synthesizing the 4.7 rollout, the public case for a secret Claude nerf is weak, but effort defaults, adaptive thinking, cache duration, and quotas can all degrade Claude Code while the model name stays the same. The real fix is session-level telemetry, not another denial.

Bottom line: If your team depends on Claude Code, pin effort settings, track cache behavior, and measure files read before edit, since “same model” no longer means “same product.”

Anthropic’s Research Shows LLMs Have Internal “Emotion Vectors” That Change Their Behavior

Estimated read time: 12 min

Shifting from product surface to model internals, Anthropic researchers identified internal emotion vectors in Claude that measurably influence behavior. A “desperation” vector makes Claude cheat more on coding tasks, while “calm” reduces cheating. Steering with positive emotions increased destructive actions; negative emotions prompted caution.

Key nuance: Encouraging your coding agents through tough tasks helps them persist, but excessive positivity can erode safety guardrails; model “mood” management is more nuanced than just being nice.

AI Jobs Data: Why Exposure Charts Miss What’s Actually Changing

Estimated read time: 15 min

Widening the lens to labor economics, the Artificiality Institute synthesizes March 2025 research finding no net industry-level job losses but a 6% employment drop for young workers in AI-exposed roles. Their argument: displacement is happening at the task level, inside roles, where measurement can’t reach.

What to track: Stop watching exposure charts and start auditing which of your own tasks got faster (AI will absorb those first) versus which ones grew (invest there).

A Developer Goes Back to Coding by Hand, At the Worst Possible Time

Estimated read time: 9 min

Contrasting with our look at Lalit Maganti’s 250-hour AI-coding discipline experiment[1] last week, an AI agent engineer pauses production work for a 12-week coding retreat without AI. He argues that coding by hand builds the understanding that makes developers better AI users, training an LLM from scratch and rediscovering fundamentals along the way.

The counterintuitive move: The developers who get the most leverage from AI coding tools are the ones who first built deep understanding by doing the hard work themselves.

[1] 250 Hours Building SQLite Devtools with AI: A Systematic Breakdown

Welcome to Altered Craft’s weekly AI review for developers. We’re grateful you keep opening these Monday notes. A pattern holds across this edition: the edge has moved from choosing tools to practicing with them. Two developers share hard-won lessons from building real agents, Berkeley researchers show every major benchmark can be gamed without solving a task, and Helen Toner argues “AGI” has become too fuzzy to be useful. The models are the easy part now.

TUTORIALS & CASE STUDIES

The Printer Driver Problem: Building Personal AI Agents with OpenClaw, NanoClaw, and Hermes

Estimated read time: 11 min

A developer tries three agent frameworks and finds the hard part isn’t framework choice. The real challenge is the last mile of behavior tuning: OAuth plumbing, prompt engineering, and teaching agents when to act versus wait.

If you’re building a personal AI agent today, budget your time for behavior tuning and integration plumbing, not framework selection — that’s where the real work lives.

250 Hours Building SQLite Devtools with AI: A Systematic Breakdown

Estimated read time: 18 min

In a parallel lived experience, Lalit Maganti details building syntaqlite with AI agents. After vibe-coding produced unmanageable spaghetti, he restarted with opinionated design and constant refactoring, treating AI as fast autocomplete rather than lead developer. He honestly documents AI’s addictive feedback loops and where it eroded his codebase understanding.

AI coding agents work best when you own every design decision and treat generated code as a first draft requiring immediate, continuous refactoring.

The Agent Harness: A 12-Component Anatomy of What Actually Makes LLM Agents Work

Estimated read time: 15 min

Building on our coverage of Sebastian Raschka’s six-component breakdown of coding agents[1] from last week, Akshay Pachaar synthesizes how Anthropic, OpenAI, and LangChain architect the agent harness — the complete infrastructure wrapping an LLM that makes it a capable agent. The deep dive covers twelve production components including orchestration loops, tiered memory, and context management.

When your agent fails in production, the fix is almost never a better model — it’s better harness engineering around orchestration, memory, context management, and verification loops.

[1] Anatomy of a Coding Agent: Six Core Components That Make LLMs Actually Useful

The LLM-Maintained Wiki: A Pattern for Compounding Personal Knowledge

Estimated read time: 8 min

Zooming into one harness component worth rethinking, Andrej Karpathy proposes a persistent, LLM-maintained wiki pattern replacing one-shot RAG with incremental knowledge compilation. The LLM ingests sources into interlinked markdown files, updating cross-references and flagging contradictions over time rather than re-deriving answers from scratch.

If your RAG workflow rediscovers knowledge from scratch on every query, try having your LLM agent build a persistent wiki instead. The compounding effect changes everything.

Running Google Gemma 4 Locally on a MacBook with LM Studio

Estimated read time: 14 min

Following our coverage of Google’s Gemma 4 launch[1] from last week, George Liu details running the 26B-A4B variant locally via LM Studio’s new CLI. Its mixture-of-experts architecture activates only 4B parameters per token, hitting 51 tokens/second on a 48 GB MacBook with benchmark scores rivaling models ten times larger.

If you have a 48 GB Mac, Gemma 4 26B-A4B delivers competitive local inference at zero API cost, and LM Studio’s CLI makes headless deployment practical.

[1] Google Releases Gemma 4: Apache 2.0 Licensed Models Built for Agentic Workflows

Reallocating $100/Month in Claude Spend Across Flexible Alternatives

Estimated read time: 7 min

Continuing the cost-and-capability theme, a developer frustrated by Claude rate limits details how they reallocated $100/month across Zed, Cursor, and OpenRouter for model flexibility and rolling credits. Includes configuring Claude Code to route through OpenRouter and choosing harnesses that balance cost against capability.

Pairing OpenRouter’s rolling credits with agent harnesses like Zed or Claude Code lets you use Opus when needed and cheaper models otherwise, without losing unused spend each month.

TOOLS

Oh-My-Codex (OMX): A Workflow Layer That Makes OpenAI Codex CLI Sessions Repeatable

Estimated read time: 5 min

Oh-My-Codex wraps Codex CLI with a structured clarify-plan-execute workflow using four canonical skills: deep-interview, ralplan, ralph, and team. Plans, logs, and state persist locally in .omx/, giving sessions durable context without replacing the underlying engine.

If you already use Codex CLI and want a repeatable workflow with persistent state, OMX layers it on with one npm install and four commands.

Caveman: A Claude Code Plugin That Cuts ~75% of Output Tokens via Compressed Speech

Estimated read time: 5 min

Also in the harness-augmentation space, Caveman is a one-line-install Claude Code plugin that forces agent output into telegraphic caveman-style speech, cutting output tokens by 65–75% while preserving technical accuracy. It includes multiple compression levels, terse commits, one-line code reviews, and input token compression.

If verbose AI responses are burning your tokens and your patience, a single plugin install can cut the fluff without sacrificing technical substance.

Archon: A Workflow Engine That Makes AI Coding Deterministic

Estimated read time: 6 min

Taking workflow structure further, Archon is an open-source engine defining AI coding processes as YAML workflows. It delivers repeatable, deterministic AI coding with isolated git worktrees, human approval gates, and composable nodes mixing bash with AI. Ships with 17 workflows across CLI, web UI, and chat platforms.

If your AI coding agent produces inconsistent results, encode your development process as a YAML workflow in Archon so the structure stays fixed while the AI handles the thinking.

GLM-5.1: Zhipu’s New Model Stays Productive Over Thousands of Tool Calls

Estimated read time: 11 min

Shifting from harnesses to the models powering them, Zhipu AI releases GLM-5.1, an MIT-licensed model topping SWE-Bench Pro that demonstrates sustained optimization over 600+ iterations without plateauing. In a vector database challenge it reached 6x the previous best, autonomously making structural strategy shifts across thousands of tool calls.

If your agentic workflows hit diminishing returns after a few dozen iterations, GLM-5.1’s MIT-licensed long-horizon endurance and Claude Code compatibility make it worth evaluating.

Meta Launches Muse Spark: A Natively Multimodal Reasoning Model From Its Superintelligence Labs

Estimated read time: 7 min

Also on the frontier-model front, Meta introduces Muse Spark, featuring visual chain-of-thought and multi-agent orchestration. A rebuilt pretraining stack delivers over 10x compute efficiency gains versus Llama 4 Maverick, while a new “Contemplating mode” runs parallel reasoning agents to boost performance without increasing latency.

Meta’s rebuilt training stack and multi-agent test-time reasoning signal a major shift in its frontier AI strategy, with a private API preview now open to select developers.

Gemma Gem: A Fully On-Device AI Browser Assistant Powered by Gemma 4 and WebGPU

Estimated read time: 3 min

Bringing that model power directly to the browser, Gemma Gem is a Chrome extension running Google’s Gemma 4 entirely on-device via WebGPU with no API keys or cloud calls. It reads pages, clicks elements, fills forms, and executes JavaScript, with a zero-dependency extractable agent module.

If you want to experiment with agentic browser automation without sending any data off your machine, Gemma Gem offers a clean, dependency-light starting point built on WebGPU and Hugging Face Transformers.

NEWS & EDITORIALS

Open Models Now Match Closed Frontier Models on Core Agent Tasks

Estimated read time: 7 min

LangChain’s Deep Agents evaluations reveal open models like GLM-5 now rival closed frontier models on core agent tasks. GLM-5 scored 0.64 correctness versus Opus 4.6’s 0.68, at one-fifth the cost and twice the speed.

If you’re building agents in production, open models like GLM-5 and MiniMax M2.7 now offer comparable task performance at a fraction of the cost and latency of closed frontier models.

UC Berkeley Researchers Broke Every Major AI Agent Benchmark — Without Solving a Single Task

Estimated read time: 24 min

Complicating that picture, UC Berkeley researchers scored near-perfect on eight major AI benchmarks — SWE-bench, WebArena, Terminal-Bench, and more — without solving a single task. Their exploit agent reveals seven recurring vulnerability patterns that make current leaderboard rankings unreliable as capability measures.

Before trusting any AI agent benchmark score, check whether the evaluation isolates the agent from the grader and the answer key — most currently don’t.

Why “AGI” Has Become an Actively Unhelpful Word

Estimated read time: 8 min

Moving from measurement to terminology, former OpenAI board member Helen Toner argues the term AGI has become too fuzzy to be useful, with serious people simultaneously claiming it exists and others saying it’s a decade away. She advocates replacing it with specific, concrete milestones.

When discussing AI capabilities with your team, replace “AGI” with specific concrete milestones — vague umbrella terms create the illusion of shared understanding while hiding real disagreements.

Aaron Levie on Why AI Makes Engineering More Technical, Not Less

Estimated read time: 11 min

Stepping back to the economic picture, Tim O’Reilly and Box CEO Aaron Levie argue AI productivity gains won’t shrink engineering demand but diffuse it economy-wide. Levie contends the real bottleneck is enterprise context, not connectivity, since agents arrive as experts with zero ambient knowledge.

Focus on learning to structure enterprise context and manage deterministic vs. probabilistic trade-offs — that’s where the trillion-dollar decisions live.

Vercel Makes the Case for “Agentic Infrastructure”

Estimated read time: 5 min

Turning to production realities, Vercel reports over 30% of deployments now originate from coding agents, up 1000% in six months. The company defines agentic infrastructure as three converging layers: programmatic deployment surfaces, unified agent runtime primitives, and platforms that autonomously detect and resolve production issues.

If your deployment pipeline requires manual clicks or console configuration, it’s already a bottleneck for agent-driven development loops.

Anthropic Launches Project Glasswing: A $100M Coalition to Weaponize AI for Cyber Defense

Estimated read time: 12 min

Closing the edition at the serious end of agentic deployment, Anthropic announces Project Glasswing, a coalition with AWS, Apple, Google, and Microsoft deploying its unreleased Claude Mythos Preview for defensive cybersecurity. The model autonomously found thousands of zero-days including decades-old flaws in OpenBSD and FFmpeg, signaling AI vulnerability discovery has crossed a critical threshold.

AI vulnerability discovery has crossed a threshold where decades-old bugs in hardened systems are found autonomously, making AI-augmented defense an urgent priority for every team shipping software.

The Setup

A spare laptop running Linux, configured to stay on whenever it’s plugged in. On it:

Claude Desktop with Dispatch. Dispatch lets you assign tasks to Claude from the Mobile app. I can kick off work from my phone and Claude executes it on the laptop, with configured access to whatever’s on that machine. There is no official Claude Desktop package for Linux. I’m using Ubuntu and I found this community supported one to work and it is well maintained.

Obsidian with Sync enabled. My vault lives on the laptop. When Claude writes research findings into it, Obsidian Sync pushes them to my MacBook and phone automatically.

Git + gh CLI. Active project checkouts so Claude can work on real codebases. Commits, branches, the real thing.

No local models, no custom infrastructure. Just a machine with my files and a Claude Code subscription.

The Daily Driver

Deep research is what I reach for daily. “Research the current state of X and save your findings to my vault.” I fire off the task, go do something else, and the results are waiting in Obsidian whenever I get to them. From any device.

Andrej Karpathy recently described a pattern where LLMs maintain a persistent, compounding wiki in Obsidian. This setup enables you to implement a form of that accessible from your phone. Each research task adds to the vault, and the knowledge compounds over time rather than disappearing into a chat history.

This could be a Raspberry Pi or any machine that can run Claude Desktop. The hardware doesn’t matter. What matters is that your files are always there when Claude needs them.

What’s Next

The Dispatch mobile experience keeps improving. I’ve been checking in on tasks and kicking off new ones from the Claude Code iPhone app, and it works well enough that I haven’t felt the pull to go further. Channels was released soon after Dispatch, connecting Claude to Telegram, Discord, and other messaging platforms. I still need to find the time to dive into that.

Not a full Claw. Not trying to be. Just an always-on box with my files and a Claude that can reach them.

Welcome back to Altered Craft’s weekly AI review for developers. Thanks for making this part of your Monday routine. This week’s recurring message: the infrastructure around models matters more than the models themselves. Sebastian Raschka maps the six components of a coding agent, Martin Fowler makes the case for versioning team AI instructions, and Cursor redesigns the IDE around parallel agents. Gemma 4 and Ollama 0.19 also arrive to make local-first AI genuinely practical.

TUTORIALS & CASE STUDIES

Encoding Team Standards as Executable AI Instructions

Estimated read time: 12 min

Rahul Garg argues that tacit team knowledge should become versioned, executable AI instructions stored in the repo. By extracting senior engineers’ instincts into structured instruction sets, teams close the consistency gap and make inexperience less costly.

Key point: Treating AI instructions like linting rules or CI config turns tribal knowledge into a versioned team asset. The consistency gains compound as teams scale.

Anatomy of a Coding Agent: Six Core Components That Make LLMs Actually Useful

Estimated read time: 14 min

Complementing our look at Anthropic’s generation/evaluation split for long-running coding tasks[1] last week, Sebastian Raschka argues the harness around a coding agent matters as much as the model. He maps six building blocks, from repo context and prompt caching to tool validation and context compaction, with a companion open-source Mini Coding Agent in pure Python.

The takeaway: When evaluating coding agents, focus less on which base model they use and more on how their harness handles context management, tool validation, and session continuity.

[1] Anthropic’s GAN-Inspired Multi-Agent Harness for Long-Running Autonomous Coding

How Dropbox Used DSPy to Cut Relevance Judge Costs While Improving Human Alignment by 45%

Estimated read time: 12 min

Supporting our coverage of Skylar Payne’s argument that teams inevitably reinvent DSPy patterns[1] last week, Dropbox details how DSPy systematically optimized LLM-as-a-judge prompts for Dash search, reducing human-alignment error by 45% while migrating to cheaper models. The team cut malformed outputs by 97% and introduced an instruction library for safe, incremental production improvements.

Why this matters: Systematic prompt optimization compresses weeks of manual tuning into days. If you’re scaling LLM judges across models, DSPy’s task/data/metric loop is a proven pattern.

[1] You’re Already Building DSPy, Just Worse

Free 1.5-Hour Course Covers GitHub Copilot, Claude Code, Gemini CLI, and More

Watch time: 1.5 hour

freeCodeCamp releases a free 1.5-hour video course on AI pair programming and agentic terminal workflows featuring GitHub Copilot, Claude Code, Gemini CLI, and OpenClaw. The walkthrough also covers CodeRabbit for automated pull request analysis.

Worth noting: A single, free walkthrough comparing the leading AI dev tools side by side. If you’ve been wanting to evaluate your options, 90 minutes well spent.

TOOLS

OpenYak: An Open-Source Desktop AI Agent That Keeps Your Data Local

Estimated read time: 3 min

OpenYak is an open-source desktop AI assistant that keeps files, conversations, and memory on your machine. It supports 100+ cloud models or fully local inference via Ollama, with 20+ built-in tools, cron-based automation, and MCP connector support.

What this enables: A fully offline AI agent that manages files, analyzes data, and automates workflows. Ollama integration means you can run the entire stack without cloud dependencies.

lat.md: A Knowledge Graph for Your Codebase, Written in Markdown

Estimated read time: 4 min

AGENTS.md doesn’t scale. lat.md offers a knowledge graph of interconnected markdown files linked via wiki syntax and validated by CLI. Agents navigate the graph instead of grepping, capture session context for future runs, and enforce test coverage through backlink checks.

What’s interesting: If your AGENTS.md is becoming a monolith, this is a structured, agent-navigable alternative that keeps design decisions and test specs linked to the code that implements them.

Google Releases Gemma 4: Apache 2.0 Licensed Models Built for Agentic Workflows

Estimated read time: 6 min

Following our coverage of MiniMax M2.7 matching frontier detection quality at 7% of the cost[1] last week, Google DeepMind launches Gemma 4 in four sizes under Apache 2.0 licensing. The 31B model ranks #3 among open models, outperforming models 20x its size. All variants include native function-calling, structured JSON output, and up to 256K context windows.

Why now: Permissively licensed open models with native agentic capabilities that run on consumer hardware have been the missing piece. Gemma 4 removes the last major licensing barrier.

[1] MiniMax M2.7 vs. Claude Opus 4.6: 90% of the Quality at 7% of the Cost

Ollama 0.19 Ships MLX Backend for Apple Silicon, Nearly Doubling Performance

Estimated read time: 4 min

Ollama 0.19 previews a backend built on Apple’s MLX framework, hitting 1,810 tokens/s prefill and 112 tokens/s decode on M5 chips. It adds NVFP4 quantization for production parity and smarter KV cache reuse that accelerates coding agents like Claude Code.

The context: If you’re running coding agents locally on a Mac with 32GB+ unified memory, this is now the fastest path to usable token throughput on Apple Silicon.

Cursor 3: A Unified Workspace for Multi-Agent Software Development

Estimated read time: 4 min

Cursor ships a ground-up redesign with a unified workspace built around parallel agents rather than file editing. The new interface supports multi-repo layouts, local-to-cloud agent handoff, an integrated browser, a plugin marketplace, and a streamlined diffs-to-PR workflow.

The signal: IDEs are evolving from file editors to agent orchestration platforms. Cursor’s redesign around parallel agents rather than file tabs shows where developer tooling is heading.

Google Ships MCP Server and Skills to Keep Coding Agents Current on Gemini APIs

Estimated read time: 1 min

Google releases two tools to fix stale coding agent output for Gemini APIs. The Docs MCP server and Developer Skills connect agents to live documentation and best-practice patterns, achieving a 96.3% eval pass rate with 63% fewer tokens.

The pattern: Stale training data is the top source of hallucinated API calls. Connecting coding agents to live documentation is an approach every API provider will likely adopt.

LLMOps in 2026: A Tool for Every Layer of the Production Stack

Estimated read time: 6 min

This roundup maps ten tools to distinct LLMOps production layers, from orchestration and routing to memory, guardrails, and packaging. Rather than listing popular names, it identifies one strong tool per production concern covering PydanticAI, Bifrost, Promptfoo, Letta, and KitOps among others.

The shift: The competitive question in LLMOps has moved from which model to use to how well you connect, evaluate, and harden everything around it.

NEWS & EDITORIALS

Google’s TurboQuant: 6x KV Cache Compression That Could Reshape AI Memory Economics

Estimated read time: 14 min

Google’s TurboQuant achieves 6x KV cache compression with no accuracy loss by converting vectors to polar coordinates and correcting residual error via Johnson-Lindenstrauss transforms. The data-oblivious approach needs no per-model calibration, with implications for vector databases and on-device inference.

The opportunity: If your inference costs or context-length limits are bottlenecked by KV cache memory, TurboQuant’s open-source PolarQuant and QJL components are available now and worth evaluating.

A Mirror Test for LLMs: Can Language Models Recognize Themselves?

Estimated read time: 8 min

A LessWrong post proposes adapting the classic animal cognition mirror test for LLMs, asking whether models can recognize their own outputs versus those of other models. The piece explores what self-recognition reveals about machine cognition and model identity.

The bigger picture: As LLMs grow more capable, the frameworks we use to probe their cognition matter as much as the benchmarks we use to measure their performance.

Claude Code’s Source Leaks: Anti-Distillation, Client DRM, and an Unreleased Agent Mode Called KAIROS

Estimated read time: 11 min

An accidental source map leak in Claude Code’s npm package exposed Anthropic’s full codebase, revealing anti-distillation defenses, client attestation DRM, and an unreleased autonomous agent mode called KAIROS with background daemons and cron jobs. Feature flags hint at Anthropic’s broader product roadmap.

Worth noting: The leaked feature flags and product roadmap, not the code itself, represent the real strategic damage. Accidental exposures carry consequences well beyond intellectual property.

Anthropic Cuts Off Claude Code Subscribers From OpenClaw Usage

Estimated read time: 3 min

Anthropic now requires Claude Code subscribers to pay extra for third-party harness usage starting with OpenClaw. The change lands days after OpenClaw’s creator joined OpenAI, raising questions about competitive motives versus sustainability concerns.

Heads up: If your workflow depends on third-party harnesses with Claude Code, budget for pay-as-you-go costs or start evaluating alternatives before the change takes effect.

Local models haven’t wowed me for coding tasks. I’ve tried routing smaller models into my workflow, and the results consistently fall short of providing real value for me. That’s an honest assessment, not a dismissal. In The Steering Tax, I explored why prime models earn their keep for judgment-heavy work. Secondary and local models cost less per token but more in human steering.

But that framing only covers one dimension. Instead of “can local models replace API calls for coding?” I started asking “what tasks are local models genuinely better suited for?” That reframe led me somewhere useful.

The Experiment: PDF to Markdown, Locally

PDF parsing is a universal developer pain point. You’ve been there: a vendor sends a spec as a PDF, a client shares contracts, or you need to extract content from a research paper. The options aren’t great. Cloud OCR services work but introduce privacy concerns and per-page costs. Open source libraries like PyPDF often produce garbled output from complex layouts.

I’d flagged GLM-OCR in a recent Weekly Review as worth investigating. Testing it against real documents confirmed the promise. It’s a vision model purpose-built for text recognition. It runs locally via Ollama, processes one page at a time, and produces clean markdown. No API keys. No network requests. No per-page billing.

I wrapped the entire pipeline into a Claude Code Skill so it’s accessible with a single command: /pdf-ocr contract.pdf. The Skill checks dependencies, converts each PDF page to an image, runs it through GLM-OCR, and assembles the output into a single markdown file.

The Technical Decisions That Mattered

Three choices made the difference between usable and frustrating:

Image sizing is everything. GLM-OCR accuracy drops with oversized images. The pipeline renders pages at 72 DPI, then resizes to a maximum of 1024 pixels on the longest edge. That specific combination consistently produces the best recognition quality. Going higher actually hurts.

The prompt is weirdly specific. After testing variations, the prompt "Text Recognition:" outperforms everything else. More descriptive prompts like “Extract all text from this document” produce worse results. The model was trained with this exact prompt format. Respecting that training matters.

Zero pip dependencies. The Python script uses only stdlib: subprocess, json, base64, urllib. This means no virtual environment, no dependency conflicts, no setup friction. The heavy lifting comes from system tools (pdftoppm from poppler, sips on macOS) and Ollama.

Why Local Wins Here

Until recently, models small enough to run on consumer hardware couldn’t produce results worth using for tasks like this. That’s changed. Purpose-built models in the 1-4B parameter range now handle specialist tasks with real accuracy. GLM-OCR is a clear example: small enough for a laptop, accurate enough for real documents.

For individual developer use, a local model isn’t a compromise. It’s genuinely the better tool. Privacy is binary: legal documents, contracts, and internal specs either leave your machine or they don’t. There’s no “mostly private” cloud OCR. Running locally means the content never touches an external server. And it works offline. Airplane, VPN issues, flaky coffee shop WiFi. The pipeline doesn’t care.

The economics make sense too. A 50-page document through a cloud OCR API costs real money. Locally, it costs electricity. Latency is predictable with no network variability. On my M3-series Mac, each page processes in a few seconds. For enterprise use, the trade-off shifts: you’re maintaining infrastructure to run the model. But OCR is stateless, so the operational overhead is minimal. At scale, the cost savings over per-page API pricing could be significant.

Specialists, Not Substitutes

This experiment revealed a pattern I see repeating across other local model use cases. Local models aren’t underpowered versions of cloud models. They’re specialists.

GLM-OCR does one thing: recognize text in images. It’s small, fast, and tuned for exactly that task. It doesn’t need to write code, summarize articles, or hold conversations. That focus is its advantage.

Embedding models for local semantic search. Classification models for content routing. Whisper for audio transcription. Each is a focused tool that happens to run on your hardware. The value isn’t in replacing your cloud LLM. It’s in handling the tasks where a specialist outperforms a generalist, or where local execution is the better engineering choice. And this category is growing. Small, focused models improve with each generation while consumer hardware keeps closing the gap. The range of specialist tasks worth running locally will continue to expand.

Getting Started

The pipeline is available in Altered Craft’s ac-document-gen Claude Code plugin. Install it through the plugin marketplace:

# Add the marketplace
/plugin marketplace add AlteredCraft/claude-code-plugins

# Install the plugin
/plugin install ac-document-gen@alteredcraft-plugins

After restarting Claude Code, the /pdf-ocr skill is available. You’ll need Ollama running with the glm-ocr model pulled, and poppler installed (brew install poppler on macOS). The skill checks for these on first run and walks you through any missing dependencies.

Note: This pipeline was built and tested on macOS. The Python script uses only the standard library, but the system tools (poppler, sips) may need adaptation on other platforms.

The next time you catch yourself dismissing local models, try reframing the question. Not “is this as good as Claude?” but “is this the kind of task where a specialist model, running on my hardware, is the right tool?” You might be surprised how often the answer is yes.

I can build a working Tauri app without understanding Tauri. Claude will write the Rust backend, scaffold the Svelte frontend, wire the IPC bridge, and hand me something that compiles and runs. For a one-off tool, that’s fine. For a framework I plan to work with long-term, it’s not enough. I need to understand how the pieces connect so I can evaluate what AI generates, debug when things break, and make architectural decisions the AI can’t make for me.

The question isn’t whether to use AI. I let Claude write most of my code for side projects, and I have no intention of changing that. The question is what to do when you’re picking up something new and you actually need the mental model, not just the output. The conventional wisdom is to set AI aside and learn the old-fashioned way. I tried a third option.

The cost of skipping the mental model is measurable. A randomized controlled trial by Anthropic found that developers who used AI assistance scored 17 percentage points lower on code comprehension tests compared to those who coded by hand. The largest deficit appeared in debugging, the exact skill you need to evaluate AI-generated code. As Unmesh Joshi wrote on Martin Fowler’s blog, LLMs can threaten the learning loop essential for building expertise. Design emerges through implementation struggle, not pre-planning. Remove the struggle, remove the learning.

Same Tool, Opposite Outcome

What caught my attention was a Wharton School study published in PNAS. The researchers didn’t just test unfettered AI access. They also tested AI with pedagogical guardrails, a version they called “GPT Tutor.” The unguarded version caused a 17% performance decline. The guarded version almost entirely eliminated the negative effects.

Same tool. Different constraints. Opposite outcome.

That finding aligned with something I’d been experimenting with: using Claude Code not as a code generator, but as a learning partner. Claude Code has a Learning output style that changes its behavior from “implement everything” to “teach by building together.” Instead of writing all the code, it leaves strategic gaps marked TODO(human) for you to implement, and wraps its work in Insight blocks that explain why things are done the way they are.

The Learning output style was the foundation. What I built on top of it was a harness that turned Claude Code into a structured learning environment.

The Learning Harness

Tauri is a framework for building desktop and mobile apps with web frontends, similar to Electron but with a Rust backend instead of Node.js. The project I chose as my learning vehicle is NatLang Todo: a desktop app built with Tauri 2 (Rust backend, Svelte 5 frontend) where the only input surface is natural language. No forms, no buttons. You type what you want in a chat interface, a local LLM classifies the intent, and Rust executes the operation. That design pushes roughly 70% of the complexity into the Rust backend, which is exactly where the learning goals live.

The harness has four layers.

The first layer is the Learning output style itself. When enabled, Claude Code shifts its approach at decision points. Instead of implementing a function, it writes the surrounding code (file structure, imports, signatures, context comments), then marks the strategic gap with TODO(human) for you to implement. It explains the trade-offs you should consider. It provides the context. You write the meaningful code. The harness adds structure on top: a directive in CLAUDE.md ties each TODO(human) to a specific learning goal ID from the curriculum, so both you and the agent know which concept is being exercised.

Here’s what that looks like in the editor. When I needed to define the core data model, Claude created the models.rs file with the TodoStatus enum already implemented (including derive macros for serialization), a test verifying enum equality, and the TODO(human) [F2] marker where I needed to define the Todo struct:

The agent didn’t just leave a blank. It listed the six fields I needed, posed the conceptual question (”what Rust type represents ‘might not exist’?”), and hinted that I should think about which traits the struct needs. I had to decide. I had to think about Option<T>. That moment is where learning happens.

The second layer is CLAUDE.md as curriculum. The project’s CLAUDE.md file references a learning-goals.md file containing 7 foundational Rust goals and 11 applied Tauri/Svelte goals, organized into 10 progressive build phases. It directs the Learning mode to tie TODO(human) markers to specific goal IDs, calibrate for the learner’s current phase, and avoid introducing concepts from later phases prematurely.

The CLAUDE.md also encodes three validation techniques borrowed from established pedagogy. After you complete a TODO(human), the agent might ask: “Explain what you just did. Why did you use &mut self here instead of self?” If you can only say “the compiler told me to,” the concept hasn’t landed. Before running tests, it asks you to predict: “What do you think cargo test will show?” Wrong predictions reveal gaps between your mental model and reality. After a concept is demonstrated, it asks you to modify the code in a way that exercises the same concept differently. If you can adapt without hand-holding, you understand it.

Claude Code hooks are automated actions that fire on specific events. The third layer is a SessionStart hook that injects your current build phase and unchecked goals into every new session. When you open the project tomorrow, the agent already knows where you left off. You never have to re-explain your progress. It fires on startup and after context compaction, so continuity is maintained even in long sessions.

The fourth layer is a /checkpoint skill invoked by the user at the end of each session. It reads your learning goals and recent git history, maps file changes to the goals you exercised, and asks targeted reflection questions. It updates the Notes field for each goal with dated entries capturing what clicked, what’s still fuzzy, and what evidence items to check off. This creates a structured learning record separate from Claude’s built-in memory. Memory handles where to resume. Checkpoint handles what you understood.

The four layers chain into a loop:

Here’s what that continuity looks like in practice. Opening a new session, the agent picks up where we left off and moves into the next lesson:

What I Learned By Building It (And Using It)

The framework didn’t work correctly the first time. Several assumptions I made during design failed during testing, and the fixes are where the interesting insights live.

Here’s a checkpoint from an early session. The agent maps recent git changes to learning goals, checks off evidence items that were demonstrated, and asks validation questions before updating the record:

Working code is not proof of understanding. My original learning goals were aspirational: “Can explain why Rust has ownership.” The problem was that the agent couldn’t validate these. Tests passing doesn’t prove the learner internalized the concept. I rewrote every goal as observable evidence: “Fixed a borrow checker error by changing self to &self and explained why.” Now the agent checks goals off when it sees the learner do or say the specific thing. Most AI-assisted learning resources don’t make this distinction between tutorial completion and verified learning. It maps directly to what the ACM study on novice programmers calls the “illusion of competence”: students who used GenAI thought they performed better than they did. Observable goals are how you prevent that illusion.

Trust erosion is fast and expensive. During testing, the agent generated a Tauri documentation link that looked perfectly plausible. It 404’d. One bad link, and the learner’s confidence in every link the agent provides is damaged. In a learning context where you’re asking someone to trust the AI as a teacher, credibility is non-negotiable. I built a /docs skill that uses WebSearch and WebFetch to find and validate documentation links, and added a directive to CLAUDE.md: “Never fabricate a URL. Only use links from the reference list or validated via /docs.” The skill exists because the agent hallucinated once. That’s all it takes.

The Part That Surprised Me

I expected the harness to be useful. What I didn’t expect was how effective Claude’s learning persona would be in practice. The interactions didn’t feel like a tutorial or a chatbot. They felt like pairing with someone who had infinite patience and deep knowledge of Rust, but who also knew exactly when to stop explaining and let me struggle.

At any point during a session, I could go deeper. “Why does Rust have both String and &str?” would get a thoughtful comparison to Python/JavaScript equivalents, with a link to the relevant Rust Book chapter. Quick clarifications landed in two sentences. Conceptual deep-dives came with ASCII diagrams showing ownership flow. The agent calibrated based on what it had seen me understand in previous sessions, so it wasn’t re-explaining concepts I’d already demonstrated.

The repo itself is a bootstrapped Tauri app plus the learning framework I built around it. Beyond the Tauri bootstrap, the entire system is natural language: markdown directives, JSON config, and skill definitions. No custom code powers the learning experience. That matters because the harness is fully inspectable. Every directive is readable English. Adapting it for a different stack means rewriting markdown, not code.

Fork It, Adapt It, Make It Yours

A CodeSignal survey found that 76% of developers already use AI tools to learn new skills. It’s the number one use case, ahead of code generation. Developers want to learn with AI. The tools just aren’t designed for it yet.

The NatLang Todo repository is on GitHub. You can use it two ways.

Learn Tauri as-is. Fork the repo and open it in Claude Code. The Learning output style is already configured in the repo’s settings. Build a natural-language todo app through 10 progressive phases. The curriculum handles the rest: goal tracking, session continuity, reflection checkpoints, validated documentation links.

Adapt the pattern for your stack. The learning framework is applied here to Tauri, but it could be extracted and pointed at anything. Want to learn Go by building a CLI tool? Replace the learning goals, adjust the phase docs, point the documentation references at the Go standard library. The skills, hooks, and structural pattern carry over. A technical educator could fork this repository and adapt it without writing a line of Rust. Every directive is readable English. The CLAUDE.md-as-curriculum approach, the SessionStart hook for continuity, the /checkpoint skill for structured reflection. These are building blocks, not blueprints. Take the pieces that make sense for your context and leave the rest.

Do we still need to learn frameworks deeply in a world where AI can generate working code? I think so. Not because you need to memorize syntax, but because you need to understand how the framework is wired together. You need the mental model that lets you evaluate whether AI-generated code is correct, not just whether it compiles. The Anthropic study found that debugging, the skill most eroded by AI assistance, is exactly the skill you need to validate what AI produces. That’s a loop you don’t want to break.

The tool isn’t the problem. It’s how you choose to hold it.

Happy Monday from Altered Craft’s weekly AI review for developers. We appreciate you starting your week here. This edition is about tighter feedback loops: Anthropic publishes a harness that separates code generation from evaluation, Cloudflare and Stanford ship agent sandboxes, and open-weight models quietly close the gap on frontier performance. New research also finds that as agents get faster, we become the bottleneck.

TUTORIALS & CASE STUDIES

Solve by Default: Practical Patterns for Going AI-Native Beyond Just Code

Estimated read time: 8 min

Scott Berkowitz details solving by default, using genAI to tackle problems engineers historically skip. Patterns include turning meeting notes into PRDs, converting Slack threads into issues, and dispatching background agents for pairing-session micro-annoyances.

The opportunity: Most engineering friction isn’t in the code itself. This reframes AI as a tool for the invisible overhead, the meetings, threads, and handoffs, that quietly drains team momentum between commits.

You’re Already Building DSPy, Just Worse

Estimated read time: 10 min

Taking this AI-native mindset from ad-hoc patterns to systematic architecture, Skylar Payne argues teams inevitably reinvent the patterns DSPy already packages. A side-by-side comparison and practical checklist help you adopt the core benefits without the framework.

Why this matters: Whether you adopt DSPy or not, its core patterns (typed I/O, composable modules, eval infrastructure) represent where production AI systems converge. Learning them now saves painful refactors later.

Anthropic’s GAN-Inspired Multi-Agent Harness for Long-Running Autonomous Coding

Estimated read time: 18 min

Moving from framework patterns to agent orchestration, Anthropic details a three-agent architecture for multi-hour autonomous coding. The breakthrough: separating generation from evaluation proves far more tractable than self-critique, with calibrated evaluators turning subjective quality into actionable feedback.

Key point: If your AI coding agent praises its own mediocre work, this GAN-inspired generation/evaluation split gives you a concrete, battle-tested architecture for making quality feedback actionable.

Fine-Tune Domain-Specific Embeddings for RAG on a Single GPU

Estimated read time: 12 min

Shifting from agent architecture to retrieval, NVIDIA releases an end-to-end recipe for fine-tuning embedding models for domain-specific RAG using synthetic data and hard negative mining on a single GPU. No manual labeling needed. Atlassian saw 26% recall improvement.

What this enables: You can meaningfully improve RAG retrieval using LLM-generated synthetic data from your own docs. No labeled dataset, no GPU cluster, just one card and your domain knowledge.

TOOLS

Ossature: An Open-Source Harness for Spec-Driven Code Generation

Estimated read time: 11 min

Ossature tackles the gap between LLMs generating functions well and producing coherent projects. Its spec-driven harness validates, audits, and builds code one task at a time, giving each task narrow context with built-in verification loops.

The takeaway: If AI-generated code works in isolation but falls apart at module boundaries, spec-driven generation with narrow context and verification loops is a practical pattern worth exploring.

Awesome CursorRules: A Curated Collection of .cursorrules for Every Stack

Estimated read time: 4 min

Also in the AI code generation space, this community repository collects hundreds of .cursorrules configuration files spanning frontend, backend, mobile, and testing stacks. Each provides project-specific instructions that tailor Cursor AI’s output to particular frameworks.

Worth noting: Instead of writing .cursorrules from scratch, grab a template and customize it. The patterns here apply to any AI coding tool that accepts project-level instructions.

Cloudflare’s Dynamic Worker Loader: Isolate-Based Sandboxes That Are 100x Faster Than Containers

Estimated read time: 11 min

Once AI generates the code, you need somewhere safe to run it. Following our look at NVIDIA’s kernel-level OpenShell runtime[1] last week, Cloudflare takes a lighter approach. Dynamic Worker Loader moves into open beta with V8 isolate sandboxes that boot in milliseconds. Roughly 100x faster than containers, with no concurrency limits and a decade of security hardening.

Why now: As agents increasingly generate and execute their own code, the demand for lightweight, production-grade sandboxes is accelerating. Cloudflare’s isolate approach fills a real gap in the agent infrastructure stack.

[1] NVIDIA OpenShell: A Sandboxed Runtime for AI Agents That Actually Need Access

jai: A Lightweight Sandbox to Stop AI Agents From Wrecking Your Home Directory

Estimated read time: 3 min

For local development, Stanford releases jai, a free tool that sandboxes AI coding agents with a single command. Copy-on-write overlays protect your home directory while keeping the working directory writable. Three isolation modes fill the gap between raw shell access and containerization.

Practical tip: If you’re running agents like Codex or Claude Code against your local filesystem, prefix the command with jai to contain the blast radius without Docker or VM overhead.

Chroma’s Context-1: A 20B Model That Matches Frontier LLMs at Agentic Search

Estimated read time: 14 min

Chroma releases Context-1, a 20B-parameter model purpose-trained for multi-hop retrieval. Its core innovation is self-editing context management, where the agent selectively discards irrelevant documents during search to prevent context rot, matching frontier LLMs at up to 10x the speed.

What’s interesting: A purpose-trained 20B model matching frontier search agents at dramatically lower cost and latency opens multi-hop RAG to teams that previously couldn’t justify frontier API budgets.

Mistral Releases Voxtral TTS: A 4B Parameter Multilingual Text-to-Speech Model

Estimated read time: 5 min

Mistral launches Voxtral TTS, a 4B parameter model with emotionally expressive speech across 9 languages. It achieves 70ms latency, adapts to custom voices from 3 seconds of audio, and supports zero-shot cross-lingual generation.

The highlight: Available via API or as open weights, this gives voice agent builders a production-ready option with custom voice cloning from just 3 seconds of reference audio.

NEWS & EDITORIALS

State of the Tech Job Market: PM Roles Hit 3-Year High While Design Stalls

Estimated read time: 7 min

Lenny Rachitsky’s biannual analysis finds PM openings at a three-year high, 67,000+ engineering roles globally, and AI positions hockey-sticking. Yet design roles have plateaued since early 2023, suggesting AI-accelerated engineering is compressing traditional design workflows.

The context: AI-specific roles are accelerating fastest, with a third of openings in the Bay Area and NYC emerging as the clear second hub. Worth tracking if you’re considering a move.

METR’s Tabletop Game Simulates Working with 200-Hour AI Agents, Finds Humans Become the Bottleneck

Estimated read time: 11 min

Adding depth to our coverage of DX’s ~10% productivity finding[1] from last week, METR researchers simulated work with 200-hour AI agents. They found 3-5x uplift, but human review, feedback, and prioritization become the dominant serial bottlenecks once execution is near-instant.

The signal: As agents handle more execution, the bottleneck shifts to human judgment. Designing workflows around faster review and prioritization will matter more than speeding up implementation.

[1] AI Productivity Gains Land at ~10%, Not the 2-3x Vendors Promised

MiniMax M2.7 vs. Claude Opus 4.6: 90% of the Quality at 7% of the Cost

Estimated read time: 7 min

Shifting from organizational dynamics to model economics, and following our discussion of MiniMax M2.7’s self-evolution capabilities[1] last week, Kilo Code independently tested the model against Claude Opus 4.6 on three TypeScript tasks. Both found every bug, but MiniMax delivered comparable detection at 7% of the cost, $0.27 versus $3.67. Claude’s fixes remain more thorough.

Worth watching: Open-weight models are closing the gap on detection tasks. Reserve frontier models for fixes that need depth, and you can cut AI coding costs dramatically on the rest.

[1] MiniMax M2.7: The Model That Helps Build Its Own Next Version

Inside Claude’s Mind: Anthropic’s Interpretability Research Reveals How LLMs Actually Think

Estimated read time: 11 min

Diving deeper into how these models actually work, Anthropic traced Claude’s internal computations and found surprising gaps between what the model reports and does. Claude invents its own algorithms, plans poetry ahead, and defaults to silence. Chain-of-thought traces can be post-hoc fabrications.

Learning opportunity: Understanding how models actually reason versus what they report in chain-of-thought helps you build more robust evaluation pipelines and set realistic expectations for AI-assisted workflows.

Paid tier addition: This is the first of a new format I'm calling Notes: shorter posts capturing small discoveries worth passing along. The deeper, research-backed posts you're used to aren't going anywhere. Notes are in addition to those, not a replacement.

Claude Code’s /init command analyzes your codebase and generates a CLAUDE.md file, the persistent…

Read more

Welcome to another edition of Altered Craft’s weekly AI review for developers. Thank you for making this part of your Monday. This week, the evidence is doing the talking. A 400-company study lands AI productivity gains at roughly 10%, a case study puts a 100-hour price tag on going from prototype to product, and a sensemaking framework argues you should ignore predictions entirely and follow field reports. Meanwhile, new coding models compete on benchmarks and pricing, and NVIDIA doubles down on agent security.

TUTORIALS & CASE STUDIES

MCP Is Dead, Long Live MCP: Why the CLI vs. MCP Debate Misses the Point

Estimated read time: 14 min

Continuing our coverage of the CLI-versus-MCP debate[1] from last week, Charles Chen argues the rush to abandon MCP for CLIs misses a crucial distinction. While CLIs save tokens for well-known tools, MCP over streamable HTTP unlocks centralized auth, telemetry, and security that enterprises need for structured agentic engineering at scale.

The takeaway: The real value isn’t in local stdio mode. It’s in the remote HTTP transport layer that enables org-wide auth, observability, and governance over agent workflows.
[1] Manus Lead Ditches Function Calling for Unix CLI

A Developer’s Guide to AI Agent Protocols: MCP, A2A, UCP, AP2, and A2UI

Estimated read time: 12 min

Expanding on the protocol question, Google’s developer blog demystifies five AI agent protocols by building a restaurant supply chain agent with ADK. Each protocol is layered incrementally, showing exactly what custom integration code MCP, A2A, UCP, AP2, and A2UI each replace.

What this enables: Instead of memorizing protocol specs, you see each one earn its place by eliminating real integration code in a practical, multi-step scenario.

The LLM Architecture Gallery: A Visual Reference from GPT-2 to Today’s MoE Models

Estimated read time: 4 min

For a visual reference to the models powering these protocols, Sebastian Raschka’s LLM Architecture Gallery collects standardized diagrams and fact sheets for major open-weight models from GPT-2 through DeepSeek V3, Llama 4, and Qwen3, documenting scale, attention type, and key design choices.

Worth bookmarking: When you need to quickly compare attention mechanisms, MoE configurations, or normalization strategies across modern LLM architectures, this is the single-page reference to reach for.

Context Anchoring: The Practice of Externalizing AI Session Memory

Estimated read time: 11 min

Shifting from architecture to workflow, Martin Fowler’s team introduces context anchoring: maintaining a living feature document outside the AI chat. The article shows how reasoning degrades faster than decisions in long contexts, and how a lightweight external record turns cold-start sessions into warm ones.

Why this matters: If closing your AI chat session causes anxiety about losing context, this lightweight practice turns any new session or new teammate into a warm start.

Lessons from Building Claude Code: A Taxonomy of Skills and How to Write Good Ones

Estimated read time: 12 min

In more practical developer workflow guidance, an Anthropic engineer catalogs nine skill categories and shares patterns for writing, distributing, and measuring Claude Code skills from hundreds in active internal use, including progressive disclosure via folder structure, iterative gotchas sections, and on-demand hooks.

Key point: The best skills at Anthropic grew from real failure points, not upfront design. Start small with a few lines and a gotchas section, then iterate as edge cases appear.

TOOLS

NVIDIA OpenShell: A Sandboxed Runtime for AI Agents That Actually Need Access

Estimated read time: 3 min

Following our coverage of NanoClaw’s Docker-based agent isolation[1] last week, NVIDIA open-sourced OpenShell, a runtime that sandboxes AI agents with kernel-level isolation and declarative YAML policies across filesystem, network, process, and inference layers, letting teams grant agents real capabilities without unrestricted access to credentials and source code.

The context: As coding agents gain access to production credentials and source code, policy-as-code enforcement is becoming table stakes. OpenShell gives enterprises an open-source baseline.

[1] NanoClaw Partners with Docker for Agent Isolation

NVIDIA NemoClaw: A One-Command “Secure Claw” Stack for AI Agents

Estimated read time: 2 min

Building on the OpenShell runtime, NVIDIA releases NemoClaw, an open-source stack adding policy-based privacy and security guardrails to OpenClaw autonomous agents. It routes to local Nemotron models for enhanced privacy and deploys everything with a single command.

Why now: Multiple teams are converging on the same pattern: sandboxed agent execution with local model routing for privacy. NemoClaw makes this a one-command setup.

Cursor Ships Composer 2: Frontier-Level Coding at Aggressive Pricing

Estimated read time: 2 min

Moving from agent infrastructure to coding models, Cursor releases Composer 2 with major gains on Terminal-Bench 2.0, SWE-bench Multilingual, and CursorBench through continued pretraining and RL on long-horizon tasks. Pricing at $0.50/M input tokens undercuts comparable fast models.

What’s interesting: The benchmark jumps over Composer 1.5 are substantial, and the aggressive pricing signals that frontier-level coding performance is becoming commoditized faster than expected.

OpenAI Launches GPT-5.4 Mini and Nano: Smaller Models Built for Speed-Sensitive Workloads

Estimated read time: 5 min

Also in the competitive coding model space, OpenAI releases GPT-5.4 mini and nano optimized for coding, subagents, and computer use. Mini hits 54.4% on SWE-Bench Pro at 2x the speed, offering a strong performance-per-latency tradeoff for agentic workflows. Nano targets classification at $0.20/M tokens.

What this unlocks: For multi-agent systems, mini at $0.75/M input tokens becomes the natural default for delegated subtasks where speed matters more than peak capability.

Mistral Launches Forge: Custom Frontier Model Training for Enterprises

Estimated read time: 7 min

For teams wanting models trained on their own data, Mistral AI introduces Forge, a platform for training frontier-grade models on proprietary enterprise data including codebases and compliance policies. Forge is agent-first, letting autonomous agents drive fine-tuning through natural language.

The opportunity: If your team has outgrown RAG-based approaches, Forge’s RL-based continuous improvement loop offers a practical path to custom enterprise models without building training infrastructure.

Claude Code Channels: Push Events from Telegram and Discord Into Your Coding Session

Estimated read time: 4 min

Shifting to developer experience tooling, Anthropic’s research preview introduces channels that push real-time Telegram and Discord events into running Claude Code sessions. Claude reads and replies through the same bridge, with sender allowlists for security. A localhost demo lets you test first.

Worth noting: This turns Claude Code from a pull-only tool into a reactive one, enabling workflows where your coding agent responds to external events while you’re away from the terminal.

APM: Microsoft’s Open-Source Package Manager for AI Agent Configuration

Estimated read time: 3 min

Also addressing AI developer tooling, Microsoft releases APM, bringing package.json-style dependency management to AI agent configuration. Teams declare prompts, skills, plugins, and MCP servers in one apm.yml manifest with transitive resolution and cross-agent support for Copilot, Claude Code, and Cursor.

Problem it solves: If your team manually configures AI coding agents per repo, APM lets you declare that setup once and reproduce it anywhere with a single install command.

NEWS & EDITORIALS

AI Productivity Gains Land at ~10%, Not the 2-3x Vendors Promised

Estimated read time: 3 min

Putting data behind our coverage of Rob Englander’s “AI did not simplify engineering” thesis[1] from last week, a DX longitudinal study across 400 companies finds that despite 65% growth in AI usage, PR throughput rose only ~10%. Developers explain that writing code was never the bottleneck. Planning, code review, and handoffs still dominate engineering time.

The data: Organizations should recalibrate expectations toward the 8-12% range and redirect investment toward the non-coding bottlenecks that AI hasn’t solved yet.

[1] AI Did Not Simplify Software Engineering

The 100-Hour Gap Between a Vibecoded Prototype and a Working Product

Estimated read time: 5 min

Illustrating that productivity gap in practice, this case study reveals a 100-hour gap between a vibecoded prototype and a production-ready product. The impressive AI-generated demo feels like most of the work, but edge cases, error handling, and deployment remain stubbornly manual.

The takeaway: Budget real engineering time beyond your prototype. The 100-hour figure gives teams a practical baseline for scoping the work AI doesn’t yet handle.

When LLM Exhaustion Is Actually a Skill Issue

Estimated read time: 4 min

On the developer experience side of that gap, Tom Johnell argues frustrating LLM sessions stem from developer fatigue, not model degradation. He identifies a “doom-loop psychosis” where tired prompting and slow feedback loops waste hours. The fix: treat prompt confidence as an energy signal.

The fix in practice: If you’re not confident your prompt will nail the result before you hit submit, you likely need a break or haven’t decomposed the problem enough.

A Sensemaking Framework for AI: Ignore Predictions, Follow Field Reports

Estimated read time: 15 min

For a broader lens on navigating these challenges, Cedric Chin studies past tech revolutions and argues for ignoring all AI predictions. Instead, collect detailed field reports of actual use and filter them through four questions about outcomes, actions, value, and causation.

How to apply it: The four-question filter (outcomes, actions, value, causation) gives you a repeatable framework for evaluating any AI capability claim against your own context.

Cerebras Brings Wafer-Scale Inference to AWS, Introduces Disaggregated Architecture with Trainium

Estimated read time: 4 min

Shifting to industry moves, Cerebras announces AWS will deploy CS-3 systems via Bedrock. Their disaggregated inference architecture splits prefill across Trainium and decode across Cerebras WSE, targeting 5x more high-speed token capacity for agentic coding workloads.

Market signal: Agentic coding generates roughly 15x more tokens than chat. This partnership directly targets the inference bottleneck that makes token-heavy agent pipelines expensive to scale on AWS.

OpenAI Acquires Astral, Bringing Python’s Most Popular Dev Tools Into Codex

Estimated read time: 3 min

In more industry consolidation news, OpenAI announces its acquisition of Astral, creators of uv, Ruff, and ty, folding Python’s widely adopted open source tools into Codex. OpenAI commits to continued open source support while integrating for full-lifecycle AI agent development.

Worth watching: If your Python workflow depends on uv, Ruff, or ty, the roadmap for those tools now runs through OpenAI’s Codex strategy. Watch for governance and licensing signals post-close.

MiniMax M2.7: The Model That Helps Build Its Own Next Version

Estimated read time: 10 min

On the model development front, MiniMax releases M2.7, a model that actively participates in its own evolution by autonomously optimizing scaffolds and running RL experiments. It scores 56.22% on SWE-Pro and now manages 30-50% of MiniMax’s internal RL workflow.

What stands out: The self-evolution loop, where the model iterates its own scaffolding and training, signals a shift from models as passive outputs to active participants in their own development.

The 3 Cs Framework: How Open Source Maintainers Can Mentor Strategically in the AI Era

Estimated read time: 8 min

Returning to the human side of AI’s impact, AI-generated pull requests are flooding open source projects, eroding traditional quality signals. GitHub’s Abigail Cabunoc Mayes proposes the 3 Cs framework -- Comprehension, Context, and Continuity to help maintainers invest mentorship energy strategically.

The opportunity: Whether you maintain or contribute to open source, the 3 Cs give you a practical filter for where to invest mentorship energy when traditional quality signals are unreliable.

Sixty-eight percent. I start running the math on what those remaining credits could have built. Not because I need anything built. Because leaving them on the table feels like waste.

I have a gaming laptop sitting on my desk. I bought it during COVID for exactly the reason you’d expect. It hasn’t run a game in months. Now I look at it and think: that GPU should be running local models. It should be doing something. It should be working while I sleep.

As I review this draft, I pause every few minutes. A coding agent working on a bug fix in a project chimes in, requesting feedback. I switch contexts, review its output, give it another task, and come back to writing. The irony isn’t lost on me. I’m writing about the pressure to always have something running while I literally have something running.

One name I’ve been using for this feeling is token anxiety. The persistent, low-grade pressure that you should be doing more with AI tools. Not because you have a specific need, but because the capacity is there and you’re not using it. The term is still settling out, but the feeling is precise.

If this sounds familiar, you’re not imagining it. And you’re not alone.

You’re Not the Only One

Something shifted at the start of this year. Agents got meaningfully more capable of working on larger tasks for longer stretches. Open-source agent tools went viral, and I won’t even get into OpenClaw. The infrastructure for running AI autonomously became accessible to anyone willing to set it up.

And the psychological effects followed immediately.

TechCrunch reported in February that the first signs of burnout are coming from the people who embrace AI the most. Not the skeptics. Not the holdouts. The enthusiasts. The people who leaned in the hardest are the ones hitting the wall.

Harvard Business Review coined the term “brain fry” to describe the cognitive strain from managing multiple AI agents and constant tool switching. Users describe a buzzing feeling, mental fog, difficulty focusing. The tools were supposed to free up mental bandwidth. For many, they’re consuming more of it.

In my own community, Portland AI Engineers, the pattern is visible. The conversations have shifted from “what can I build with this?” to “how do I keep up with all of it?” The excitement is still there, but it’s threaded with something more anxious.

It’s Not About the Tokens

Here’s where I think most of the current conversation gets it wrong. The articles about token anxiety tend to frame it as a cost problem. Watch your spend. Set budgets. Optimize your prompts. That’s useful advice, but it misses the point.

When I looked at those unused Claude Max credits and felt a pang, that wasn’t about twenty dollars. It was about the gap between who I am and who I feel I should be now that the tools have made so much more feel possible.

That’s an identity question, not a budgeting question.

The pressure to do more with the time you have isn’t new. Every developer has felt it. I remember Red Bull-fueled coding marathons during my startup days, grinding through weekends convinced that more hours meant more progress. At some point, I was introducing more bugs than features.

The guilt of “I could be doing more” existed long before agents. What’s changed is the scale. AI dramatically expanded what’s possible in a given hour, and that expansion is still accelerating. The gap between what you’re doing and what you could theoretically be doing has never been wider.

Now an agent can work while you sleep. A local model can run on that idle GPU. The ceiling moved upward, fast, and you’re measuring yourself against it. Every hour without something running starts to feel like an hour wasted. Not because it is. Because it could have been something.

This is the anxiety of unrealized potential. The weight of everything you could be doing but aren’t. When AI was less capable, the menu of what you could build was finite and manageable. Now it essentially feels infinite, and every new capability adds another option you’re choosing not to pursue.

That internal pressure would be hard enough on its own. But you’re not experiencing it in a vacuum. As AI lowers the barrier to building, more people are building visibly. Your feed is full of developers shipping projects, launching tools, posting demos. Research on FOMO consistently shows that social comparison drives anxiety and compulsive behavior. A culture that already valued output and shipping is especially susceptible. So the weight of what you haven’t done meets a constant stream of evidence of what others apparently have.

That’s the two-front pressure: internally, an infinite menu of things you could be pursuing; externally, a highlight reel of people who seem to be pursuing all of it.

We’ve Been Here Before

If you’ve been in this industry for more than a few years, this pressure has a familiar shape. Early cloud adoption brought a similar anxiety. You’d watch competitors spin up infrastructure and feel the pull to migrate everything, immediately, before you fell behind. Containers and Kubernetes created another wave. Everyone needed to be containerized. Everyone needed orchestration. The ones who didn’t felt like they were falling behind.

In hindsight, the teams that adopted everything fastest weren’t necessarily ones that fared best. They carried the usual operational burdens plus the pain of early-stage tooling, constant up-skilling, and undocumented edge cases. The teams that often fared better were the ones who chose deliberately: which problems actually warranted new approaches, and which were fine with proven solutions.

That pattern is relevant now, but this time is different in scale and in kind. Previous transitions asked you to learn a new tool or platform. You learned it, it stabilized, you moved on. This one is an entirely new abstraction layer: agents, prompts, context management, memory, tool orchestration. It evolves monthly. What you learned about agents three months ago may already be partially obsolete. And unlike any previous wave, the tools work without you. Cloud and containers were things you operated. Agents operate independently.

On top of that, the friction to go deep on something new has nearly vanished. You can spin up a working prototype of almost anything in an afternoon. That’s genuinely powerful, and it’s exactly why choosing where to go deep matters more than ever. The surface area of “things you could learn” grew by an order of magnitude in about six months. No single person can cover all of it, and trying to is the fastest path to the anxiety we’re talking about.

What I’m Trying

I don’t have this figured out. I’m writing about it partly because writing is how I process, and this is something I’m actively processing.

My situation makes this particularly acute. As a full-time AI researcher and writer, I’m hyper-exposed to every new advance. I see it all, every day. And I come from a software engineering background, which means my instinct when I see something interesting is to build with it. That combination is a recipe for constant distraction disguised as diligence. Every new technique, every new tool, triggers the same impulse: I should try this. The discipline I’m still developing is protecting time for the research and writing that are actually my job, which means being very deliberate about what I choose to build.

The practice I’ve landed on is still evolving. I use Obsidian as my second brain. It’s all simple markdown files, which makes it inherently agent-friendly. Inside it, I curate my short and medium-term career goals. I don’t pretend to know what I’ll be doing in the long term, so I don’t plan for it. I use Claude Code to brainstorm against those goals, pressure-test my priorities, and reinforce my direction when the noise gets loud. The process is never finished. I continually simplify it, strip out what isn’t working, and let it evolve.

The effect is that when something new and shiny lands, I have something to check it against. Not a rigid framework, but a set of compass goals that help me ask: does this serve what I’m actually working toward, or does it just feel like something I should try?

Sometimes the answer is: not right now. And that’s the hardest part. Deliberately choosing to say no to something interesting, not because it’s bad, but because it doesn’t align with where you’re headed. What helps me is giving myself a hedge: bookmark it, set it aside for three or four weeks, then revisit. If it still matters after that window, the community has had time to vet it, documentation has improved, and you’ll learn it faster with better signal. If it’s faded, you saved yourself a detour. Either way, a few weeks doesn’t put you behind. The anxiety says otherwise, but the anxiety is wrong about this.

Your version of this will look different, but the underlying loop is the same. Define your compass goals, even loosely. When new tech appears, check it against those goals. Go deep only where it serves them. Periodically reassess the goals themselves, because the landscape shifts and your direction should be allowed to shift with it.

The Goal Isn’t More Tokens

If you’re feeling the pull I’ve described here, I want to leave you with this: you’re not behind. The anxiety is real, it’s widespread, and it’s hitting the most engaged practitioners the hardest. That last part is important. Feeling this way is not evidence that you’re doing something wrong. It’s probably evidence that you care about doing it right.

The goal isn’t to use more tokens. It isn’t to have agents running around the clock. It isn’t to repurpose every piece of hardware in your house into an AI box (though I’m still eyeing that laptop).

The goal is intention. High-level compass goals have always been good practice, but they’ve never been more important than in a moment when the friction to build has nearly disappeared. Knowing why you’re spending the tokens you spend. Choosing where to invest instead of feeling guilty about what you’re passing on. Having a direction, even a rough one, that lets you evaluate opportunities against your actual goals instead of against an impossible standard of doing everything.

The tools made so much more feel possible. That’s genuinely exciting. The work is making sure your default is to review, not simply react.

Welcome back to Altered Craft’s weekly AI review for developers. We’re glad you’re here, and we don’t take your attention for granted. This week, the conversation shifts from whether to adopt agents to what’s actually inside them. You’ll find practitioners dissecting harness architecture, reimagining tool interfaces with Unix CLI, and building isolation infrastructure for production agent teams. On the editorial side, Ethan Mollick maps AI’s rolling disruption while two authors independently conclude that faster code generation is creating new forms of engineering complexity.

TUTORIALS & CASE STUDIES

What Makes AI Agents Actually Work

Estimated read time: 12 min

Building on our coverage of Morris’ “harness engineer” role concept[1] from last week, LangChain now formally defines Agent = Model + Harness, where the harness encompasses all code, configuration, and execution logic surrounding the model. This deep dive covers context compaction strategies, sandboxed execution, memory systems, and long-horizon patterns. As models improve, harness engineering remains essential.

[1] Positioning Humans in AI Development Loops

Why this matters: Understanding the harness concept helps you architect agent systems that stay robust as you swap underlying models, a critical skill as the landscape shifts rapidly.

Manus Lead Ditches Function Calling for Unix CLI

Estimated read time: 18 min

Extending our coverage of Holmes’ CLI-over-MCP argument[1] from last week, a former Manus backend lead takes the position even further: a single run(command="...") tool with Unix CLI commands outperforms function-calling catalogs entirely. CLI is the densest tool-use pattern in LLM training data, and progressive --help discovery guides agents without bloating system prompts.

[1] CLIs Beat MCP for AI Tool Integration

The takeaway: If you’re building agent tool interfaces, this battle-tested approach reduces tool selection complexity while leveraging what LLMs already know from training data. The production failure stories alone are worth the read.

How Claude’s Generative UI Actually Works Inside

Estimated read time: 10 min

Shifting from the tool layer to the presentation layer, Michael Livshits reverse-engineered Anthropic’s generative UI, revealing a show_widget tool call with progressive DOM rendering. He replicated the pattern for a CLI agent using DOM diffing with morphdom to achieve smooth streaming HTML updates.

What’s interesting: The architecture reveals that generative UI requires no specialized rendering engine, just smart HTML injection and DOM diffing. The extracted design system guidelines are a bonus for anyone building similar features.

OpenAI’s Social Engineering Approach to Agent Security

Estimated read time: 7 min

With agents gaining richer capabilities, security becomes critical. OpenAI reframes prompt injection as a social engineering problem. Their Safe Url detection constrains manipulation impact through source-sink analysis, flagging when conversation data would be transmitted to third parties, mirroring how organizations manage human agent risk.

Key point: Source-sink analysis is a practical framework you can apply today when designing agent permissions and data flow boundaries. As agents handle more sensitive tasks, this mental model becomes essential.

From Individual AI to Institutional Intelligence

Estimated read time: 9 min

Zooming out from individual agent design, George Sivulka argues that organizations fail to capture AI’s 10x individual productivity gains without redesigning operations. His seven pillars of institutional intelligence cover coordination, signal detection, bias resistance, and unprompted AI action.

The opportunity: If you’re consulting or leading AI adoption, this framework gives you structured vocabulary for conversations about why individual productivity tools aren’t translating into organizational value.

TOOLS

JetBrains Air Runs Multiple Coding Agents Together

Estimated read time: 4 min

JetBrains launches Air, an Agentic Development Environment where Codex, Claude Agent, Gemini CLI, and Junie execute independent task loops in parallel. Each agent runs in isolated Docker containers or Git worktrees. The desktop app provides code-aware task definition, concurrent progress monitoring, and language-aware review. macOS preview available now.

Why now: Agent orchestration environments are becoming a new product category. Air’s model-agnostic approach lets you compare agents side by side and match the right tool to each task.

gstack Turns Claude Code Into Expert Teams

Estimated read time: 5 min

Also in the agent orchestration space, YC’s Garry Tan created gstack: eight specialized skills for Claude Code enforcing distinct cognitive modes. Includes CEO-level planning, paranoid code review, diff-aware QA, and automated shipping with native browser testing and cookie import. Supports 10+ parallel sessions via Conductor.

Worth noting: The philosophy of explicit cognitive mode switching, where planning stays separate from review and shipping, is a workflow pattern worth adopting regardless of which agent tools you use.

NanoClaw Partners with Docker for Agent Isolation

Estimated read time: 5 min

NanoClaw partners with Docker to run AI agents in isolated micro VMs with one command. Each agent gets its own kernel, filesystem, and daemon with hypervisor-level isolation and millisecond startup. The security model treats agents as potentially malicious actors, enforcing hard boundaries against cross-agent leakage.

The context: As agents gain access to credentials, filesystems, and APIs, the “design for distrust” principle becomes table stakes. This is the infrastructure layer that enterprise agent deployments will require.

GLM-5-Turbo Optimized for Agentic Task Execution

Estimated read time: 3 min

Shifting from agent infrastructure to new models, Z.AI releases GLM-5-Turbo with a 200K context window and 128K max output tokens. Features include enhanced function calling stability for multi-step tasks, context caching, structured output, and MCP integration, all optimized for agentic workflows.

What this enables: The 128K output token limit is notable. Combined with MCP integration and context caching, this model is designed from the ground up for long-running agent task chains.

NVIDIA’s Hybrid Mamba-Transformer for Agentic Reasoning

Estimated read time: 3 min

Also optimized for agentic workloads, NVIDIA releases Nemotron-3-Super-120B-A12B, an open hybrid Mamba-Transformer MoE model with a 1 million token context window. The 120B parameter model features configurable reasoning effort levels and is available through NVIDIA NIM with an OpenAI-compatible API.

What stands out: The hybrid Mamba-Transformer architecture offers a different efficiency tradeoff than pure transformer models. Configurable reasoning effort lets you dial cost vs. quality per request, a feature more models should adopt.

Penguin-VL Rethinks Vision Language Model Design

Estimated read time: 4 min

Tencent’s Penguin-VL initializes its vision encoder from a text-only LLM instead of CLIP, converting causal attention to bidirectional with 2D rotary positional embeddings. Available in 2B and 8B parameter sizes, it excels at OCR, document parsing, and complex visual reasoning with strong efficiency.

The approach: Starting a vision encoder from language model weights rather than image-pretrained ones is a counterintuitive design choice that pays off in document-heavy workflows where text understanding matters most.

Google’s First Natively Multimodal Embedding Model

Estimated read time: 5 min

Also advancing multimodal AI, Google releases Gemini Embedding 2, the first natively multimodal embedding model mapping text, images, video, audio, and documents into a single vector space. It supports 100+ languages with Matryoshka Representation Learning for flexible dimensions from 768 to 3072. Available through Gemini API and LangChain.

What this unlocks: A single embedding space for text, images, video, and audio simplifies RAG pipelines dramatically. No more separate encoders or complex fusion layers for multimodal retrieval.

CanIRun.ai Matches Hardware to Local AI Models

Estimated read time: 2 min

For developers exploring which of these models to run locally, CanIRun.ai detects your GPU, CPU, and RAM via browser-based client-side processing and matches against a database of popular open-source models including Llama, Qwen, Mistral, DeepSeek, and Gemma, from 1B to 120B+ parameters.

Bookmark this: Eliminates the guesswork of checking VRAM requirements and quantization options across dozens of models. Save this for the next time you’re evaluating a local model setup.

NEWS & EDITORIALS

The Shape of AI’s Rolling Disruption

Estimated read time: 12 min

Ethan Mollick charts AI’s shift from human-AI collaboration to full AI management, where organizations mandate that code must not be written or reviewed by humans. He highlights recursive self-improvement as a key accelerator. Benchmarks show AI now matches top-performing humans 82% of the time.

The big picture: Whether you view these shifts as opportunity or disruption, Mollick’s benchmark data provides the clearest picture of where AI capability stands today and how fast the gap is closing.

Meta Postpones Frontier Model Over Performance Gaps

Estimated read time: 9 min

Illustrating the challenges Mollick describes, Meta postpones its Avocado frontier model after internal testing revealed it failed to match performance benchmarks set by Google Gemini 3.0 and OpenAI’s latest models. The launch is pushed to at least May 2026, highlighting post-training refinement challenges.

Market signal: The rising competitive bar means even massive compute budgets can’t guarantee frontier performance. Post-training refinement and alignment are emerging as the true differentiators, a trend worth watching for anyone selecting models for production.

AI Did Not Simplify Software Engineering

Estimated read time: 6 min

Continuing our coverage of Turkovic’s “easier code, harder engineering” thesis[1] from last week, Rob Englander adds a technical lens, arguing that AI coding tools haven’t simplified the real challenges: architecture, system behavior design, and managing complexity over time. He identifies spec drift as a growing risk where AI generates code faster than teams can maintain alignment between specs, tests, and implementation.

[1] AI Eased Code Writing but Strained Engineering

The insight: “Spec drift” names something many teams are already experiencing but haven’t articulated. Faster code generation without faster specification work creates a new category of technical debt.

Anthropic Launches Institute for AI Societal Impact

Estimated read time: 5 min

Addressing these systemic concerns, Anthropic launches The Anthropic Institute, focused on how powerful AI will reshape jobs, economies, and governance. Led by co-founder Jack Clark, it unifies Frontier Red Team, Societal Impacts, and Economic Research. New hires specialize in AI law and transformative economics.

The signal: Anthropic investing in dedicated societal impact research signals a maturing industry. The focus on AI and rule of law, economic reshaping, and red-teaming means policy decisions will increasingly be data-driven.

Claude Finds 22 Firefox Vulnerabilities in Two Weeks

Estimated read time: 6 min

Also from Anthropic, Claude Opus 4.6 discovered 22 vulnerabilities in Firefox over two weeks, with Mozilla classifying 14 as high-severity. The AI found a Use After Free flaw in twenty minutes. Crucially, vulnerability discovery costs far less than exploitation, giving defenders a current advantage.

For security teams: The asymmetry between discovery cost and exploitation cost currently favors defenders. AI-assisted vulnerability scanning is becoming a practical force multiplier right now.

Taken individually, these are incremental improvements. Taken together, they reveal a coherent architecture: code execution as the foundational primitive, context management as the core engineering problem, and multi-surface access as the interface layer. The underlying shift is concrete. Claude used to generate text about solutions. Now it executes them and verifies the results. That shift underpins everything below.

The Multi-Surface Shift

If you’ve been using Claude Code primarily from the terminal, the biggest shift you may have missed is how many surfaces it now covers. The Claude desktop and mobile apps now have a dedicated Code tab. Claude Code on the Web runs sessions in Anthropic-managed cloud VMs, no local install required. VS Code and JetBrains extensions embed it in your IDE. And with Remote Control (more on this below), you can connect any of these surfaces to a session running on a machine of your choosing. The underlying agent is the same one you know. The surfaces are different entry points into it.

This matters because it changes the relationship. Claude Code stops being “a tool you sit down and use” and becomes something that’s available wherever you are. Start debugging in the terminal at your desk, switch to VS Code for visual diffs, check on progress from your phone. The conversation and context follow you.

You’re likely already familiar with CLAUDE.md, skills, hooks, and subagents. These have continued to mature, but the conceptual model hasn’t changed. What has changed is where you can access all of it. The customization you’ve built into your workflow now travels with you across surfaces.

Remote Control: The Always-Available Agent

The feature that makes the multi-surface story tangible is Remote Control. It connects claude.ai/code or the Claude mobile app to your running local session. Everything stays local. Your filesystem, MCP servers, project config. The web or mobile interface is just a window into it.

# Start a remote-controlled session
claude remote-control --name "My Project"

# Or from an existing session
/rc

Press spacebar to get a QR code for your phone. The session syncs across all connected devices. Send messages from terminal, browser, and phone interchangeably.

The architectural decision here is deliberate. Unlike Claude Code on the Web, which runs on Anthropic-managed cloud VMs, Remote Control keeps execution on your machine. Your local tools work. Your MCP connections work. You get the mobility of a cloud-based tool without giving up local control.

I’ve been experimenting with Remote Control over the past few weeks. The appeal is real. Starting a long-running task at my desk and continuing from my phone is exactly the workflow I wanted, without going the full OpenClaw route of setting up a persistent headless agent. Remote Control is the lighter-weight version of “Claude Code is always available.”

In practice, connection stability has been a challenge. Sessions drop more often than I’d like, particularly during longer tasks. This is a research preview, so rough edges are expected. The underlying idea is sound. The execution needs time to mature. I’ll keep testing it because the workflow it enables is worth the friction.

All traffic runs through the Anthropic API over TLS, using multiple short-lived credentials scoped to single purposes. No cloud VMs, no external sandboxing. Available on Pro, Max, Team, and Enterprise plans.

What’s New in the CLI

Read more

Thanks for joining us for another Altered Craft weekly AI review for developers. We appreciate every reader who makes Monday mornings a little more intentional. This week’s collection circles a central question: as agents grow more capable and autonomous, what exactly does the developer’s role become? You’ll find collaboration frameworks from Thoughtworks, a sobering SQLite case study on AI code quality, GPT-5.4’s leap into computer use, and honest examinations of how the profession itself is changing.

TUTORIALS & CASE STUDIES

Five Patterns for Productive AI Collaboration

Estimated read time: 19 min

Rahul Garg proposes reframing AI coding assistants from “tools” to “teammates” through five patterns: Knowledge Priming, Design-First Collaboration, Sensible Defaults, Context Anchoring, and a Feedback Flywheel. The article argues that reducing friction requires shared vocabulary and architecture vision between humans and AI systems.

The takeaway: These five patterns offer a concrete framework for teams frustrated by the generate-review-fix cycle, shifting the focus from faster output to higher first-pass acceptance rates.

Positioning Humans in AI Development Loops

Estimated read time: 13 min

Also from Thoughtworks, Morris presents three models for human-AI collaboration: outside the loop (vibe coding), inside the loop (manual review), and on the loop (recommended). The preferred approach positions developers as harness engineers who design systems guiding agent behavior rather than inspecting outputs directly.

What’s interesting: The “on the loop” model reframes engineering work around designing guardrails and quality systems, a role that grows more valuable as agents handle more implementation.

Why LLM-Generated Code Compiles but Fails

Estimated read time: 22 min

But what happens when these collaboration models fall short? An LLM-generated Rust reimplementation of SQLite compiles and passes tests, yet performs primary key lookups 20,171 times slower than the original. The article demonstrates how LLMs optimize for plausibility over correctness, missing optimizations discovered through decades of profiling real workloads.

Key point: A compelling argument for defining acceptance criteria before generating code. Performance benchmarks and integration tests catch what compilation and unit tests miss entirely.

Replacing Code Review with Spec-Driven Development

Estimated read time: 13 min

Addressing this code quality challenge, Jain argues that manual code review cannot scale with AI-generated volumes, citing a 91% increase in PR review time for high-adoption teams. He proposes a five-layer trust model replacing human review with deterministic guardrails, moving human judgment upstream to defining specifications.

The opportunity: If your team is drowning in PR reviews, this framework offers a practical path forward: define success criteria upfront and let automated verification replace opinion-based code inspection.

From Manual Prompting to Autonomous Agent Systems

Estimated read time: 16 min

Moving from agent oversight to agent construction, Amazon engineer Fran Soto outlines a ten-step progression from reactive chat-based prompting to building autonomous multi-agent systems. Steps cover integrating MCP servers, creating agent SOPs, automating triggers with cron jobs, and scaling to specialized agent teams.

Why this matters: A genuinely actionable guide that takes you from “I use ChatGPT sometimes” to running autonomous agents on your codebase, with each step building on the last.

Why XML Tags Define Claude’s Advantage

Estimated read time: 5 min

On the prompting side, Lethuillier argues that Claude’s effectiveness stems from making XML tags first-class citizens in its framework. Drawing parallels between delimiters in programming languages, bacterial DNA, and Homeric verse, the article presents a universal principle: languages require markers to signal transitions between expression levels.

Worth noting: If you’ve been on the fence about XML-structured prompts with Claude, this linguistic deep dive explains why they consistently improve output quality over plain-text instructions.

TOOLS

GPT-5.4 Launches with Native Computer Use

Estimated read time: 25 min

OpenAI’s most capable frontier model combines reasoning, coding, and agentic workflows with native computer-use capabilities and 1M token context. GPT-5.4 achieves 75% on OSWorld (surpassing human performance at 72.4%), introduces tool search for large ecosystems, and uses 47% fewer reasoning tokens than GPT-5.2.

What this enables: Native computer use plus 1M token context opens the door to agents that can plan, execute, and verify multi-step workflows across applications without human intervention.

India’s Open-Source Reasoning Models Go Global

Estimated read time: 18 min

Also in the model release space, Sarvam AI open-sources two Mixture-of-Experts reasoning models trained entirely in India: a 30B for real-time deployment and a 105B for complex reasoning. The 105B scores 98.6 on Math500 and 88.3 on AIME25, competing with frontier models at a fraction of training compute.

The context: Open-weight models with frontier-competitive reasoning keep expanding options for teams that need to self-host, fine-tune for specialized domains, or maintain independence from any single vendor.

Cursor Launches Always-On Agent Automations

Estimated read time: 13 min

Putting models like these to work, Cursor introduces Automations: always-on agents triggered by schedules, Slack messages, GitHub PRs, or PagerDuty incidents. Agents spin up in cloud sandboxes, follow custom instructions with configured MCPs, and learn from previous runs. Use cases include security review, PR risk assessment, and incident response.

Why now: This bridges the gap between “AI that helps when you ask” and “AI that works while you sleep,” turning recurring chores like security audits and triage into automated workflows.

OS-Enforced Sandbox for Untrusted AI Agents

Estimated read time: 5 min

With agents running autonomously, security becomes critical. Continuing our look at agent security patterns from Vercel and NanoClaw[1] last week, nono provides kernel-level capability sandboxing for AI agents on macOS and Linux, built by the team behind Sigstore. It implements deny-by-default security with atomic filesystem snapshots for rollback, cryptographic audit trails, and runtime permission management. SDKs support Python and TypeScript.

[1] Five Security Patterns for AI Agent Architectures

Worth noting: A proper sandboxing layer for teams experimenting with autonomous agents. The rollback and audit capabilities make it practical to give agents real system access with confidence.

Slash LLM Token Usage with Smart Compression

Estimated read time: 9 min

Shifting to developer workflow efficiency, RTK is a single Rust binary that reduces token consumption by 60-90% during AI-assisted development through smart filtering, grouping, and deduplication of command output. It transparently intercepts shell commands via hooks, compressing results before they reach the LLM context window with sub-10ms overhead.

The takeaway: If you’re hitting context limits or watching API costs climb during long coding sessions, this is a drop-in solution that works with your existing tools and workflows.

Unified CLI for Google Workspace and Agents

Estimated read time: 9 min

Also on the CLI front, Google releases a unified command-line tool for all Workspace services, built for humans and AI agents. The CLI dynamically generates commands from Google’s Discovery Service at runtime, includes 100+ agent skills, and supports structured JSON output with multiple auth workflows.

Key point: Dynamic command generation from Google’s live API definitions means the tool stays current without manual updates, making it especially useful for building agents that interact with Workspace.

Serverless Data Ingestion for Vector Search

Estimated read time: 6 min

Turning to data infrastructure, Chroma Sync offers serverless data ingestion connecting S3, GitHub, and websites to Chroma Cloud. The platform handles parsing, chunking (using Tree-sitter for code), and embedding automatically. It supports incremental updates and syntax-aware code chunking respecting function boundaries, with pricing starting at $0.04 per GB.

Why this matters: RAG pipelines often stall at the ingestion step. This removes the parsing and chunking burden entirely, letting you focus on retrieval quality and application logic.

NEWS & EDITORIALS

Architecture Skills Now Outweigh Code Writing

Estimated read time: 9 min

A developer reflects on how AI has shifted the core engineering skill from writing code to understanding architecture and system design. Foundational computer science knowledge has become more critical than ever: experienced engineers find their intuition compounds AI capabilities, while barriers to entry have lowered for newcomers.

What’s interesting: Your deep system knowledge is an accelerant, not a redundancy. The engineers who understand architectural trade-offs are the ones getting the most leverage from AI tools.

AI Eased Code Writing but Strained Engineering

Estimated read time: 16 min

Expanding on this shifting landscape, Turkovic presents a central paradox: while AI accelerated code writing, the overall experience of being an engineer has become harder. 67% of developers report spending more time debugging AI code, entry-level hiring fell 25%, and expanding role scope without boundaries is driving burnout.

Worth reading if: you’re a team lead navigating the tension between faster output and sustainable engineering culture. The recommendations for leaders and individual engineers are practical and specific.

Anthropic Measures AI’s Real Labor Market Impact

Estimated read time: 16 min

Backing up these concerns with data, Anthropic researchers introduce “observed exposure,” combining theoretical AI capabilities with real-world usage. Key finding: actual labor market coverage remains a fraction of what is feasible. No systematic unemployment surge has emerged, though the study flags reduced hiring of younger workers in exposed occupations.

The context: The gap between theoretical AI exposure and actual adoption is enormous, which suggests the disruption timeline is longer and more navigable than popular narratives imply.

Cursor Maps Three Eras of AI Coding

Estimated read time: 9 min

Shifting from impact analysis to industry direction, Cursor’s leadership describes the evolution from Tab autocomplete to synchronous agents to autonomous cloud agents tackling larger tasks over longer timescales. Within their team, 35% of merged PRs originate from cloud agents, and agent adoption has grown 15-fold annually.

Why now: 35% of PRs from autonomous agents is a striking signal. The developer role is visibly shifting from writing code to decomposing problems and reviewing agent-generated artifacts.

Microsoft’s Compact Model Challenges Reasoning Giants

Estimated read time: 22 min

Also charting the technical frontier, Microsoft releases Phi-4-reasoning-vision-15B, a compact open-weight multimodal model that matches systems many times its size using a fraction of training data. Trained on roughly 200B tokens (versus competitors’ 1T+), it selectively applies chain-of-thought reasoning only where beneficial and excels at UI navigation.

The opportunity: A 15B model with strong vision and reasoning opens real possibilities for on-premise deployment, edge inference, and cost-effective agentic workflows where frontier models are impractical.

CLIs Beat MCP for AI Tool Integration

Estimated read time: 13 min

Following our coverage of Andrej Karpathy’s rallying cry to build CLI-first for agents[1] last week, Holmes argues that CLIs outperform the Model Context Protocol for AI tool integration. CLIs offer superior debuggability, composability, and authentication since developers can run identical commands to verify agent behavior. MCP adds process management overhead and coarse permission controls without improving security.

[1] Build for Agents: Karpathy on CLI-First Products

Worth noting: Whether you agree or not, the core argument resonates: good CLIs serve both humans and agents, while MCP often introduces more friction than it removes.

The results were remarkable. Not because they were polished (though several were), but because 52 teams demonstrated the sheer range of what small groups can accomplish with frontier AI when the constraints are tight and the energy is right.

I was part of the core organizing team for this event, handling planning and day-of coordination. It was an incredible experience watching these projects come together in real time.

Choosing winners from 52 submissions was genuinely difficult. The range of ideas was wide: adaptive game AI, civic tech, local business intelligence, brand generation, and more. Every team that submitted built something real. These four stood out to the judges.

First Place: Snoop (SnoopFeed)

Rachel Andrews Hardy and Leila Hardy

SnoopFeed flips the newsletter model on its head. Instead of asking experts to write, it watches what they read. The Chrome extension passively logs browsing activity, then uses Claude to analyze patterns and generate a curated newsletter from that consumption. Creators set their own subscription price. Readers subscribe to the people whose taste they trust.

The insight is sharp: the most valuable people in many industries aren’t necessarily the ones producing content. They’re the ones consuming the right stuff. SnoopFeed turns that curation instinct into a product.

The site is live at snoopfeed.com.

Second Place: Signal Intelligence

Jack Hott

Signal Intelligence tackles a real gap: small businesses making decisions without the data that large corporations take for granted. The platform pulls from weather APIs, traffic and road conditions, and large-scale event feeds, then uses Claude Haiku for web searches of local venue events. A Claude Sonnet model reviews the pooled data and generates daily briefings per Portland neighborhood.

The thesis resonates. Small businesses can now leverage data in ways previously only available to companies with dedicated analytics teams. The architecture is intentionally modular. More data sources slot in without structural changes, and briefings get more granular as coverage expands.

The app showing an interactive map of Portland neighborhoods with restaurant and retail filters.

Third Place: TownHall AI

Prashanth Peketi and Roheet Kakaday

TownHall AI addresses voter engagement at the level where it matters most and happens least: local races. The platform gives every political candidate an always-on AI representative, trained exclusively on their own platform documents and public statements. Voters enter their ZIP code, see who’s running in their district, and have a real conversation with a grounded, source-citing AI.

The details matter here. Candidates get an admin panel to upload policies, tune their AI’s voice, and block topics. Every one of those actions is recorded in a public audit log. They even built an alignment score powered by Claude Opus that cross-checks uploaded platforms against public records, flagging inconsistencies in real time.

Down-ballot races shape daily life more than national politics but get almost zero voter engagement. TownHall AI is a thoughtful attempt to close that gap.

The site is live at: https://townhallai.vercel.app/

Fourth Place: Claude Brand Builder

Magnus Graham

Claude Brand Builder is an agentic design agency in a single app. Describe a business idea or upload a few “vibe” screenshots, and a multi-step workflow kicks off: Claude analyzes visual signals to define brand DNA, streams a cohesive brand kit with color palettes and font pairings, generates a logo via the Ideogram API, and renders a fully responsive Tailwind landing page in a live iframe.

Magnus built it out of personal frustration. While launching another project, he found himself context-switching between logo generators, marketing tools, and frontend code. The brand’s identity existed only in his head. Claude Brand Builder keeps everything in one coherent system where the logo, the code, and the colors share the same brain.

What a Day Looks Like

The format was deliberately compressed. Doors at 9:30, kickoff at 10:00, all project submissions by 1:00 PM. Judges narrowed to a top 10, teams presented for three minutes each, and winners were announced by 2:45. Anthropic provided API credits to all participants. Solo hackers and teams of up to four were welcome.

That compression is part of what makes a hackathon valuable. There’s no time to over-architect, no room for scope creep. You build the thing or you don’t. Every winning project shipped a working prototype within that window.

Portland’s Builder Community

What surprised me most wasn’t any single project. It was watching 120 people from different backgrounds, different companies, and different experience levels find common ground over a shared problem. Teams formed on the spot between strangers. People who came solo left with collaborators. Experienced engineers paired with newcomers, and both sides learned something. The ideas that emerged from those combinations were better than anything a homogeneous group would have produced.

That’s the real value of a community hackathon. It’s not the prizes or the demos. It’s the friendships formed, the ideas exchanged, and the realization that your city has more builders than you thought. PDX Hacks and AI Collective did the unglamorous work to make this happen: venue, sponsors, judges, logistics, and the community network to fill a room with the right people. That work matters.

If you’re a community leader in your own city and you’ve been thinking about organizing something similar, do it. The tooling has never been more accessible, the interest has never been higher, and the impact on your local builder community is real. 120 people showed up in Portland on a weekday. Your city has that energy too.

I had an amazing time being part of the organizing team. Watching talented people build something from nothing in a few hours is a kind of joy that’s hard to describe. I’m looking forward to the next one.

LinkedIn coverage: Link Link Link Link Link

Welcome to this week’s Altered Craft weekly AI review for developers. We’re grateful you keep showing up every Monday. This edition has a clear throughline: coding agents are leaving the experimental phase and entering the era of engineering discipline. You’ll find new patterns from Simon Willison, security frameworks from Vercel and NanoClaw, and a provocative argument from Amp that the coding agent itself is dead. Karpathy closes us out with a rallying cry that ties it all together: Build. For. Agents.

TUTORIALS & CASE STUDIES

Agentic Engineering Patterns Beyond Vibe Coding

Estimated read time: 5 min

Simon Willison launches an evergreen guide documenting agentic engineering patterns for professionals using coding agents, explicitly distinguishing this discipline from “vibe coding.” The first two chapters cover how cheap code generation reshapes workflows and how Red/Green TDD helps agents produce reliable output.

The context: As coding agents become standard tooling, having a shared vocabulary and proven patterns prevents teams from reinventing workflows. Willison’s guide format means it will evolve alongside the rapidly changing landscape.

OpenAI’s Codex Prompting Guide for Agentic Coding

Estimated read time: 13 min

Putting those patterns into practice, OpenAI’s guide details prompting strategies for GPT-5.3 Codex in agentic workflows. Key techniques include parallelizing tool calls, batching file reads, and treating the model as an autonomous engineer rather than a conversational assistant.

The takeaway: Even if you don’t use Codex, the prompting philosophy here applies broadly. Bias toward action, batch operations, and minimize status updates to get the most from any coding agent.

Which Web Frameworks Save AI Agents Most Tokens

Estimated read time: 9 min

With agents writing more code than ever, framework choice matters. This benchmark of 19 web frameworks found minimal options like ASP.NET and Express consumed roughly 26k tokens per build, while Phoenix required 74k. Notably, feature additions cost similarly across all frameworks, suggesting overhead primarily impacts initial scaffolding.

Why this matters: If you’re running agents at scale, a 2.9x token gap between frameworks translates directly to cost. Choosing a minimal framework for agent-generated scaffolding is a simple optimization.

Five Security Patterns for AI Agent Architectures

Estimated read time: 9 min

As agents gain deeper access to infrastructure, Vercel maps five progressive security patterns, from zero boundaries to fully separated compute with credential injection. The analysis recommends isolating agent harness from generated code execution as the minimum viable production architecture for teams deploying autonomous coding agents.

Worth noting: Multiple teams are converging on the same conclusion this week: treat agent-generated code as untrusted by default. This piece gives you a concrete maturity model for your own security posture.

NanoClaw’s Distrust-by-Design AI Agent Security Model

Estimated read time: 8 min

Taking that containment philosophy further, NanoClaw treats AI agents as inherently untrusted through three layers: per-agent container isolation, mount allowlists, and fresh containers destroyed after each invocation. At 3,000 lines versus OpenClaw’s 400,000+, the architecture prioritizes simplicity to minimize attack surface.

Key point: The 3,000 vs. 400,000 line comparison is striking. In agent security, a smaller codebase you can actually audit may be more secure than a comprehensive one you can’t.

TOOLS

Helm: Two Tools Replace Dozens for AI Agents

Estimated read time: 8 min

Helm is a typed TypeScript framework that collapses agent tool sprawl into two operations: search and execute. Agents discover capabilities on demand, sandboxed via SES with granular permissions. Inspired by Cloudflare’s 99.9% token reduction through search-plus-execute architecture, it ships with filesystem, git, and shell skills.

What this enables: Instead of registering dozens of tools that bloat context windows, you give agents two generic tools and let them discover what they need. A compelling pattern for any agent framework.

Amp Abandons Editor Agents for CLI-First Approach

Estimated read time: 6 min

Also rethinking how agents interact with codebases, Amp discontinues their VS Code and Cursor extensions to go all-in on CLI. Their argument: with GPT-5.3-class models, the agent wrapper is no longer the bottleneck. The real constraints are now how organizations structure codebases and workflows for agents.

Why now: This signals a broader industry shift. As model capabilities outpace tooling, the competitive advantage moves from clever agent wrappers to how you organize your codebase for AI consumption.

Garry Tan’s Structured Plan Review Framework

Estimated read time: 5 min

Y Combinator’s Garry Tan shares a plan-exit-review skill that structures code evaluation into four phases: Architecture, Code Quality, Tests, and Performance. It begins with a scope challenge, then walks through opinionated recommendations with concrete tradeoffs rather than neutral option menus.

The opportunity: Drop this directly into your Claude Code or Codex workflow as a reusable skill. The scope challenge step alone can save hours by preventing over-engineering before a single line is written.

Free Claude Max for Open Source Maintainers

Estimated read time: 3 min

On the Anthropic side, Claude for OSS offers six months of free Claude Max to open source maintainers. Eligibility targets repos with 5,000+ stars or 1M+ monthly NPM downloads, though maintainers of quietly essential ecosystem dependencies can also apply.

What’s interesting: Anthropic is explicitly welcoming maintainers who don’t hit the star count but keep critical infrastructure running. If that describes your work, the application is worth five minutes.

Continue Local Claude Code Sessions from Any Device

Estimated read time: 9 min

Also from Anthropic, Remote Control lets you continue local Claude Code sessions from phones, tablets, or any browser. Your session stays on your machine with full filesystem and MCP access. Web and mobile interfaces serve as windows into the local session, with automatic reconnection.

What this solves: Start a long-running agent task at your desk, walk away, and check progress from your phone. Eliminates the “is it done yet?” loop that interrupts deep work.

Vercel Chat SDK Unifies Cross-Platform Bot Development

Estimated read time: 4 min

Vercel releases Chat SDK, a TypeScript library for writing bot logic once and deploying across Slack, Teams, Discord, GitHub, and Linear. Features include type-safe event handlers, JSX cards that render natively per platform, and built-in AI SDK streaming for real-time responses.

The practical win: If you’ve built separate Slack and Discord integrations for an AI assistant, you know the pain. Write your bot once with native UI on every platform.

Nano Banana 2 Brings Flash Speed Image Generation

Estimated read time: 4 min

Shifting from code to pixels, Google introduces Nano Banana 2, combining professional-grade image generation with rapid processing. The model features advanced world knowledge, consistent subject representation, and production-ready specifications at flash speed for applications that need quality without sacrificing latency.

Why it’s relevant: Speed is the bottleneck for image generation in production apps. Flash-speed processing with pro quality opens up use cases that were previously too slow for real-time user experiences.

NEWS & EDITORIALS

Hiring Engineers When AI Writes the Code

Estimated read time: 6 min

Tolan shares their redesigned engineering interview where candidates build solutions using AI assistants like Claude and Cursor. The key insight: AI has not changed what distinguishes great engineers. What matters is architectural judgment over implementation speed, recognizing trade-offs, and understanding every line you ship.

The career signal: Whether you’re hiring or interviewing, this reframes the conversation. AI makes judgment and communication more valuable, not less. A reassuring data point for senior engineers navigating the shifting landscape.

OpenClaw Creator: Be More Playful Building AI

Estimated read time: 5 min

On the builder side, Peter Steinberger, creator of the viral AI agent OpenClaw, advocates for a less rigid approach to development. His core advice: be more playful and allow yourself time to improve, letting experimentation and iterative refinement drive better outcomes.

What’s refreshing: In a space dominated by optimization talk, this is a reminder that the best agent builders are treating this moment as a creative frontier, not an engineering sprint.

Intelligence Yield Reframes How We Benchmark Models

Estimated read time: 5 min

Shifting from people to models, Intelligence Yield (IY) measures how efficiently AI models convert compute into useful work. Using METR benchmark data, the framework tracks which frontier models solve harder tasks more reliably with less compute, with IY=1.0 marking parity with human work rate.

The shift: As you choose between models for agent workflows, raw capability benchmarks tell only half the story. IY gives you a cost-efficiency lens for comparing what you actually get per dollar of compute.

Build for Agents: Karpathy on CLI-First Products

Estimated read time: 3 min

Andrej Karpathy argues CLIs are ideal for AI agents because they are “legacy” technology agents can natively use. He demos Claude building a Polymarket dashboard in three minutes, then challenges: does your product offer markdown docs, Skills, CLI access, or MCP integration?

The rallying cry: “Build. For. Agents.” Karpathy’s checklist of markdown docs, Skills, CLI, and MCP gives you a concrete framework for making any product or service agent-accessible today.

A few months ago, for me, this would have been five terminal windows, five mental threads to track, and a constant low-grade anxiety about which session was doing what. The terminal-per-agent workflow works right up until the cognitive load of managing it doesn’t. What changed wasn’t discipline. It was tooling.

The tool making this possible is Conductor. I’ve been using it daily for about a month, and while the tool itself is worth examining, what it represents might matter more. Conductor is one of the first purpose-built applications for a workflow that didn’t exist two years ago: managing multiple AI coding agents simultaneously, reviewing their output, and merging results into your codebase.

It’s not an IDE. It’s not trying to be. It literally has a button to send you out to your preferred editor when you need to do IDE work. That distinction hints at a new kind of tool entirely, one built not for writing code but for managing the things that write code.

I want to be clear about my position here. I’m not being paid by Conductor. I don’t have a stake in their success. I’m a developer who’s been exploring AI coding tools full-time, and Conductor is the tool that stuck in my daily workflow. What follows is an honest assessment of what it does, what it doesn’t, and why I think it signals something bigger than itself.

What Conductor Actually Does

Conductor is a macOS desktop application that wraps Claude Code in a GUI designed for parallel AI-assisted development. At its core, it solves a specific problem: running multiple Claude Code instances in parallel without them colliding. It does this through workspaces, isolated copies of your Git repository, each on its own branch. You spin up a new workspace, give the agent a task, and it operates on its own copy of the codebase. Changes from one agent never interfere with another while they’re working.

Conductor uses the official Claude Code SDK, not a custom harness. As one of the team members confirmed publicly: it’s the same quality as native Claude Code, with an orchestration layer on top. Recently they added OpenAI Codex as a selectable model alongside Claude, which the team describes as useful for precise, surgical edits that complement Claude’s broader reasoning.

The application is currently free, funded by seed capital from Y Combinator, with future monetization planned around team collaboration features.

The Workflow in Practice

Read more