Pretty much every organization finds it easy to reward “productivity” as expressed by lines of code emitted, but the benefits of doing thorough and thoughtful design, analysis, and code review very difficult to reward. In this world, an LLM is an invaluable tool for the sociopathic ladder-climber, particularly if your legacy organization is still structuring their workflows as if the person prompting the bot is “writing” the code, and then they get to foist off the act of “reviewing” the code onto someone else. / Here, the prompter effectively externalizes the cost of the LLM’s failures but internalizes any benefits.

When a student is asked to write an essay, the teachers see the effort as both intrinsically worthwhile for the student, as well as useful as a pedagogical tool to evaluate and react to the student’s progress. The student, by contrast, sees a stumbling block designed to knock them off the path to success and into a permanent underclass.

via: https://liamoc.net/forest/2026-W26/index.xml

With reference to SNAP as an illustration

What lets the same algorithm work across all three domains is that they share two key properties:

1. Closure under negation and intersection — so the difference between two candidates is itself expressible.
2. Sampling from that difference — so the system can show the user concrete cases where the candidates disagree.

This is just Ought’s Factored Cognition paradigm again, just now contrasted with the currently popular agent paradigm. A bit disappointed that he didn’t cite prior art.

Apparently, he’s now doing AI systems research at a showy VC fund? :/

You probably recognise these things as good, but a surprising number of managers seem to think they can just chastise people until quality improves. They talk themselves into this because they believe line workers are fully responsible for their actions.

But even those managers will find it very hard to convince themselves quality improves when they scream at the code-generating robot. It’s a robot! It can’t be responsible for its actions. We have to adopt the lean philosophy for building systems around robots. When something goes wrong, we have to blame the process, not the robot.

We always had to do that, even with people, but with robots it’s painfully obvious.

Agents can make one-off apps, but they’re usually toys. I show how we might bring malleability and composability to the kind of deep interfaces that experts live in all day—demonstrated in a writing environment, but applicable to all serious software. Little serious reading software exists, so I propose and demonstrate a new kind of malleable digital reading environment focused on expert use.

But malleable interfaces aren’t enough. Historically, inventing interfaces has required imaginative design skill, deep domain insight, and fluent programming. Few have all three, but programming is the only skill that can produce working software on its own—so interface invention culture is dominated by programmers. I share early reports of how coding agents are changing that, and what it might mean for the people and institutions inventing interfaces today.

In summary: the thing that keeps language models flexible is the same thing that makes them act like hash functions is the same thing that makes language itself fractal is the same thing observed empirically through basin maps. It’s one phenomenon wearing at least four costumes.

How language model agents manage memory through compaction and session types, why they lose context, and how runtime self-knowledge and document pinning prevent context drift.

via: https://johncarlosbaez.wordpress.com/2026/03/11/a-typed-language-for-agent-coordination/ see: https://johncarlosbaez.wordpress.com/2026/03/20/the-agent-that-doesnt-know-itself/

Introduction to the plumbing calculus: a statically typed language for designing and verifying multi-agent systems using category theory, with applications to adversarial document composition and ensemble reasoning.

Yeah yeah, LLMs are dumb and all that, but this is is actually a really beautiful and practical example of how to put categories in control. Honestly, this what I would want the syntax of CatCollab to look like. Great string diagrams, too.

see: https://leithdocs.com/ldc/documents/outgoing/plumbing/typed-language-for-agent-coordination.md

Soon, we’ll feed requirements to AI and get working software without writing code. But when cars replaced horses, the horses never had to debug the cars.

A computer can never be held accountable

Therefore a computer must never make a management decision