Bits and Bobs 4/6/26

If the former, then your business is now worth much less given LLMs.

If the latter, then there's no problem, and it's possibly even good.^[a][b]

The fundamentals of how software gets created are being reorganized as we watch.

For example, imagine getting a grant application reviewed.

Try to think of all of the other things in your category the reviewer will see.

Imagine the average of all of those.

That's your landscape you need to stand out from.

Whatever is surprising based on that baseline is your payload.

Your thing will feel automatically special to you, but that doesn't make it special to others.

But with an agent those two characteristics are disjoint.

It might recognize the jargon but not understand it.

It's already aligned with your conclusion (of course it is, you caused it to be created), so you give it the benefit of the doubt.

But another reader sees it from their own perspective, which will likely look at it from an angle.^[c]

"Below the API" is equivalent to "below the waterline."

Lilypads have almost all of their mass above the waterline.

It's one of the ways we learn.

As we get more individually capable will we be increasingly bowling alone?

To coordinate with other humans requires you to convince them.

If every actor agrees on a given "judgment call" then it's not a judgment call, it's straightforward and obvious.

LLMs are great at tasks that nearly everyone (with enough time and motivation) would agree on.

The more you can distill a problem in a form that LLMs can knock out of the park, the better.

You just want to not have to think about it.

As long as you trust the system will do a good enough job, you don't have to worry about it.

"Cognitive labor" means "I don't care how it gets done as long as it gets done.

In the loop means that a human is required for the loop to move forward.

On the loop means the human is able to correct the loop but it can move forward autonomously.

A massive difference in efficiency.

If you are in the loop you are the bottleneck.

You have to let go of the loop, so it can go arbitrarily fast.

When you let go of the loop your system can fly.

If you want to maximize the AI system's impact for you, you have to not be a limiting factor.

For example, when the internet goes out.

When it was below the API you didn't have to think about it, but when it's above the API it forces you to think of it.

In Victorian England, this is how an upper class person might feel about a lower class person.

Things that are above the API we have to think about.

We have limited mental capacity.

That means that there's a natural (low!) ceiling for things above the API.

When you move the agent swarm below the API, you can now have many more items without hitting that scaling factor.

This is one of the insights at the core of Getting Things Done.

When you have an open loop, part of your mental energy is spent keeping track of that item.

A system that makes all of the loops closed frees up mental energy.

You know that if you put something into that system, it will definitely pop up in the future when you need it.

That allows you to stop worrying.

Both email and chat can be delivered instantly.

But the social implications of them are radically different.

The chat modality is default synchronous.

The email modality is default asynchronous.

In the end, we obviously^[e] needed both.

The same kind of thing will likely happen for sync vs async LLM interaction.^[f]

We can only focus on one thing at a time, so our focus is inherently rivalrous.

Urgency and importance are distinct, but synchronous channels create urgency, which often accidentally overshadows importance.

LLMs are excellent at understanding the meaning of arcane jargon.

One thing LLMs know well are enneagram types and Myer's Brigg personality types.

"Alex is ENFJ / 3w4" contains a huge amount of meaning in a tiny package.

Humans would have to constantly unpack it to make sense of it, but LLMs can do that unpacking immediately and intuitively.

When the agent knows your personality, it knows how to present information for maximum receptivity.

When you're interacting with agent swarms, you're flying.

When you have to talk to a human, you're grounded.

It has to wait for the human to come back and do their conversation turn before it does its next one.

They're constantly chirping for your attention, and you know that each incremental second of attention you give them will unlock more value, so you feel frenzied to satisfy them.

A permission check is a sync point.

Sync points expand the coordination cost super-linearly.

That's one of the reasons with agent swarms, dangerously-skip-permissions is so freeing.

It's also freeing in human organizations, with "Ask forgiveness, not permission."

You trade off execution velocity for safety.

Sometimes that tradeoff is worth it.

"As AI advances, the rise of instant, customized, and often ephemeral software solutions will alter the dynamics of vulnerability hunting and patching, and thus the battle between attackers and defenders."

ChatGPT Data Leakage via a Hidden Outbound Channel in the Code Execution Runtime.

A roundup: OpenClaw Security Report

Claude Code bypasses safety rule if given too many commands.

