Bits and Bobs 5/26/26

OpenClaw was the starter pistol for the power of agentic software, but it will not be the most important one.

Hermes likely won't be it, either.

We're still in the Mosaic era, awaiting the AOL^[e].

The first entrants might have explosive growth, but then realize that they are organized subtly wrong.

Instead of climbing the mountain they realize they're climbing the foothill.

Their existing users become a liability, and make it harder to change.^[f]

Someone watching closely can figure out what made it work and how to set it up to actually be at the foot of the mountain.

The stone age!

They can go into much smaller granularity of detail than you can.

They can always be ahead of you, breaking down the layer of detail immediately beyond your current perception.

If you aren't careful you can sink into it and forget what you were planning on doing.

Everyone gets stuck in the former even when the latter would be useful.

But LLMs rarely pull back unless prompted to.

If you just follow them you'll get pulled into self-digging rabbit holes.

Quicksand.

The Peter Principle: everyone is promoted to their level of incompetence.

LLMs allow you to promote yourself beyond your comfort level, just a bit out over your skis.

The more that you use agents, the more that you find yourself in that region.

We have only a limited amount of capacity to handle intellectual novelty.

When it's depleted, trying new things feels like an impossibly high bar to clear.

Agents consume as much novelty as you'll give them, asking high-leverage questions.

This means that there's a very low novelty budget for trying new things, including software that might turn out to be useful!

That's not that big of a deal if software is so expensive that you couldn't possibly make it yourself.

But if software becomes easy enough to create that you could fix it, it feels like being stuck in a stranger's cage.

"What do you mean that I have to wait for some stranger to add the feature I need?"

"... What do you mean I can't tweak it if it doesn't do what I want?"

If you can conjure up your own software, why move into the constraints of someone else's software?

If I can add whatever features I want in my software, why would I want to be stuck in a stranger's software?^[g]

Humans get better over time. Agents get worse over time.

Competent and motivated is resonant.

Competent and not motivated is fine, because when you can get them motivated they add significant value.

Incompetent and not motivated is fine, because they can't do too much damage.

But incompetent and motivated is the worst because they destroy more value than they create.

LLMs can often be both incompetent and motivated, with infinite patience.

Before, coordination on an engineering team was herding cats.

Now all the cats have become extremely fast.^[i]

Herding cheetahs is way more coordination cost than herding cats.

A previously expensive thing (writing code) drops its cost by multiple orders of magnitude.

The most obvious thing is to search the shallows: the previously underwater coastal areas that are now mudflats.

The real value comes from discovering the new continents..

But as the network grew, it increasingly became, "actually, your pictures aren't as good as the other ones on the feed," and most people switched to consumption.

As supply increases, and the ranking functions sort the good stuff to the top, it makes amateurs less interested in creating.

The same thing will likely happen with software in an era of AI.

Lovable was "anyone can write software now!" but in the end the vast majority of people won't write their own software even in this era.

The good stuff can rise to the top.

At the beginning, a filter of "stuff your friends built" helps reduce the cacophony of crap to manageable levels.

Then as the supply gets bootstrapped and the ranking function warms up, most users don't see crap anyway.

You lower the bar, and now you get more things... but most are crap.

There are some that were previously below the bar that are now viable that are great.

You want the new great things to bubble to the top, which requires a ranking or social sifting process.

This process happened with social media for discourse.

It will happen with vibe coding for engineering.

But you can't get network effects to boot up in 6 days.

Humans just don't go that fast, and that's the fundamental clock speed of network effects.

Code used to be created by humans, so the cost to create was in equilibrium with the cost to adopt.

But now code can be created 10x faster, and it can run faster than humans can adopt.

If your service is a dumb pipe, then users don't think about you at all.

You're just an implementation detail.

Something that the user hasn't built up a relationship or trust with is much easier to swap out.

Silos, who used to render the pixels, making themselves increasingly dumb pipes for agents is ceding a lot of power.

The software will become so cheap to fade away into nothing.

Just your data, come alive.

You can still keep using it, and even improving it!

It was packaging them up with different convenient packaging that made it sing.

Claude Code was also its own version of unlocking the value latent in Claude.

"The cockpit is intimidating to people, so we're going to create a familiar UI that presents as an XBox controller."

Then they tell the users: "If you control it precisely right you will literally be flying. But it's hard to describe how to do it right, and by the way if you do it wrong you'll probably die. … OK, have fun!"

