Gu-log Picks

Jarred Sumner rewrote 535K lines of Zig into Rust with 64 Claude agents in parallel, adversarial code review, and mechanical porting. 11 days later: all tests green, memory leaks fixed, binary 20% smaller.

The TypeScript team rewrote the entire compiler in native Go. Real-world tests show 8x to 12x faster compilation with lower memory usage. VS Code project compilation dropped from 125.7 seconds to 10.6 seconds. Time to first error in the editor went from 17.5 seconds to under 1.3 seconds.

Simon Willison learned from the Claude Code team fireside chat: instead of dictating rules, let Fable use its own judgment. Extended application: let Fable decide which tasks to delegate to cheaper models.

Anthropic engineer trq212 shares his methodology for coding with Claude Fable 5: the bottleneck isn't model capability anymore—it's whether users can surface their 'unknowns' before, during, and after implementation. Includes prompt examples plus HTML artifacts for visualizing blind spots and plans.

Phil Chen shares six years of career lessons — from his own startup through Helm AI, Scale AI, OpenAI, and Google: when agents can solve every well-defined problem, what stays valuable is finding problems, sprinting the last mile, and everything that cannot be graded by a loss function.

Geoffrey Litt asks a sharp question for the agent era: if agents can write and verify more code by themselves, why should humans still understand the code? His answer is that understanding is not only for verification. It is how humans keep participating.

AI can handle 80-90% of frontend work, but the remaining edges — depth, sensitivity to new platform features, and knowing when the stable default is not the best answer — are becoming the real moat. Fundamentals are not obsolete. They are compounding assets.

Fable 5 as the commander, Opus as the deep thinker, Sonnet as the grunt worker, Codex as the parallel-universe senior engineer — a multi-model orchestration setup inside Claude Code that reserves the most expensive brain for the most critical decisions.

Mitchell Hashimoto tries to define "taste": consistently making high-quality qualitative judgments where no objective metric exists. People say taste is worthless because it is easy to copy — but that proves the opposite: without someone with taste making the thing first, there is nothing to copy.

Open any agent skill and it's stuffed with 'be more detailed,' 'be thorough'—lines that look diligent but don't change the model's behavior at all. Matt Pocock names the no-op trap, plus how to spot a dead instruction versus one that actually pulls its weight.

Loop Engineering is the wrong name. The real work isn't the loop—it's the foundation nobody photographs: push 'what counts as correct' down to the cheapest enforcer, align granularity, lay a nine-layer sensor net, pay off comprehension debt. Execution went free; legislation got expensive.

In 2010 Princeton priced happiness at $75,000/year. A 2021 Wharton study found the ceiling gone. The 2023 joint reanalysis: money keeps working for almost everyone — except the unhappiest group, where it stops near $100,000. The real question: is your money deleting worry, or feeding the self?

Sakana ships Fugu: a multi-agent orchestration system behind one API, sold as "AI sovereignty." But a researcher who read the tech report tears it down — a closed orchestrator on closed models means you control less, not more, and it wins benchmarks while never reporting cost.

Someone called Ghostty "unusable" for taking a second to launch. Its author Mitchell Hashimoto replied with a textbook tradeoff lesson: the slow cold start is not a bug — it is cost paid up front to buy eight smooth hours. Are you optimizing a button you press once a day?

Big companies always have two camps: process people and outcome people. Over decades they barely learned to coexist — but AI shattered that balance. The outcome camp sees a chance to finally shake off the process camp; the process camp sees the AI-generated disaster coming.

As CTOs aggressively push AI coding, software engineers split into two classes: the lazy and the craftsmen. The lazy throw code up, never read it, never test it, never care. The craftsmen carry the whole review burden, watch quality collapse, and eventually become lazy too.

A guy spent two years doing every productivity tip out there, only to realize he had become "the most disciplined unproductive person alive." The problem was not a lack of effort — it was making the optimization system itself the goal, and forgetting to ask what it was all for.

Most coding-agent best practices from six months ago are now out of date. The new playbook: bigger tasks, longer sessions, and adversarial review so the agent verifies its own work — the engineer just shovels coal into the engine.

Every two hours, Codex drafts email replies for review. The drafts are good — he edits them anyway. Those edits are context too, and most automations throw them away. The fix: an inner loop brings context to the work; an outer loop recovers context from the review diff.

Loop engineering is sold as designing orchestration and spinning up agents — but the tools now do that half for you. The half still hard, still deciding the result, is the verifier. Anthropic's Bun port is the tell: 99.8% of tests pass, yet the announcement says not yet in production.