Weekly Review: Shape It Yourself
The week's curated set of relevant AI Tutorials, Tools, and News, on open weights finding a business model and the growing value of what you bring to the model
Hello, and welcome to Altered Craft’s weekly AI review for developers, with thanks for making this part of your week. Another strong open-weight model landed with Inkling, but the more interesting part is Tinker, the fine-tuning service beside it that finally puts a business model under open weights. Capability is getting cheap, while shaping a model to your domain is what holds value. The picks below follow that thread.
TUTORIALS & CASE STUDIES
The tutorials all circle one question: what do you bring to the model? Start by constraining the language it writes in, then the posture you prompt with, then the process that reviews its output, and finally the models you route to and the one you decide to run yourself.
Why DSLs Are the Sweet Spot for LLM Code Generation
Estimated read time: 7 min
Start with the language the model writes in. Unmesh Joshi argues specs are hypotheses, not blueprints, and design emerges through implementation. His core claim: DSLs make LLMs more reliable because their constrained syntax responds to a few examples and ships with deterministic validators, shown via PlantUML and the Tickloom framework.
The takeaway: Pair LLMs with a small, well-factored DSL backed by a validator, and you get reliable generation plus domain-level error feedback the model can self-correct against.
Tourist vs. Archaeologist: Prompting AI Through a Legacy Codebase
Estimated read time: 8 min
Shifting from the model’s language to your own posture, asking an LLM “how do I run this?” on crumbling legacy code yields a confident, hallucinated “Starter Kit” that hides the rot. The fix is to act like an archaeologist, not a tourist: run forensic audits and build Docker “time capsules” first.
The practice: On brownfield code, prompt the AI to be a critical forensic auditor rather than a helpful tour guide, and containerize the original environment before you change a single line.
Rewriting Bun in Rust, One Adversarial Review at a Time
Estimated read time: 11 min
Scaling that discipline to an entire migration, and facing recurring memory-safety bugs, the Bun team ports 535,000 lines of Zig to Rust using roughly 50 Claude Code workflows over 11 days, relying on split-context adversarial review and fixing the process that generates code, not the code itself.
Key point: When merging large volumes of LLM-authored code, separate the implementer and reviewer into distinct context windows and fix the workflow rather than patching individual outputs.
Better Call Sol: The Workhorse Model Roundup
Estimated read time: 11 min
With the process settled, the question becomes which model runs it. This roundup weighs a fictional near-future GPT-5.6-Sol against Fable, arguing that Fable stays the architect while Sol is the workhorse. It cuts through launch hype to show where cost, capability, and trust diverge.
The pattern: Route planning to your smartest model and execution to the cheaper workhorse, but send hard queries to both and compare.
A Zero-Trust AI Code Reviewer That Never Leaves the LAN
Estimated read time: 11 min
Taking a different approach from routing across frontier models, this tutorial keeps everything on the LAN, building a local review pipeline with GitLab CI/CD, Ollama, and Qwen3-Coder-30B, where a self-correcting LangGraph loop validates and retries JSON output to produce reliable inline suggestions.
What this enables: Wrapping an open-weight model in a retry loop that feeds validation errors back into the prompt turns unreliable JSON output into a production-grade review gate.
TOOLS
The tools split in two. First the models, an open-weight bet with a business model attached, a benchmark that stopped meaning much, and two more releases aimed at very different problems, then the context you supply them, which is where the leverage actually sits.
Thinking Machines Bets on Open Weights With Inkling
Estimated read time: 4 min
Following our look at Tencent’s open-weight MoE[1] from last week, Mira Murati’s Thinking Machines Lab ships Inkling. The wager: AI that organizations shape themselves beats one-size-fits-all. Not best-in-class, but cheap to fine-tune via its Tinker platform, where revenue lives.
Why this matters: If your domain expertise is your edge, fine-tuning an open-weight model may beat renting metered access to a frontier chatbot.
[1] Tencent’s Hy3 Lands as a Punchy Open-Weight MoE
The Pelican Benchmark Meets Kimi K3
Estimated read time: 4 min
Also arriving open and cheap, Moonshot AI’s Kimi K3 lands with 2.8 trillion parameters and Claude Sonnet-level pricing. Running it through the SVG pelican test reveals one “max” reasoning mode and heavy token spend, but the real point: the pelican no longer tracks model quality.
Worth noting: Fun single-prompt tests are useful for confirming a model works, but judge today’s models on agentic tool calling over long conversations, not vibes.
Meta Ships Muse Spark 1.1 With a Million-Token Agentic Focus
Estimated read time: 5 min
Shifting to the frontier, Meta Superintelligence Labs introduces Muse Spark 1.1, a multimodal model built for agentic work with a million-token context it actively manages. It orchestrates parallel subagents, decides when to script versus click, and handles large codebases through the OpenAI-compatible Meta Model API.
The opportunity: If you’re building agents that span coding, tool use, and long-running workflows, the Meta Model API preview gives you a low-friction way to test a million-token model against your real tasks.
NVIDIA Cosmos 3: One Model for Physical AI
Estimated read time: 12 min
Also open but aimed elsewhere, NVIDIA Cosmos 3 is a suite of omnimodal world models that jointly handle language, images, video, audio, and action in a unified Mixture-of-Transformers architecture. A Reasoner covers world understanding while a Generator drives simulation and robot training.
What’s interesting: Cosmos 3 collapses vision-language models, video generators, and world simulators into one framework you can run locally today for Physical AI development.
OpenWiki Brains: Proactive Wiki Memory for Your Agents
Estimated read time: 6 min
Moving from the models to what you feed them, LangChain’s OpenWiki 0.1.0 adds a “Personal Brain” that connects Gmail, Notion, git, and X into a local Markdown wiki for agents. The pitch is proactive memory pulled from tools you already use, refreshed on a schedule.
Try this: Instead of re-pasting context into every session, wire your agents to a local wiki that quietly stays current with the sources you already work in.
deja: A Local Search Layer for Your AI Agent History
Estimated read time: 9 min
Similarly mining context you already have, coding agents log every conversation locally, leaving gigabytes of solved problems you can’t search. deja is a zero-dependency Go binary that indexes histories across Claude Code, Codex, and Cursor into a searchable memory layer with sub-15ms search and MCP recall.
Why now: Point deja at your existing agent logs and your assistant can recall past fixes instead of solving the same bug twice.
NEWS & EDITORIALS
The editorials work outward from the market to the person. Open weights won on cost, the labs may not capture the value they create, and what’s left as leverage is the part you supply, your ideas, your judgment, your taste, along with the fatigue of supplying it.
The State of Open-Source AI: Parity Reached, Operations Still Hard
Estimated read time: 11 min
Extending our coverage of the open source AI stack map[2] from last week, this Mozilla report argues open weights closed the capability gap as inference costs collapsed 50×. Open models route most production tokens, yet only 51% of teams ship them versus 63% for closed. The bottleneck isn’t capability, it’s operations.
The stakes: Open models have won on cost and capability for most workloads, so the real decision is whether your team can carry the operational burden of deploying them.
[2] Mapping the Gaps in the Open Source AI Stack
Loving AI Without the Doom and Hype
Estimated read time: 3 min
Following that thread on where the value lands, this piece celebrates LLMs and coding agents while rejecting both doom and singularity hype. The core claim: frontier labs won’t capture the value they create, since progress rides Moore’s law, not proprietary genius.
The context: Treat AI models as another productivity tool in the compiler lineage, and tune out both the doom narratives and the superintelligence hype.
Stop Reading the Code, Own the Ideas
Estimated read time: 6 min
Turning from the market to your own practice, Redis creator antirez argues that as AI outpaces human review, developers gain more by controlling the ideas rather than scanning line by line. He favors trading exhaustive review for QA, design thinking, and human-readable DESIGN.md files.
The shift: Spend your hours defining architecture, testing, and documenting design intent rather than manually reviewing every line an LLM produces.
The LLM Critics Are Right. I Use LLMs Anyway.
Estimated read time: 9 min
Echoing that from Local-First Conf in Berlin, this piece sits in the dissonance of agreeing with LLM critics while spending heavily on tokens. The argument: LLMs amplify what you already have, so trust becomes the real currency, backed by concrete workflow patterns.
The principle: Use LLMs to sharpen your own thinking, not replace it, and gate their output through short human-readable artifacts you would defend out loud.
What Are We Automating: Human Tasks or Human Thinking?
Estimated read time: 7 min
On the other hand, there’s a limit to what you should hand over. Using Ken Liu’s story “The Perfect Match” and a real man who lets AI do his thinking, this essay probes the line between helpful automation and offloading not just tasks but agency.
Worth holding onto: Use AI to extend your thinking after you’ve formed your own hypotheses, not to skip the reasoning that makes decisions genuinely yours.
The Human in the Loop Is Tired
Estimated read time: 7 min
Ending on the cost of all that supervision, an honest account from inside Pydantic explains why AI-assisted coding feels more productive yet less satisfying. It names the fatigue of supervision and a broken reward loop, arguing taste and judgment matter more, not less.
The honest read: Treat your broken feedback loop as an engineering problem, not a personal failure, and lean into the judgment and taste that LLMs still can’t supply.