That's what it will be like to try to retrofit OpenClaw or even Claude Code to the mass market.

Either you'll break what made it powerful in the first place or you'll make something that hides the dangerous complexity but doesn't address it.

The more ways to misuse it and not have it work, or achieve results that you didn't intend.

"A pair who helped launch the agentic-AI craze worry that their creations are pumping out bad—even dangerous—code"

Today's security model is incompatible with a tsunami of low-quality code.

Critical 'Claw Chain' Vulnerabilities Put Thousands of OpenClaw AI Servers at Risk.

The Register: Minor edits to AI skills can make agents go rogue.

How prompt injection broke Nvidia's sandboxed OpenClaw agent.

Paper: Blind Spots in the Guard: How Domain-Camouflaged Injection Attacks Evade Detection in Multi-Agent LLM Systems.

Paper: Hidden Signals Can Hijack AI Voice Systems.

Anthropic Silently Patches Claude Code Sandbox Bypass.

The AI backdoor your security stack is not built to see.

You could argue that there's a backlog of old software that all needs to be fixed up at once… but that's a one time thing.

New software that is exposed to Mythos before shipping simply won't ever have the same problems.

Or, it could be that a new equilibrium has been reached, where machines can find vulnerabilities faster than the human clock speed.

They always have been.

Phishing has always been effective, and now it's insanely effective.

Writing perfectly targeted, totally bespoke phishing lures for individual people.

Qualitative nuance at quantitative scale.

Javascript / Typescript has the most, but every language has way more in the average bit of software than a decade ago.

Once dependencies were solved structurally, they exploded.

At decision time, the concrete benefit of using a known-to-work dependency wins out vs the theoretical, diffuse risk of supply chain risk.

It's possible that we've been in a golden age of open source that is coming to a close.

Before the difficulty of making the software was larger than maintaining it and dealing with PRs and issues.

But now, it's way easier to create, and the maintenance cost on a relative basis goes way up.

That reduces the push to publish open source software.

But as a user, it's still nice to know that a given chunk of code is battle-hardened and effective for others.

If you want a feature that others don't want, you have to convince the maintainer to accept the PR.

You could fork, but forks take time and effort to maintain.

LLMs have made forks less expensive to maintain.

Instead of debating with a stranger, just fork it.

A possible future: no one accepts PRs anymore, but everyone forks and picks up the patches that other people also seem to like.

A much higher rate of speciation.

Not necessarily better, just a different equilibrium.

A house is built by a builder, but relatively soon after it's done those builders never work on it again.

If you want changes later, there are tradesmen who can make any modifications you want.

There are many different kinds of houses, but they're all fundamentally built similarly, so tradesmen can work on arbitrary houses.

In the hills, you hope no one will bother looking for you.

In the fortress, you hope that the strength of the fortress will attack you.

Software monocultures create a combustible situation when new weapons can emerge.

It's not "do you trust Reddit's owners?" it's "do you trust any random person who posts on Reddit?"

Especially in a world of agents.

But Notion is many orders of magnitude too expensive for anyone who isn't an enterprise or an early adopter to get it.

Those are the lowest common denominator coordination tools.

"Booed commencement speakers, blocked data centers, plummeting poll numbers: Fast-growing industry has a faster-growing crisis."

The last phase of polish and productionization has always felt wildly slower than the first phase, but LLMs 10x it.

The first phase sets the expectations unreasonably high!

The custom devtools lets the human peer into the innards of the system.

The LLMs understand it already, but humans are not machines.

Custom devtools used to be unthinkably expensive, reserved only for the most well-funded or must-not-fail projects.

But now you can do it for even throwaway projects.

It gives you leverage, because it allows you to peer into the innards and find high-leverage mistakes.

"it's in gemini, just create it in ai studio. oh, that's for your personal google one account. for workspace you need gemini business. no, not gemini advanced, that's ai pro now. unless you need ai ultra. oh agents? you do that in spark actually. no, not gemini api managed agents, that's different. for coding use jules. unless you mean the agentic ide, that's antigravity. no, that's the old antigravity, download the new one. actually gemini cli is being deprecated, use antigravity cli. no the flash model is smarter than the pro model. unless you need pro. if it's video, use flow. no, flow uses veo. no, nano banana is images. actually that's in gemini now. unless you're in search, then it's ai mode. no, research is notebooklm. anyway it's all very simple."

