Linklog

Dan Austin built a pipeline where an agent is handed a training task (“teach a model to do X”), writes a complete RL training job (environment, reward, dataset, hyperparameters), and submits it to real GPUs. Then he RL-trained the agent itself, rewarding it when the models it trained got better. Reward climbed from about 0 to 0.63 over 54 steps, and transferred to a held-out task family. Everything is open-sourced, including write-ups of the failed pilots.

Sumuk’s field notes on GPT-5.6-Sol: “the most OCD model I’ve used”, frequently one-shotted by random nits in the codebase, prone to writing piles of tests to fix them, and slow at this iterative fussing even in fast mode. Model reviews measured in billions of tokens of daily use are becoming their own genre, and often say more than benchmarks.

On your own machine an agent leaves two bad options: approve every command and babysit the prompt, or --dangerously-skip-permissions and hope nothing is one rm -rf from disaster. Clawk is the third option: cd into a repo, type clawk, and Claude Code (or Codex, or a shell) works inside a disposable Linux VM with your code mounted. The agent gets full autonomy inside walls, instead of limited autonomy on your laptop.

The HN discussion asks the obvious question (why not just Docker: answer, kernel isolation), jokes about agents escaping container jail, and reveals a crowded field: Fly Sprites, virtdev, take-ai-control. Agent sandboxing is having a moment.

Can Bölük analysed token distribution across about two million agent tool calls: 91 per cent of tokens go on reading the codebase, 9 per cent on edits. That kills the intuitive plan-with-a-frontier-model, implement-with-a-cheap-model split, because the cheap executor has to reread everything the frontier model already read; in his tests the split actually cost 14 per cent more than the frontier model working alone. A plan document is “a literal postcard, describing a journey to a model that never took it”.

Their fix, prewalk, hands over the frontier model’s actual context window after its first successful edit: 92 per cent of the performance at 53 per cent of the cost.

Steve Krouse’s problem with spec-driven development: most software can’t be specified up front, because “software is a creative act, where you figure out what you’re building as you build it”. You need your hands in the details, reacting to incremental versions.

A useful tension with the constraints school (constrain the agent, Uncle Bob’s gauntlet): constraints assume you know what to constrain.

A visualisation tool that replays coding-agent sessions on a 3D map of your codebase. Watching where the agent walked, file by file, is a novel angle on the understanding problem: not reading the diff, but seeing the journey that produced it.

Salvatore Sanfilippo: many devs aren’t maximising automatic programming because they still look at the code. “Doing it makes you the bottleneck. Your time is better invested in new ideas, QA, design, and asking yourself what is your goal.” Striking from the author of Redis, a codebase famous for being read line by line.

Same camp as Uncle Bob, and the opposite of the short leash method.

Dax Raad: being in the loop matters, but people misread what the loop is for. Your job isn’t to micromanage the agent into executing steps the way you would; “it’s to come up with cool things for it to work on”. A neat one-line answer to the bottleneck question Patrick JS raised: deciding what should exist.

Anthropic researchers find a “J-space” in Claude: a small set of word-linked patterns that behaves like the global workspace of consciousness research. Claude can report what’s active in it, modulate it on request, and use it to mediate multi-step reasoning, while routine processing bypasses it entirely. It emerged in training rather than by design. Useful for safety (a lens onto hidden thoughts, like recognising test scenarios or fabricated data), and provocative on the question of access consciousness, while claiming nothing about phenomenal consciousness.

The Claude Code team’s taxonomy of loops, pinning down a term the discourse had left fuzzy: agents repeating cycles of work until a stop condition is met. Turn-based (the ordinary agentic loop), goal-based (/goal with an evaluator model checking your stop condition: “get the Lighthouse score to 90, stop after 5 tries”), and time-based (/loop and /schedule for recurring work or polling external systems). The practical advice: encode your manual verification steps as skills so the agent can check its own work end to end, and make the checks as quantitative as possible.

Patrick JS: agents are solving coding, not engineering, and engineering is exactly where the current problems live: taste, judgment, constraints, systems thinking. “The bottleneck didn’t disappear. It moved from ‘can you write the code?’ to ‘can you tell what should exist?’”