Google Addresses Vertex Security Issues After Researchers Weaponize AI Agents.

Ars Technica: Here's Why It's Prudent for OpenClaw Users to Assume Compromise.

Agents of Chaos: a paper on directly observed failure modes of agent swarms in the lab.

John Stewart Mill: "a human being is more like a tree than a steam engine."^[i][j]

"A tree does not exist in order to produce lumber.

You can make lumber from it, and good lumber is nothing to sneer at.

But if you look at a tree and see only lumber, you have missed what is standing in front of you.

Something is growing there under its own power, toward its own form, and the growing is not a means to some further end.

Humboldt's claim about human beings is the same shape.

A person is a self-developing being whose worth is not exhausted by function."

You're sighted off of the real peak.

But you don't realize that you're simply climbing a hill in front of the main one.

You're climbing a smaller hill that you could get stuck on.

You're moving in the right direction, but you will get stuck.

Normally when interacting with other humans, someone will point out that you might be wrong.

Agent swarms are less likely to do it.

You might be in danger and not realize it.

We're so used to "I might be in danger" correlating with "someone will tell me I'm in danger" that we don't realize they can be disjoint.

For example: the reflex to breathe is triggered not by lack of oxygen but by accumulation of carbon dioxide.

LLMs can help with the latter, not the former.

If you can free up useless energy by automating it, you can spend that energy on higher-leverage things.

"Who is willing to invest the time" wins in most coordination scenarios.

But now time is cheaper!

True for any emergent property in a system, like performance.

If you can break a complicated problem down into merely-tedious components, LLMs can do it.

To successfully compress something, you have to have a predictive model of it.

"Look at our Lessons Learned doc and our commit history then create the tools that would have made it easier, faster and cheaper to solve these problems if we knew then what we know now."

At every step, look for a place to remove yourself from the loop and put in a process that you trust more than you.

Whitehead: "notation creates intelligence."

Notations can help you think better, they aren't just about storing state and recalling it.

LLMs can skim 100000x more than a human in that time frame.

So of course LLMs will be great at the illusion of knowing you.

A unit of attention from a sufficiently-intelligent actor.

Before, most cognitive labor tasks required a human.

Human intelligence tokens are quite expensive.

LLMs are good enough at many tasks, and their intelligence tokens are orders of magnitude cheaper than humans.

Normal mechanistic code has even cheaper intelligence tokens… but the tools by default aren't useful in a given domain.

That center point is the one whose turf it is; who can make sure it's safe and stable.

It has to be somewhat large, because emergence is a Grubby Truffle; the power of it shows up only at larger scales.

The downside is that everyone participating is doing it in the shadow of a powerful actor.

What if it were possible to have small-scale emergence without any single powerful actor?

Or possibly something else?

Agentic harnesses like Claude Code have a few components.

As the code leak showed, there's no magic in Claude Code.

The TUI is only really important if the user interacts with the agents via synchronous chat modalities.

The bigger the island, the more likely that adding a feature interacts with another feature, so the harder to incorporate.

Emacs has inside of itself not just one but two Vim implementations, apparently.

Large usable chunks are less likely to work in any given environment.

All it takes is one feature that is incompatible with the environment.

The likelihood of that grows multiplicatively.

How did it happen?

E2EE has an abstract benefit, and has no concrete downside for users.

That created the gradient where it could grow without bound.

All it needed was the right seed crystal to kick it off.

If it had concrete downside, then that would have dominated the abstract benefit and it likely wouldn't have taken off.

It all comes down to "how long is the tail?"

If the tail is short and stubby, a linear, heroic, Gilded Turd approach might be viable.

If the tail is long, then no amount of muscling through will get you there.

LLMs make the creating orders of magnitude easier.

But it also makes the latter part easier.

Humans need the tool to not only be useful but also enjoyable.

Agents have infinite patience, so they will crawl through broken glass if necessary.

The UI you created is often obvious to you.

Watching real users fumble with it is an eye opening, grounding experience.

When you watch it live, you sit with the frustration, it's impossible not to feel it.

When you watch it later and can fast forward, you don't have the same visceral reaction.

If you experiment without a hypothesis you might overreact to noise.

Not what it might be able to do in the future.