None currently exists, because previously they had to be captured mechanistically.

It wasn't possible to capture them mechanistically across domains.

Humans don't write the code anymore… but they do make the decisions.

We didn't need this before agentic engineering because decisions moved at human speed so they didn't decohere too quickly.

Now trying to herd cheetahs, it's necessary in a way it never was before.

You can make a barely viable option and as long as it's close enough to the main system to get folded in automatically and become load-bearing, it will naturally be improved.

A default-converging process improves everything that's load-bearing in the system.

Vertical Saas replaced spreadsheets for many businesses. Why?

With malleable software, you can interact with data directly.

Once the era's playbook is figured out, it becomes a race to apply it to the ever-smaller niches.

Cloud software has been at the end of a paradigm.

An example: seed stage software would spend 20% of their budget on top notch branding as their main differentiator.

Small chunks that can be combined in many different ways gives you a combinatorial power to cover the domain.

Larger chunks are less likely to fit the given use case precisely.

Not just "ship a feature" but "Increase ranking quality by 2%".

That meant that you could work really hard and not hit them.

The OKR was about the impact more than the effort.

Later they evolved to be more about a tasklist.

That meant it was about how hard you worked, not how much impact you had.

This happens when individual actions, by default, create more long-term value than erode it.

If you're in that state, you don't need a strategy, just run it hotter.

For example, if you have a capable team who believes in the mission and you have full PMF.

This is Stuart Russell's observation in the context of AI.

Companies are optimizing machines to maximize shareholder value.

The reason they don't run amok is that they're in competition with other maximizing machines: competitors.

But think of these machines as being for the purposes of maximizing the net value created for society.

Should a machine be allowed to create infinite value for its shareholders at the infinite cost to everyone else?

Obviously not.

When not aligned with the end, the smarter the players, the more quickly they destroy value.

Do you care about the deep thing or the superficial thing?

When that happens, society moves from default-converging to default-diverging.

"Why play by the rules when the people on top don't."

The deal is the richest people have to at least pretend to follow the rules!

Previously the kids were the ones who used new tech, who took it for granted.

But this current generation coming of age is more likely to hate it.

To see it as a tool of the powerful to oppress everyone else.

Technology has leverage; refusing to use it will put people farther behind.

How can we use technology to help everyone in society thrive, and not just empower the broligarchs?

The tech CEO archetype thinks that most people are lazy and incompetent.

Is it any wonder that when tech becomes powerful, people are suspect of it?

A truly humanistic tech company, one that allowed everyone to benefit from technology, would be resonant.

It's easy to be aligned with your ethics if the thing isn't successful.

Once it becomes successful, the pull to cut corners to make significant money becomes stronger and stronger.

That tension will tear you apart, in proportion to how successful it is.

That makes it easy to miss how tech is like any other industry.

Silicon Valley will look like Detroit someday.

Google will increasingly become Procter & Gamble.

Especially in a cacophonic environment!

You have to do it when it's still somewhat fresh in your mind.

The less fresh it is, the larger the activation energy to page it back in, and the more likely you don't do it.

Often you want a handful of iterative synthesis passes.

My Bits and Bobs has three synthesis passes:

They're not the flashy showman in front.

They're quietly in the back, making the whole thing coherent and robust.

You find out what's good by what didn't die.

Some must die for selection to occur to propel the collective forward.

If individuals weren't exposed to death then the collective couldn't learn who could survive it.

This is the cold, amoral emergent logic of evolution.

Biology cares about species but not about individuals.

Society cares about venture but not about individual startups.

Thanks to my friend Steve for these insights!

Instead of "when should we add foo," invert it.

Often, the answer is, "effectively zero."

If that's the case, then foo is an inevitability.

That means you can start thinking of how to plan around it now.

"Given that we'll have foo in the future, what small tweaks to our data model or roadmap will make it less challenging when we get to it?"

Sometimes that means pulling forward work a bit, or laying a very small stub that can blossom into the full thing.

The inversion makes what was an amorphous question snap into clarity.

One of the brain's fundamental super powers is to narrativize.

To come up with a story that is plausible given the observations.

To retcon.

These stories are the inverse of surprise.

Surprise is unsettling, but stories make it feel just so.

LLMs are also great at coming up with a story that is plausible given what has happened in the conversation already.