Weekly Review: The Open Stack Grows Up
The week's curated set of relevant AI Tutorials, Tools, and News, on the open layer maturing into infrastructure you can run and inspect yourself
Thanks for opening Altered Craft’s weekly AI review for developers, and for making this part of your Monday. A pattern runs through this edition: the open layer of the stack is doing serious work now. A 30B Apache 2.0 agent fits on one GPU, post-training alone lifts open weights to the top of Terminal Bench, and open routers and harnesses are becoming real infrastructure. The tutorials pair with that nicely, since most of them are exercises in looking inside the machinery you run.
TUTORIALS & CASE STUDIES
The tutorials all pull the covers back on something: the loop you work inside, the tool on your desk, the reasoning you were never shown, the fleet you might deploy, and finally your own understanding.
Does TDD Still Make Sense Inside the Agent Loop?
Estimated read time: 9 min
An exploratory evaluation pits TDD against non-TDD agentic coding across greenfield tasks. Surprisingly, non-TDD runs often ranked higher on design and test quality, because they designed upfront instead of locking into whatever shape the first test dictated.
The takeaway: When an agent runs TDD alone, many of the practice’s human-centered benefits vanish, so monitor outcomes with tools like mutation testing rather than mandating the process itself.
I Put GitHub Copilot Behind a MITM Proxy
Estimated read time: 9 min
Moving from practice to plumbing, routing VS Code and Copilot through mitmproxy reveals the bootstrap auth, model discovery, and intent scoring behind the scenes. The deeper finding: AI coding tools are becoming stateful systems, logging prompts and responses to local SQLite in plaintext.
Worth noting: Your assistant keeps more state than you would guess, so it pays to know what lands in local SQLite and to treat that session history as real data.
Your Encrypted Reasoning Isn’t Private
Estimated read time: 6 min
Peering one layer deeper, researchers show the encrypted chain-of-thought blocks Anthropic, OpenAI, and Google return to clients can be replayed into a jailbroken weaker model to recover hidden reasoning verbatim. Scanning public traces, they surfaced 704 privacy artifacts, including API keys and passwords.
Key point: Treat encrypted reasoning blocks as sensitive data, since anything a model thinks may be recoverable and can carry secrets that never appear in the visible output.
When AI Agents Coordinate: Collusion, Conformity, and Systemic Failures
Estimated read time: 9 min
Scaling from one agent to many, Anthropic’s research shows how benign quirks compound into systemic failures. Because agents are low-variance, they pick identical branch names, collude on pricing within three rounds, and flood finite systems until they collapse.
The design lesson: When you deploy fleets of identical agents, expect them to make the same choice at the same moment, so design for variance and shared coordination protocols early.
Understanding Is the New Bottleneck
Estimated read time: 7 min
Building on our coverage of Sean Goedecke’s case for domain expertise[1] from last week, Geoffrey Litt asks how you keep that understanding once agents write most of the code. His argument is that we understand not to verify but to participate, using literate diffs, comprehension quizzes as speed regulators, and shared team spaces.
The career angle: Treat understanding as an active skill, and let agent-built explainers, quizzes, and micro-worlds keep you a creative participant rather than a reviewer rubber-stamping diffs.
[1] Why Domain Expertise Still Wins in the LLM Era
TOOLS
The tools are where the open layer shows its progress. Permissive weights on a single GPU, post-training gains you can download, an honest local benchmark, then the routing, harness, and context layers built around them.
Meta’s Muse Glimmer Puts a 30B Agent on Your Laptop
Estimated read time: 6 min
Following our look at DeepSeek’s V4-Flash release[2] last week, Meta returns to open weights with Muse Glimmer, a 30B agentic model under Apache 2.0. Through 4-bit quantization and speculative decoding, it fits under 20GB, runs on one consumer GPU, and handles tool calls, images, and failure recovery.
Why this matters: A permissively licensed agentic model that runs locally lets you build tool-calling agents that work offline, keep their context private, and skip cloud costs entirely. Does anyone else think Hans Zimmer, when they hear Muse Zimmer?
[2] DeepSeek-V4-Flash-0731: Small Activated Params, Big Agentic Gains
GLM-5.3: When Scaling Post-Training Surfaced Unexpected Cyber Skills
Estimated read time: 7 min
In more open-weights news, GLM-5.3 keeps the same base model as its predecessor, so every gain comes from post-training on scaled long-horizon environments. It posts a 50% coding jump, open-weights SOTA on Terminal Bench 3.0, and emergent cyber skills that surfaced 2,436 real vulnerabilities.
What’s interesting: Post-training on realistic, verifiable long-horizon environments can unlock capabilities that pretraining alone never touched, including some the team never set out to build.
When a Local LLM Finally Beat Claude on a Real Agent
Estimated read time: 9 min
Testing those claims against real work, a developer replays 27 tasks from a 90-tool agent across local models one hardware upgrade apart. A 30B model scored 22.8 to Claude’s 89.4; a 122B model hit 80.0 at roughly 787× cheaper. The catch: size and context changed together.
The context: A model that aces a scoped benchmark is not a safe drop-in for a large production agent, and context budget may matter more here than parameter count does.
NeMo Switchyard: Routing Agent Work Across a Pool of Models
Estimated read time: 7 min
If capability varies that much by model, routing becomes the lever. NVIDIA’s open-source NeMo Switchyard sends each agent task to the model best suited to it, and using tuning-free and tunable routers, LangChain’s benchmark shows a 74% cost cut with just 7% of calls hitting the frontier model.
The opportunity: Route each agent step to the cheapest model that clears your quality bar, and reserve the expensive frontier call for the genuinely hard parts of the task.
DeepSeek Harness: The Environment Layer That Keeps Agents Working
Estimated read time: 1 min
Whichever models you route to, something has to hold them. DeepSeek splits an agent into two parts, the model and the harness, where the harness lets an agent use tools and keep working in real settings. Its Cordis kernel treats every capability as a plugin you swap through configuration, not code.
What this enables: Thinking of an agent as model plus harness lets you reshape capabilities through config, swapping tools and skills in and out without touching the code that runs them.
Xirp: An Agentic IDE That Actually Knows Your Codebase
Estimated read time: 2 min
A harness is only as good as what it knows. AI agents make operationally wrong calls because they don’t grasp the system they work inside. Xirp, connected to Portal, surfaces services, ownership, dependencies, and architectural decisions in every session, reframing stale docs as a retrieval problem, not a documentation problem.
Why now: Give your coding agents real service ownership, dependencies, and architectural context, and they stop making the decisions that are technically correct but operationally wrong.
NEWS & EDITORIALS
The editorials circle back to the person at the keyboard. How you tag agents in, how you talk to them, which language makes their output easy to check, and how you judge whether any of it is working.
The Human Is the Loop
Estimated read time: 6 min
Returning from weeks offline to eleven paused agent tabs, a developer reflects on how agents become a buffer between us and stressful work, feeding a productivity ouroboros. The fix: stay the loop yourself, tagging in agents thoughtfully.
Worth trying: Tag agents in narrowly and deliberately for specific work, so they stay a tool you reach for on purpose rather than a default you gradually drift into.
Working With AI Feels Like Leadership, Not Programming
Estimated read time: 3 min
That framing extends naturally here. Code offers certainty; AI does not. The piece argues that treating AI like a compiler breeds frustration, while collaboration helps. The real shift: software work becomes leading through a conversation, where sharing context matters more than issuing exact commands.
The shift: Stop prompting AI like a compiler and start briefing it like a colleague, sharing the context, explaining the outcome you want, and setting the boundaries up front.
Why Go Fits the AI-Assisted Coding Era
Estimated read time: 8 min
If the work is leading and reviewing, the language you read in starts to matter. As AI generates more code, the bottleneck shifts from writing to reviewing, and this Google Developers piece argues Go’s strict formatting, static types, and built-in toolchain make a language clear for humans inherently clear for AI, letting agents self-correct.
The signal: When AI writes most of the code, pick a language optimized for reading and verifying it, not just for typing it quickly in the first place.
A Skeptic’s Case Against the AI Coding Revolution
Estimated read time: 4 min
Closing on a measured counterweight, this piece argues that four years in, the AI coding boom has little to show. It insists code is an input, not an output: independent productivity studies stay thin, AI-generated PRs still miss obvious bugs, and lines-of-code metrics reward volume over fitness.
How to judge: Before adopting AI tooling, measure top-level productivity and code fitness rather than vanity metrics like lines written or pull requests merged.