It's now a possibility to have a recurring agentic process to adapt and pull in upstream changes continuously.

Making software forkable might make it less forked, in general, now that forking is easy.

Forkability gives pressure to the software to conform to user demand.

If it had a nice UI and also took your data so you had to rent it back, well, what are you going to do?

But now imagine a piece of software holds your data hostage.

In each round of review, you see what's working, what is resonant, and lean into it.

You repeatedly see the emotional throughline of the story, and then make it more that way.

Similar to the oscillating retconning strategy of improving a working product.

More of a blossoming process than a building process.

A customer comes and asks for interviews on a given topic.

Tegus sources them, charging the customer the cost to produce it plus margin, gives the results to the customer… and then puts the report in their catalog.

Their leverage comes from how many new requests can be serviced by their back catalog.

We talk about what "the market" wants.

We talk about what "your body" wants.

These are responding to the whole emergent system, not individual voices in it.

As it gets more momentum, more and more others choose to participate.

An open system that's stagnating is the worst.

It's hard to fake to have every component just happen to consistently be pointing in a given direction.

Imagine that someone has to interfere with the signal to fake it.

That cost goes up with the number of places they have to interfere.

If everything points in the same direction, that implies there's some fundamental process driving that alignment beneath the surface.

All it takes is one or two examples to invalidate such a hypothesis.

This process can help you discover massive but hidden forces.

The last dot is obvious and trivial, but the reader connects it.

Because the reader connects it, they feel ownership over the insight, instead of it being pushed on them.

Chase Hughes, a former behavior analyst for the Navy, describes this technique as "elicitation."

Default-convergent systems pull themselves to their resonant throughline, automatically.

Before there's a name, there's just an amorphous mass of possibility.

Once there's a name, there's a capital-T Thing.

The best practice is to have a "bible."

Only the creative lead is allowed to add things to the bible.

Something in the bible is not to be questioned, it's like the word of god.

This pattern is useful for working with agents, too.

Coordination costs are huge.

Schelling points make it go from large to ~zero.

All it takes is a point everyone can agree is good enough.

A schelling point can emerge when there's a critical mass of entities who can agree on one point, and as it gets momentum, it pulls in others, too.

People speak in order to be understood.

Words are an emergent folksonomy.

We use words we've heard from others (as long as they make sense to us) since, all else equal, that's more likely to work in the future too.

This is one of those gotcha observations that is technically true but fundamentally uninteresting.

The culinary concept of fruit vs vegetable is about their sweetness.

There is no botanical concept of a vegetable.

There is a botanical concept of a fruit, but it's about the part of the plant.

It's not that cucumber is a fruit, but that it's the fruit part of the plant.

So in the botanical sense it's like saying "is edible part of the plant the fruit or a different part?" which is obviously uninteresting in any culinary sense.

When smaller droplets touch, they are pulled into a larger droplet, with much less surface area for the same volume.

Surface tension contains energy, so there's now energy that is freed up.

That energy in the contraction has to go somewhere, and it can't go against the fixed surface, so it blasts it off away from the surface.

That makes every cell "compatible."

They're the version of us we're most familiar seeing.

When we see ourselves how others see us, it feels like seeing a stranger.

A disconcerting feeling: totally familiar and yet totally off somehow.

I have an intuitive sense of "are things converging fast enough," where "fast enough" is downstream of how much time is allotted.

If things aren't converging fast enough I feel physically strained.

Once I've set a long-term goal, my steering loop is to continuously minimize that non-convergence strain.

One way that manifests is that when I sit down in a meeting I try to orient myself so I can glance at the clock inconspicuously.

That allows me to keep an eye on the convergence.

Mario Andretti, F1 legend: "When you think you have everything under control you're too slow."

Sometimes you need to lose control, but intentionally.

Adults can hold multiple simultaneously.

This is one of the big maturity leaps needed to be an adult.

Similar to the leverage you get from leading one agent vs leading a swarm.

You only need one dimension to have an active gradient to descend to escape a local minima.

The chance at least one dimension has a downward gradient goes up multiplicatively with more dimensions.

This is one of the reasons gradient descent for LLMs and evolution is unreasonably effective.

We're used to a puny three dimensions.

An excellent video about how proteins can be discovered by evolution so effectively.

And to do it gladly.