I'm not sure what the joystick is for, and neither are they apparently: the only example they give is something that could just be a keybind.

Notice I didn't use the word motivation, which you decided to use. The reason LLMs use a technique is simply because it works, and that comes straight from training (specifically RLVR post-training).

One reason I'm in favour of handling capabilities in the OS is so we can stop having trivial symlink traversal and /.. traversal bugs in path filters (or indeed more complex bugs in the face of FS-specific linking primitives).

I've found them useful to review docs for factual consistency and potential sources of confusion, but the correct workflow from that point is IMO to correct the draft yourself and then say "better now?"

Non-reasoning models were still surprisingly good at generating working programs. I think it makes sense when you consider that it's still iterative; it doesn't have to generate the entire import block in a single pass, for example, more like decide at the end of each line whether there are more libraries it should import or whether to move on to the body of the program. It's less surprising that a single forward pass is able to make that type of decision IMO.

Taking Python as an example, you see LLMs use a lot of scoped imports and I think this is partly because it makes the output more resilient against failure to think forward at the start. Even a reasoning model will write out (the first iteration of) an entire file in one tool call, so once it starts generating it still has to keep going until it finishes, no pausing for breath.

Also it's interesting that non-reasoning models can still do quite well in a harness that lets them test and fix up their code. Like you said, it gives them the ability to iterate.

If you keep RL'ing the dispatch then the prompts are likely to keep diverging from the type of prompt a person would write (like CoT becoming increasingly incomprehensible), and that divergence is part of their competitive advantage.

> rather a latent space representation of the conversation

Student/teacher models derived from the same checkpoint convey a lot of latent information through token choice, as in: https://techxplore.com/news/2026-04-ai-chatbot-student-owls....

I wonder if this is something they can take advantage of by training on compaction inside of the RLVR loop?

Thanks, this answers my question and does sound handy. Also I do see the value in having more problem-shaped versions of a general construct.

If I ask an agent to maintain agent-facing docs like AGENTS.md then similarly it ends up with low information density and not really saying what I want it to say. Something I thought was unequivocal ends up leaving the agent with far too much scope for interpretation and judgement calls.

Perhaps I'm just Prompting It Wrong (TM) but I do find LLMs lack the theory of mind to realise that other LLM instances don't know the things that the current instance knows, and make poor calls on what to include and what not to include. It's a bit hand-wavey, but I was wondering if the same issue might transfer to language design.

> and the runtime requires explicit permission to touch the filesystem, network, etc

This feels like more of an OS problem (or library problem) than a language problem.

> Run one program against many worlds. The same code can run against the real network, a scripted fake, a recording of last week's traffic, or a probability model of how servers usually behave

How is the "world" model different from plain dependency injection?

Warts and ancient quirks, I can kind of see, but in what way have LLMs solved the footguns?

I think the popular use of distill (one-hot rather than logits) is not due to Anthropic but due to the DeepSeek-R1 tech report: https://arxiv.org/abs/2501.12948

This is interesting because when I was 7-8 my mum just recommended me whatever books she was reading, some of which were quite... adult in retrospect, and I turned out mostly well-adjusted.

Kids aren't LLMs, they know that what they're reading is fiction. Maybe reading something like that would be a fun way to start a conversation about it?

> The commit-message tax.

> Git demands prose on every commit. You burn tokens writing "wip", "fix", and "address review", messages no human will ever read, just to checkpoint your own progress.

Yes, making agents describe their work in a way that is readable to humans and other agents is clearly a bottleneck that must be fixed.

What is this garbage? The only thing I agree with is that worktrees kind of suck (usually once submodules are involved).

llama.cpp's Metal backend does use them when they're available.

I use a local Qwen3.6-35B-A3B (@ Q4_K_XL) for my documentation search harness. It works well for its assigned task, which is:

- I dump in a bucket of PDFs and/or source code.

- I ask a question.

- Qwen greps, fuzzy-searches, views rendered PDF pages to check diagrams, possibly gives up and reads everything, and possibly gives up on that too and writes its own scraper with PyMuPDF in a Pyodide sandbox.

- Qwen gives me an answer consisting mostly of citations and links back into the source material.

This approach with local Qwen can extract useful answers from the Armv9-A manual, which at 17k pages is possibly too big for any context window. Qwen has just enough knowledge baked in to know what to search for and understand what it's looking at. A more knowledgeable model would be a waste because even Fable makes shit up, and I want citations, not hallucinations.

DeepSeek v4 Flash gets an honourable mention: somehow all three of fast, capable and cheap. Zero-data-retention providers are available for both GLM-5.2 and DSv4F. I trust OpenRouter ZDR about as much as I trust Anthropic ZDR, since I can audit neither.

Overall I don't miss my Claude subscription, but take what I say with a grain of salt. I was just a Pro subscriber, not a heavy user like some other folks here.