Bits and Bobs 4/7/25
Alex Komoroske
LLMs allow moving from allocentric knowledge to egocentric knowledge.
In the world of maps, “allocentric” means world-aligned, and “egocentric” means person-aligned.
It turns out that for many use cases, what users need is an egocentric map, but what they get is an allocentric map.
Aligning an allocentric map to the egocentric view is something that many people struggle with.
Before LLMs, books and media had to be aligned for a generic audience who might read them–which might not be the best format for any particular reader.
Allocentric knowledge.
But now with liquid media powered by LLMs, it’s possible to have the space of ideas rotate around you–what you already know, how you learn best, etc.
Egocentric knowledge.
This could be very powerful, but also dangerous.
It could accentuate our biases and make us more extreme.
One superpower of LLMs: patience too cheap to meter.
When you’re dealing with another person, you don’t want to waste their time or say something that will make them think you’re dumb.
How many people stop learning because they feel too dumb?
LLMs can be a non-judgmental, knowledgeable thinking partner that never gets impatient.
LLMs will likely supercharge the amount of legalese.
Whoever uses the most well-applied legalese gets an edge over their counterparty.
Before, only lawyers could write and interpret legalese.
That meant we landed on an equilibrium where the two sides of a contract balanced out how much legalese to use.
Now LLMs can help interpret or create legalese, even for non-lawyers.
The one-ply implication of this is more people can deploy and navigate legalese.
But the multi-ply implication might be an expansion of legalese.
The benefit doesn’t go to one party; it goes to all parties.
That raises the equilibrium point: a new equilibrium of misery.
A similar phenomena to why tariffs lead to price increases, or why when a highway gets a new lane the average commute doesn’t decrease because people move farther out.
Now it means that anyone who doesn't use LLMs in that domain can't possibly keep up.
You have to work to get disconfirming evidence from LLMs.
LLMs are too eager to please.
If you aren’t careful they won’t question you, even if you give it false premises.
A trick someone told me: they sneak in a reverse Van Halen brown M&M.
That is, an unreasonable request as a canary.
The legend about Van Halen stating in their contracts that they wanted a bowl of M&Ms in their green room… but with no brown M&Ms.
It was often interpreted as an example of the extravagance of an over the top, self centered band.
But it was actually a kind of canary–if a venue had messed up that detail, then they should also verify that other conditions related to safety of rigging, etc that were specified in the contract were checked.
The reverse Van Halen brown M&M for LLMs: ask it to grade the writing samples on something you know it shouldn’t score highly on.
For example, “is it laugh out loud funny?”
If the LLM says it is, you know to look more carefully.
A meta-note: I originally drafted this about “blue M&M’s” and asked Claude if that was correct.
It told me it was, “not brown M&Ms as often misremembered.”
I asked it “are you sure it was definitely blue M&Ms and not brown ones?”
When I pushed it, It corrected its error and said that it’s brown M&Ms, which I then confirmed with a Google search.
A great example of the gullibility problem!
Chat is too squishy to be the primary substrate.
It's easy to riff with, but not great for repeatable, dependable interactions.
It makes sense that we started with chatbots, since LLMs are naturally good at squishy text.
But most things we want them to do dependably are not best expressed in chat.
With chat it's very hard to emphasize some information, or show things to interact with that are easier to skim than a wall of text.
A chat is just a big amorphous blob of text, hard to find a landmark.
You drown in it.
UX is best when there are some affordances.
For example, a physical button that tells you what you can do with it.
The user doesn’t have to proactively recall how to interact with the system, they can see (or even feel!) the button.
We lost all the physical buttons in the shift to touch screens.
Now with the shift to chatbots we also lost all of the buttons.
Just a wall of undifferentiated text.
Is this really the future of all UI?
Castles in the sky: simple to describe, impossible to build.
The value of them is self-evident; what’s not evident is how impossible they are to build.
Every execution step reveals yet more complexity to navigate.
As you pin it down it swirls away.
Building the castle in the sky demands all of your resources and attention, distracting you from approaches that actually could work.
Companies with the resources to build them often get stuck in the culdesac of trying to build them.
Omniscient chatbots as the dominant interaction paradigm might be a castle in the sky.
MCP is a way to supercharge chatbots.
The “omniscient agent” view is easier to understand at a science fiction level, but harder in implementation.
All of the big guys are chasing full automation, because it’s plausible for them and a big prize.
But it's an incredibly high bar to hit to be viable.
"Everything is a chat with an omniscient agent inside doing a perfect job".
Another approach to software in the era of AI: generating bespoke software on demand.
LLMs are by default way too eager to please, too gullible.
LLMs are too gullible, too earnest, too action oriented, to be trusted to do things fully on your behalf.
In my experience, Deep Research often gets tricked by SEO slop.
The slopification of the internet means that most of the data is untrustworthy.
A human looking at the SEO’d slop would see it’s not credible.
But Deep Research doesn’t have a vibe on what should feel credible, so it just accepts it as correct.
Now imagine an agent trying to be helpful for you in a task.
“My user told me to shop for insurance. This helpful site tells me they’ll give me great rates if I just share my user’s social security number.”
What could possibly go wrong?
The expensive eggs were just the beginning.
There is a trust scaling problem with agents in our current laws of physics.
In our current system, human judgment is load bearing.
“Does this site seem credible for this task?”
“Do I trust this site to keep their word, based on the vibe I’m getting?”
MCP is the tech industry’s politician’s fallacy.
The politician’s fallacy:
Something must be done.
This is something.
Therefore this must be done.
Everyone in the tech industry can tell that AI is the real deal, and they have to have an AI strategy.
Every company must have an AI strategy.
“Implement MCP” is an AI strategy.
Therefore every company must implement MCP.
I see so many people talking about MCP and building integrations, but I'm not seeing too much evidence of people using it.
I think MCP might be a culdesac; it has a low ceiling due to its nonexistent security model.
After all, the S in MCP stands for Security.
How long will the industry be distracted by this shiny object that might turn out to be fundamentally a mirage?
In the end something else that answers the MCP kind of need but without a low ceiling will become the schelling point.
Is the LLM the one calling tools, or can tools use LLMs inside of themselves?
Which is on top of execution, a chat thread orchestrating tools, or a traditional bit of software that’s orchestrating tools, some of which are chats?
Can your tool generate (with a lot of effort, perhaps) a version of itself?
That's an open-ended system.
Don't use LLMs as the software, use them to write the software.
If LLMs make software for basically free, then you can have the LLM generate it on the fly.
An emergent system built out of just-in-time software.
Code is easier to trust because it’s concrete and can be structurally analyzed.
LLMs, on the other hand, are squishy and gullible.
A system that meets LLMs where they are for code will get the most out of them.
LLMs can write simple React components with high quality
They need a lot more hand-holding and direction to write more complex code.
A system that makes it possible for LLMs to write little bits of code that can be stitched together into larger experiences will unlock the most value.
There are tools for building vibe coded artifacts today.
But there's not a medium for publishing them, where they can interoperate and interconnect in useful ways.
Vibe coded software that's stitched together, not separate islands.
Coding with Cursor or Claude Code is tiring in a different way than normal programming.
Normal programming has architectural thinking and also tactical programming.
The tactical programming has a feeling like grinding on sudoku puzzles.
That is, some people (those with a natural affinity for programming) actively enjoy solving the puzzles.
But now LLMs can solve the puzzle for you, and it’s up to you to just verify its work and think architecturally.
It’s a different kind of puzzle, one that is more mentally challenging and less directly rewarding.
Typescript will be the new ‘assembly’ for this generation of programmers.
Every generation of programmers has a new “assembly”.
That is, a raw, nearly inscrutable, lower level of programming, that is below the everyday level that they are comfortable with.
Each generation adds a new level of abstraction.
Back in the day you could only do assembly.
Then the next generation got C, dropping to assembly only when necessary.
In that era, programmers had a superficial understanding of assembly–they could understand it but probably not write it by hand.
This continued up the stack of higher and higher levels of abstraction.
Now LLMs allow vibecoding; programming without having to look carefully at it.
The next level above that is vibe prompting.
Vibe prompting is surfing through the latent space of generated software.
Humans don't need to write code they surf through latent space.
High volition people can still cause useful code to come into existence, even if they themselves are not technical enough to vibe code.
Collectively-discovered savepoints in the latent space of generated software help others get better results, too.
"Why would developers write new software in this new system?" is the wrong question when the software is being created by vibe prompting.
The humans are doing the work to surf through for their own problems, and that helps everybody else too.
Agency is tied to competence.
Agency is tied to your effective ability.
If you couldn’t program before but now you can it’s a massive improvement in agency.
Clemens Klokmose proposed a list of six properties for malleable software that I love (via Andy Matuschak)
“malleable: users can adapt tools to fit idiosyncratic preferences and uses
shareable: multiple users can work on the same data, using their own views and tools
distributed: the data and tools can be used on different kinds of devices, in different situations (desktop, tablet, phone)
composable: the user’s preferred tools can be combined into workflows well adapted to their activity
interoperable: different tools can interact with the same data, so that the user can always use the “right tool for the job”
computational: the system behaves and responds dynamically"
One downside of perfectly bespoke tools: they rot away.
All software rots away as the surrounding context changes.
Tools that are made by someone else for a large market of users tend to be maintained and keep working, because they are constantly in use by someone.
But a tool that was distilled on demand just for you and that you haven’t used for a year or two might have rotted while you aren’t using it.
Ideally these tools can be “alive,” maintaining themselves, instead of passing that maintenance burden onto the user.
If the security model is paranoid, the user doesn’t have to be.
Today’s default security model has the data flow to where the software is.
This means that the creator of the software could potentially see the data.
If it’s on a remote cloud, you have to trust the software creator to not peek.
But if the model were inverted, and code went to data, then users wouldn’t have to trust the software creator to not peek, because the software creator couldn’t.
If the software tried to do something the user doesn’t want, the user could just not execute that part.
LLMs need to be treated as untrusted components in a system.
They are extraordinarily gullible and can be easily tricked by anything you pass them.
If what you pass them includes untrusted content (e.g. emails you’ve received, or web search results), then the LLM could be tricked into taking an action.
Don’t let LLMs pull levers with dangerous side effects.
Claude Code is safe to run semi autonomously because it’s operating on data that is version controlled.
So the possibility of irreversible side effects is way lower.
If Claude Code does something weird to your project, just `git reset`.
It’s way scarier to have general purpose MCP that mutates systems of record or takes actions with irreversible side effects.
Data is welded to apps.
This is one of the defining characteristics of apps vs applications.
If you don’t like what the app does, you’re out of luck.
There’s no way to take your data and go elsewhere with it.
ATProto is about separating the app from the data.
You have a choice about what you do with it.
Don’t like the algorithm? Go somewhere else, or pick a new one.
A load-bearing party trick: an app that doesn’t have a GDPR banner.
Your data never flows anywhere else to be used in another context, so no banner is necessary.
Algorithms don’t have to be scary if they’re working for you.
If they’re working for someone else, then their ability to steer your attention is extremely powerful, and potentially dangerous.
BlueSky has captured some of the crypto ideals but among a mainstream audience.
Crypto is a totalizing worldview.
If you dip your toe in, you’re often pulled fully into the ecosystem, swept up into it.
To outsiders, the ecosystem might look extreme and not worth jumping into.
That prevents crypto (at least so far) from growing beyond some ceiling of adoption.
BlueSky and crypto share a number of key philosophical goals around power structures in tech.
BlueSky is idealistic, but pragmatic.
It’s common to use BlueSky and not be a zealot about it.
If you're not paying for it, you're the product.
If it's incredibly important to you, you should be glad to pay for it.
It's like paying for rent or mortgage, to have a space that's yours.
Our phone and our computer are our digital homes.
It makes intuitive sense to pay for our digital homes, to ensure we have a space that’s ours.
If someone offered you a free phone, you’d be suspicious.
“What’s the catch?”
But we don’t have that same suspicion about software.
Maybe we should!
The aggregator pattern is not inevitable.
It is downstream of the app / web distribution model.
It is only inevitable in the web laws of physics.
Aggregators are jealous.
Aggregators say “these are my users and anyone who wants to talk to them has to pay my toll.”
In the web the origin has sovereignty over the data, not the user.
It’s the origin’s turf, the user is just living in it.
Open Attested Runtimes give you "your own cloud."
Normal users can't get their own cloud.
Using Gmail is like couchsurfing.
You’re beholden to the rules of the apartment’s owner.
Using Google Cloud Platform is like renting an apartment.
For the most part, what you do in your apartment is your own business.
Companies that use Google Cloud get something very different than users get from Gmail.
But that different kind of software isn’t practically available to most consumers because it’s designed for technical people.
If you want a game-changing open ecosystem, don’t try to build consensus too early.
Consensus is an averaging process.
If you took all of the ideas that shared the same ideals and averaged them together, you’d get mush.
But if you have a swarm of diverse ideas that share the same ideals, the chance that one of them happens to be coherent enough to be viable and start compounding is much higher.
Then, once it starts breaking out, other members of the ecosystem who share the same ideals can pitch in to make it more open and decentralized.
This is true as long as each option takes care to design themselves so they are naturally decentralizable, where the amount of decentralization is tied to the amount of energy other parties choose to invest.
Lots of ecosystems, like aggregators, have no ability to be decentralized, even if lots of other parties choose (or are compelled to) participate.
The default apps for the original iPhone were an important signal of intent.
They told users what this new kind of tool could do.
Might we see the return of tech small businesses in the era of LLMs?
In the 80’s and 90’s there were thousands of tech small businesses.
Later, as the cloud phase heated up, the efficiency of scale became more important.
Ranking algorithms in particular are necessary to sift through the firehose of content.
Historically the best way to do ranking algorithms was sifting social processes; collecting billions of human interactions in the system and using them to drive an emergent sort.
This only works with massive amounts of data, which means only the biggest platforms can do it.
But LLMs allow human-level judgment available to anyone, and might make ranking with much less input plausible.
Perhaps it will still be limited to only the companies with enough momentum to be able to pay the small but non-zero inference costs.
LLMs will get good at everything that can be quickly ground truthed by computers.
But that doesn't mean they'll do a good job at things that can't.
Most meaningful things to humans can't be ground truthed entirely in the world of bits.
Most meaningful things must touch the world of atoms, where humans reside.
Transformers’ primary superpower is finding hidden patterns in ridiculously large data sets.
They discover the generating function behind the patterns, with multiple layers of nuance.
Even layers and mechanisms we didn't realize were there or couldn't describe ourselves.
The hidden patterns of the universe, captured in this crystallized, inscrutable collection of numbers.
Knowledge is what allows humanity to escape the OODA loop of biology.
Our ability to accumulate and communicate knowledge is the thing that allows us to out-maneuver things that are purely biological.
We operate and adapt on a pace layer above the biological substrate.
LLMs are crystallized, distilled society-scale knowledge.
Of course they're massively useful!
To navigate a world, you must have a model of it.
Our own actions are one of the biggest predictors of the things we see and experience in the world.
For example, if I choose to move my head to the right, the things I see will shift.
This means that a large part of our model of the world is a model of ourselves.
Even paramecium have models of themselves, to some degree.
LLMs also have models of themselves, allowing them to drive themselves to coherent outcomes more than a single token in the future.
To LLMs, humans will seem like trees.
Humans can perceive at most about 10 bits of information per second.
This was explored in a paper called The Unbearable Slowness of Being.
This is as fast as human OODA loops can go.
This loop is likely faster than any other animal.
Our whole constructed environment is designed around that 10 bits per second limit we all share.
But computers have a massively faster OODA loop.
Before computers were entirely mechanistic.
Now with LLMs they can do human-style reasoning.
What happens when we are no longer the fastest twitch “species”?
There’s a mesmerizing video by Adam Magyar of an insanely fast frame rate of people on a subway platform.
In it, the people look like trees.
That’s how we’d look to something that has a massively faster OODA loop.
The old picture was robots taking out the trash so we could write poetry.
But what's happened is backwards!
Turns out machines are way better at bits than atoms.
Atoms still require humans and will for a long time.
Someone this week worried to me that LLM relationships will become the pornography version of human relationships.
That is, a hyper, hollow, convenient version of a real, deep, challenging phenomena.
Human relationships are challenging.
They force us to compromise and grow.
On the internet it’s already easy to find new people to talk to.
If you’re feeling challenged, instead of growing, you can simply leave and find new people.
An infinite supply of people, some of whom are sure to accept you just as you are.
LLMs are so eager to please, they’re sycophantic.
Imagine how unhealthy it would be to grow up surrounded by nothing but sycophants.
What a warped, emotionally stunted person you’d be.
Previously this could only happen for the children of the hyper rich.
But now it could happen to everyone.
The speed of evolution is tied to the amount of noise in a system.
This arises from the logic of the roving bullseye.
When the target moves, if there’s noise, at least some members of the swarm are likely to have already, by chance, been in the right direction, and the rest of the swarm can follow them.
Sometimes to get to coherence, you need to put on blinders.
If the team doesn’t have blinders on, then every idea that could be good distracts everyone.
It’s like entropy eroding the momentum.
Putting on blinders helps focus energy and make sure that something happens.
Once it gets to the point of viability it becomes self-cohering; everyone can see it’s working and see that iteratively improving it to get more momentum makes sense.
But putting on blinders is dangerous!
You could miss opportunities or threats outside of your view.
The more momentum you have, the less you should have blinders on.
At least one person who is well-respected and will be listened to if they raise a concern should not have blinders on at all times.
Play is easy in abundance.
In scarcity you naturally get less play.
When things are positive sum (growing), you don’t need to compete directly.
When things are zero sum (not growing), then you need to compete ruthlessly to get an edge.
Growth makes it easier to have an infinite mindset.
This is one of the reasons the tech industry historically cared less about titles.
Everything was growing, so why sweat it?
More mature contexts, like on the east coast, or academia, are way more focused on titles.
The downside of making fast decisions is you can't think through the indirect effects.
Over long enough time horizons, indirect effects dominate direct effects.
But if you're always sprinting you'll never grok the indirect effects.
Chasing efficiency leads to a hollowing out.
The easiest way to juice long term returns is to steal from future returns.
It's done in finance and tech.
Both kinds of PMs: Portfolio Managers and Product Managers
As information transmittance gets faster, everyone has to run their OODA loop faster to create an edge over competitors and stay alive.
That means everyone is driven to increasingly short-sighted decisions, at an accelerating rate.
A constant pressure for everyone everywhere in modernity.
Leading to a hollowing out of nearly everything.
To scale you need efficiency, and efficiency erodes the soul.
Society is becoming a pancake: broad but shallow.
We only have the efficient answers, not the deep or meaningful ones.
Everyone has to hurry to get an edge, so everything is one-ply.
We’re trading off a flattening of nuance with interoperability.
Flattening removes the meso scale, meaning, community, aliveness--depth.
The power of small and medium collaboration. Communities. Where you feel a social connection to something meaningful that is larger than you.
Interoperability gives you scale and breadth.
Hyper individualization and hyper globalization, but missing the middle.
Experiments shouldn't tell you what to think, they should only tell you what not to think.
If an experiment performs better, but you can't state the mechanism of action, then be careful.
Maybe you're optimizing for a proxy that has decohered from the underlying thing you care about.
I love this compendium of “hacker laws”.
I knew most of them already but there were some that were new to me!
Today there's two camps: pro tech and anti tech.
Both react to tech as it exists today.
What about tech as it should exist?
Acknowledging where tech has gotten lost or stuck or diverged from its ideals, while pointing a way for it to regain them.
There's currently no mainstream voice that has grounded optimism about LLMs.
There are either the hyper tech "it will be wonderful, simply trust us" or the anti tech "this is terrible and you should be terrified".
Someone should be the optimistic, society-minded voice on LLMs.
We have lost the imagination of what could even be done with software.
Software can be built to make so much more than aggregators and apps.
But we forgot about its potential!
With great power comes great responsibility.
Responsibility is about owning the indirect effects of your action.
Tech has a ton of power but often abdicates responsibility.
“We’ll simply create a perfect dictator and put it in charge.”
There is no such thing as a good dictator.
It’s impossible.
The problem with a dictator is there is no room for error.
If there is any error, there’s no way for the system to self-correct.
The power structure precludes it.
But nothing is infallible.
Imagine you thought other parties were going to try to make a perfect dictator oracle, and they just might succeed.
Now you’d be locked in a race to make a dictator for the human race, because yours would be a good one, and the competitors’ would be the bad one.
Everyone thinks their own candidate is intrinsically good, because they created it.
An infinitely powerful dictator is a winner take all, so it becomes a totalizing quest to install yours first before the baddies do.
An emergent arms race to install a dictator.
Bullies exploit an unfortunate game theoretic equilibrium.
You'd rather the bully not notice you, but if he's going to notice you you'd prefer for him to think you're on his side.
So that means that if you can’t escape his notice (e,g. you loom too large) you need to suck up to him.
That's the incentive for each individual.
But that means that everyone puts their head down and lets the bully get away with whatever he wants.
The more that everyone puts their head down, the stronger the disincentive for everyone else to stick their neck out, because they’d stand out prominently and definitely get smacked down.
In some contexts there’s a bigger authority that can smack the bully down.
But if there isn’t one, the only way is for everyone to rise up against the bully at once.
That can happen if there’s a supercritical state where everyone is upset but no one wants to stick their neck out.
Those supercritical moments are prone to catastrophic shattering when the right inciting incident comes along that everyone simultaneously can see everyone agrees the bully has crossed the line.
As everyone sees others stick their neck out, they feel emboldened too.
Some mountains are like Kilimanjaro.
No part of it is particularly challenging, it’s just the sheer scale of it.
Not complex, just complicated.
Whether you succeed is less about strength and more about the right attitude to not give up.
Just take step after step.