The poster can’t reach flow state with coding agents: “a bicycle that just brakes abruptly every couple minutes. I stop, wait, review, prompt again.” The thread is a good sample of 2026 workflows people have built around the problem: TODO files as free-text prompt queues, JSX templating languages for context piping, custom harnesses running in VMs with their own email accounts and Linear boards, and agents generating diagrams of their changes at different abstraction levels to speed up human understanding.

Greg Slepak’s counter to full delegation: plan and break down tasks first, review every diff before granting permission, never YOLO mode, commit after each subtask, and require AI-assisted PRs to be self-reviewed before human review. “You keep yourself in the loop at all times instead of removing yourself.” His claim is that even Fable 5 writes inefficient, ugly code without active oversight.

The direct opposite of Uncle Bob’s approach: maximum cognitive coverage, paid for in speed.

The HN discussion split neatly: half thought this is just how anyone serious already works (“are you guys just YOLOing everything these days?”), half thought it’s slower than writing the code yourself, plus a jab at the genre of AI-workflow advice written after a couple of months of personal use.

An AI code review platform built around stacked PRs: break large changes into small sequenced ones, have AI review each, and merge through a stack-aware queue. Used by Shopify, Ramp and Asana. Bookmarked as the strongest productised bet that code review stays central in the agent era; the opposite wager to Gergely Orosz’s observation that reviews are fading.

Patrick Nadeau at Autodesk Research argues that spec-writing discipline puts the burden on the wrong side: build constraints into the agent’s environment instead. He sorts them into three kinds: generative (tests, and especially test oracles that compare against a reference implementation), interpretive (give the agent a debugger so it can test its hypotheses about existing code), and elicitative (have it interview stakeholders to resolve ambiguity before implementing). The common thread is grounding the agent’s output in an external source of truth.

Same instinct as Uncle Bob’s gauntlet of constraints, but engineered into the system rather than bolted on.

Matt Pocock reports that /writing-great-skills, a skill whose job is writing other skills, has become his most-invoked one. Pleasingly recursive, and a signal of where agent customisation is settling: the skill file as the unit of teaching an agent how you want things done.

Chantal Kapani on the gambling-machine quality of AI coding: intermittent rewards, an immediate next step to every problem, and no natural stopping points. 45 per cent of engineers report working more hours than last year, and CTO burnout has more than doubled. Steve Yegge compares the random rewards to casinos: “your brain gets a chemical bath”. Suggested defences are unexciting but sane: time-box sessions, separate exploration from execution, treat recovery as maintenance.

Sam Rose hand-ported the core of Kubernetes to TypeScript so it runs entirely in the browser: pod lifecycle, cluster networking, DNS and deployment controllers, about 100,000 lines written with LLM assistance, every line reviewed, and 2,000-plus tests checked against a real k3s cluster. It ships at roughly 140KB gzipped and exists to power interactive Kubernetes tutorials. A nice data point for what one developer educator can now build with agents.

The HN discussion found the workflow more interesting than the artifact: the review discipline and testing against a real cluster is what separates it from vibe slop, with one commenter suggesting we’re on the cusp of only needing to read the tests. That, and the inevitable jokes about Kubernetes complexity.

Suhail Doshi has stopped reading interesting posts, tweets and papers in the moment. Everything gets queued, and when he has a block of time (in an Uber, before bed) he asks an AI to teach him each item with a specific prompt, instead of doomscrolling. A simple reframe: treat the feed as an inbox, and use the model to turn each item into a lesson.

A free handbook of the unglamorous fundamentals of building financial software: representing money (precision, rounding, currency, FX), double-entry ledgers, value time versus booking time versus settlement time, immutability and audit trails (and how that squares with GDPR), idempotency and full resumability of money flows, reconciliation, and controls like four-eyes and segregation of duties. Appendices walk end-to-end flows such as a crypto withdrawal. The kind of domain knowledge that usually lives only in the heads of people who’ve been burned.

In the HN discussion, a fintech veteran vouches that it matches five years of hard lessons (answering the now-obligatory “is this AI slop?” question), and the sharpest thread warns against using minor-units integer amounts as an interchange format, however clever it feels.