Bits and Bobs 4/1/24

I don't think I've ever felt this exhilarated!

The idea has had significantly more resonance with folks than I expected.

I'm having trouble sleeping at night because I'm just so excited about all the opportunities in front of us.

I can't remember the last time I felt this optimistic, this alive.

Lean into what makes you human.

Lean into your agency.

Lean into what you find fun.

Lean into your superpowers.

Lean into what makes you connected with your environment.

Don't hand over your agency to a tool!

A living thing can only be grown.

An ecosystem is a living thing.

The fact that it's alive is what makes it so valuable and important.

Other products are designed to catalyze an ecosystem that extends wildly beyond the product.

The people who invest their time and capital into those kinds of catalytic products are the ones who should be excited to invest in other things that grow in the ecosystem, too.

An ecosystem is not interesting as a built object.

It's only interesting if it's alive.

Alive things with network effects have momentum.

This is the all-important self-sustaining flame.

That essay is now 8 years old, but I think it still slaps!

Ecosystem building is very different than product building.

If you have to pick between the product or the ecosystem, pick the ecosystem.

(At least, after clearing the bar of a minimum-viable product)

You can't force an ecosystem to grow. You can only create the conditions where it might thrive

Growing an ecosystem is an art.

A highly intuitive, vibes and experienced based art.

"Wait for it... wait for it... ok NOW! Give it a dash of paprika. And now, a dash of coriander".

Like alchemy, brewing a wizard's potion.

You need to make sure you have the right materials on hand to meet the moment, which you can never predict precisely but you can predict stochastically.

The laws of physics determine the cost to build any given experience, but also to distribute it.

Laws of physics here cover things like the privacy and security model.

The laws of physics set how strong gravity is, and also the speed of light.

Even if it's possible to create a privacy-preserving, hyper-bespoke application today on a technical level, it's still not viable.

The distribution friction is too high, meaning the market is too small to justify the cost of building it.

A whole universe of conceivable software tools are below the bar of viability and thus don't get built.

No one will install an app to read about a random teenager's favorite beanie baby.

The distribution friction is simply too high.

But they might happily navigate to a random web page about it.

Everything that is a part of the fabric can be trusted to have the same properties.

The fabric is a decentralized, private fabric that has different laws of physics from other technical systems.

It uses tools like information flow control, remote attestation, confidential computing, and good old fashioned cryptography to establish these laws of physics.

It will start off having decentralization, security, and privacy that is at least as good as the best in class of today's paradigm.

But it will have an incremental, ratcheting, self-accelerating glidepath to being radically better on all of those dimensions, in proportion to the momentum of the ecosystem.

The problem is how to assemble them into a fabric that everyone agrees to coordinate within.

An ecosystem schelling point problem, not a technical one.

They're the ones who call the shots of where the computation happens and thus implicitly what happens with the data.

Today's value proposition: "I'll do the computation for you for free… just give me all your data"

A devil's bargain!

When users don't pay for their own compute, it leads to the exploitative aggregator experience.

Another problem: a one-size-fits-all computation budget.

Sometimes you really would want to spend $30 of compute on a better solution to a particularly important problem!

Today only companies pay for their own compute, which gives them control of it.

Why not allow users to pay for their own compute?

The total amount of compute most users use in a month would cost on the order of magnitude of a cell phone bill.

A system where users paid for their own compute would flip the model on its head, and lots of other properties would flip with it.

This is because the easiest way today to have access to the context is for the service to be able to see all of the data.

That means the user must have very high levels of trust in the creator, accelerating the aggregation effect.

By flipping the privacy paradigm on its head, indie creators will have the same amount of context to build with.

The only trick is: they can't see the context.

Instead, the creators will describe the operations to do on the context to produce a useful result.

Think of allowing creators to give a pre-programmed algorithm for a remote control robot to follow that, once in motion, they can't tweak.

The reason is because of the same-origin model.

In traditional operating systems, different apps can coordinate via the filesystem.

That's powerful, but also dangerous (without protections).

Files are the natural schelling point for different actors to coordinate, including in unexpected ways.

The web introduced a simple rule: isolation between origin.

Origins could not interact except with two-way opt-in.

Simple law of physics, easy to implement and maintain.

But that made it so each domain was its own separate universe.

Apps extended this model to powerful local software and made them all isolated islands.

More secure, but at the cost of strongly accelerating the pull to aggregation.

The most powerful apps can convince other apps to send data to them, but don't allow data to flow from them.

This power is self-accelerating.

The same-origin model is too simplistic of a model, and precludes the majority of the combinatorial power of software that comes from composition.

We should make the model same-user, and allow a more enlightened and powerful security and policy apparatus to prevent unintended information leakage.

It's absolutely foundational, and yet you never have to think about it.

That's how the privacy constraints should be.

A force of gravity.

Powerful, but you can take it for granted.

The "no cake recipe should have 5 tablespoons of tabasco sauce in it" call is not reasoning, but intuition, so LLMs are good at it.

"Across all of the cake recipes in the world, none call for a substantial tabasco sauce (except as a joke)"

It's a miracle that it's able to do it at all, but watch out because no matter how well they can act like a human on some tasks, they're still a wild animal.

They might ransack your kitchen, and they could kill you, accidentally or intentionally!

Just because it can talk like a human doesn't mean it deserves the responsibility of a human!

Don't give LLMs agency over you, use them as a tool.

A thing has agency if it could initiate an action behind your back.

In the 70's there were all kinds of novelty jello molds, allowing various shapes.

You need an external structure that sets the laws of physics, that creates a cage, a jello mold for the slime mold to expand into.

An LLM is like jello.

LLMs are inherently, fundamentally gullible.

You cannot rely on them for the structure of any part of your security model.

A GPT could configure a solid box to have certain privacy properties but it can't be the box.

The structure is what makes it safe.

The LLMs are what make it magic.

The ability to create, endowed from human to machine.

The horcrux allows that device to take actions on your behalf even when you're not there.

A crystallized version of your particular agency.

You can also be harmed when that horcrux is used maliciously.

An extremely powerful magic to endow on that device!

Do it only carefully, and rarely!

Having privacy baked in to allow a different laws of physics makes a whole new class of software viable.

Users will use the platform not because of the privacy characteristics, but because of the amazing new experiences that are possible within it… which are only possible because of the privacy model.

The killer use case of this new platform will be the whole universe of amazing things that aren't viable in other systems.

A privacy model does not make a product. It enables a product.

If you were a big media company in 2000, you saw how the internet allowed distributing your high-fidelity, expensive-to-produce content with radically lower distribution costs.

It might seem like the internet was best for the big media creators.

But actually it was disruptive to the high-cost / high-quality / one-size-fits-all model fundamentally.

With zero cost of media distribution, even potentially low-value content was free to distribute… and some of it turned out to be extremely compelling for unexpected reasons.

As the cost of creation drops, too, it will further accentuate the disruption.

What does software look like when you free it from the constraints of having to make money?

But we're alienated from our software today because they are one-size-fits-all.

This term is associated with Ivan Illich and his Tools for Conviviality.

Like many differentiated thinkers with an unapologetic worldview, there's some controversy surrounding him.

Like many such thinkers, there are parts that I feel a warmth of deep resonance with, and others that leave me cold.

But in the spirit of "yes, and," let's focus on the warmth.

Conviviality, to me, means "alive, together".

Deeply alive, empowered, leaning into our agency and potential to create good in the world.

Together: not a fortress of individual autonomy, but collaboratively building meaning and goodness.

We are not islands, we are gloriously enmeshed in a fabric of human potential, empowerment, and cooperation.

Our tools should reflect our ideals, and act as extensions of our agency.

The fabric of technology we've enrobed ourselves in is the ultimate tool.

Shouldn't we make that fabric also have that convivial spirit?

You need to exercise it in the small to have any hope of applying it in the large.

The same way that de Tocqueville asserted that you want participatory democracy in the small to have it in the large.

The same way for active participation in and creation of software!

Let's make creativity Turing complete again!

When you're looking at a perfect fidelity one-size-fits-all app, you don't want to tweak it, you'll mess it up.

Perfect fidelity and polish is only feasible for a given scale of market.

But if you relax the fidelity you can enable something very new.

Hand hewn. Rough and ready, but hand crafted by you, something you feel a direct connection to as an extension of you, not alienated from.

Imagine describing a goal and having an application assemble itself.

"Help me organize a birthday party for my four year old."

And you can ask it to tweak itself, or "draw" extra buttons on it that just works.

Low fidelity, but powerful.

It will feel like an empowering toy.

The same way Minecraft invites you to play and modify.

Web sites defined only the semantics, and it was up to the browser to determine precisely how they got shown.

There was a lot of variation in default style sheets, etc.

As time went on, the level of control web developers sought and applied grew and grew.

The semantics got increasingly pinned down, allowing pixel-perfect, high-fidelity experiences, with very little "wiggle room" for the browser to interpret.

This, to be clear, is good!

It allows predictable, high-polish experiences to be built.

It's just that the requisite variety browsers used to be allowed to play within got frozen out.

At the very beginning, browsers used to be easy to build.

Now they're one of the hardest things to build.

Building a browser, even using one of the core open source projects to build on, is like adopting an elephant.

Requisite variety moved away from browser competition, to all requisite variety inside the page rectangle.

Very hard to innovate in a browser now!

It's just a thin shell of chrome (ui) around the main rectangle of page content that has full agency to determine its individual pixels.

Browsers, as large, trust-dependent applications, are also monstrously expensive to distribute.

If you want to make a new innovative type of app experience, don't do it by building your own browser.

"don't design a beautiful website, build a beautiful part of the web"

Now imagine someone demos the web to you by showing a browser that renders a single web page.

That's not an impressive demo at all!

The entire point of the browser is not any individual experience, but the meta experience.

That you can teleport to anything you can imagine, safely and with zero friction.

That's impossible to show with a single page, or even a small handful of them.

You can't get out of them.

The set of constraints fundamentally defines what kinds of things can emerge.

What you can do is pick the ones that allow the kind of coherence you want.

High modernists try to get rid of constraints, or ignore them completely.

Instead, curate your constraints by picking the environment to operate in.

That vibe was not specific to that time, it was specific to that stage of the s-curve.

If AI is indeed a disruptive innovation that will usher in a new technical paradigm, it will feel more like that vibe.

A powerful combination: capitalist drive, technological optimism, hippie-style holistic vibes.

The fallacy was defined by Cory Doctorow.

A seemingly reasonable assumption that is secretly impossible.

A smuggled infinity.

Everything downstream of that assumption is also impossible.

In fractally generated, natural systems, you hit a ceiling when trying to formally model them.

The volume is the value, the surface area is the cost.

Every new rule in the model is new surface area.

As you go deeper into the edge cases and fractal wrinkles, they get more and more expensive to formally capture and model, while the net value captured goes up much more slowly.

You end up with fundamentally more buckets than things to go into the buckets..

There are more ways to bucket a set of things than the things themselves.

This is a combinatorial explosion.

Imagine trying to add a feature to allow sharing with family members.

One team gets stuck down a rabbit hole of trying to capture the full semantics.

"How do I represent the constraint of 'Cousin Vinny is technically family but I wouldn't trust him to be alone with the silverware?'"

They are stuck in the metacrap fallacy.

Another team says, "we will simply not have that feature".

Or, "There is simply a list of accounts that users can control"

A radical simplification that can capture 80% of the problem, succinctly.

A "good enough" solution that requires a curatorial, subtractive authorial voice.

It's easy to add via consensus, it's very hard to subtract via consensus.

The one team that will lose their feature will see it as an existential threat.

The overall benefit of a better-scoped thing is diffuse.

It's easy to add "yet one more requirement" to plans.

To create means to curate means to remove.

That has to be done by an author.

Vetocracies will never ship simple things.

Curation isn't possible.

The ability to make opinionated judgment calls ("we simply won't have copy/paste") on subtraction to make a thing viable can only be done with an author.

Everything is a remix, and yet if all you have is an add operator and no subtract, there are certain things you can't get to.

Assembly theory includes some of these dynamics.

You can have lots of others share their feedback, but it should be up to that editorial voice to decide which feedback to absorb, how to absorb it, and which ones to ignore.

None of the feedback givers should have a veto, except for a "holy crap the whole enterprise will literally die if you do that" emergency brake.

Lindy hear meaning: demonstrated to be extremely resilient.

If you start with emacs you can't get to vi, except with a subtraction operation.

Although apparently there are two concrete implementations of vi that are fully inside emacs.

In those conditions, the emacs shell fades away in importance and the internal vi takes over.

If you do the former, you get a bunch of kindergartners playing soccer, swarming the ball, making nothing coherent happen.

If you do the latter, only the core group focuses on execution and alignment; the others provide disconfirming evidence to help the group survive.

The latter is more like dodgeball than soccer.

Leaving it will feel like death, because you literally do not know how to survive without it as a crutch.

But when you do leave, and you survive, you realize you are a separate thing with agency, and you become even more alive.

Gloriously, precariously alive.

Algorithm hard: extremely hard to think about, but actually only a small number of lines of code.

Integration hard: obvious but requires lots and lots of glue code.

Two common errors:

See an algorithm hard problem and say "that's hard, we need 5 people"

See an integration hard problem and say "connect a bunch of backends? That's easy, we only need one person".

But the former actually just requires one person (although the right person).

The latter needs 5 people (but anyone will do).

The exact same pitch in writing might land very differently.

A charismatic speaker is like a comedian: reading the room, leaning into riffs that are landing, and quickly moving on from frames that aren't resonating.

But writing is one-size-fits-all for the reader.

It can't be as responsive in the moment and bespoke; it has to be robust to all of the different readers who might read it, instead of being custom fit to the audience.

A live pitch is alive.

Flexible, pure, fleeting.

Writing is crystallized in amber.

Robust, resilient, durable.

Don't take yourself for granted!

Have compassion for yourself.

Learn to play yourself like a fiddle, and create the conditions for yourself to thrive, to be in your flow state.

An audacious belief that a massive outcome is possible.

A totally grounded understanding of what's possible and where you actually are.

An existential urgency.

If you can't see the other person you will assume the other person hates you.

Even if every interaction is over the top amazing and clear they value you.

"Oh god last night they probably realized that I'm actually an idiot or a jerk and probably hate me."

The only way to disprove it is seeing the person do something proactively positive towards you.

A nice ping can do it, but those have to be proactive, and sometimes they come across as inauthentic or forced.

But in person it can be even easier/cheaper: when they see you they smile and are obviously happy to see you.

Overly conscientious / insecure overachievers might hate WFH for this reason; when they don't see the other person often they can't reset the "ok, today they still like me".

This is one of the reasons why the PM role is like tofu.

One way is to have full agile, micro-services, swarms of autonomous sports cars.

The downside of this is that the overall result won't necessarily look coherent.

Any time the different components need to coordinate it will be swirly.

Big coherent changes will be basically impossible.

Another way is with a pipelined, coordinated release schedule.

"We release all new features on the first day of the quarter"

Everyone does their bit, and then waits for the signal to launch it at the same time.

This is not too dissimilar how in a processor, the clock speed is set by how long it will take the longest circuit to flow to the checkpoint before being released by the clock signal.

Obviously this has some wastage because there are some teams that get to the ready state before others, and then just sit there twiddling their thumbs waiting for the clock signal to fire.

But it does make coordination much easier; there's an external clock signal everyone knows won't change and they can time their work off of.

An automatic, impossible to ignore schelling point.

And when you're there waiting at the gate, you aren't just twiddling your thumbs, you're doing quality improvement work, testing, etc.

That's a stage that can take as little or as much time as you want.

So a benefit of this approach is that you can also get higher quality output.

Much less agility and no power of the swarm, but like a steamroller reliably producing quality of a given level.

When you have properly absorbed the complexity of a given domain you feel it in your bones and in a way you can't explain to others.

That's knowhow.

They suck to be a person in and they also aren't particularly good at the thing they're ostensibly good at.

Large machines composed of humans can do large-scale things.

But the experience of being a cog in those machines is often not fun.

Large organizations of humans are fundamentally inhuman.

But they're the only way of achieving builder-style large-scale outcomes.

Sarumans correctly see that big companies are incapable of achieving things efficiently.

They incorrectly conclude that the problem is the people being lazy or incompetent.

The problem is the inherent coordination cost scaling super-linearly., a law of physics.

There are ideas that are so big that they can't be done inside a company, where everyone can veto.

Large organizations are not necessarily required for gardener-style outcomes or a Radagast playbook.

When you do an action, you have the direct output that comes out of it, as well as the optics of other people inside being able to see you do it.

The former is what matters, but the latter is what is directly observable from afar.

You can only see the true action -> output if you are up very close.

When the organization is small, everyone can see everyone creating value; they can see the direct line from their actions to the value, and you can see your neighbors, too.

This can lead to a scenius of creation, based on deep trust and intertwined fates.

But as the org gets larger, the direct line from action to value becomes muddled.

You have a larger audience, and from afar they can only see the optics, not the output.

People will judge you based on your optics, and if they don't think you're doing a good job, you might be left behind or knocked out of the game.

So as the org gets larger, you can feel your action to output less (it's more shared) and also the vast majority of people who are judging you can only see your optics.

So the organization becomes about performative actions, not valuable actions. This is inherent in all large assemblages of people.

"Lock it open"

As you get more fit, it oscillates which is the limiting factor.

If your muscles are the ones you can feel holding you back, it's your cardiovascular system that's supporting you.

As you push your muscles they get stronger, and they become the platform to then stretch your cardiovascular system, and it repeats.

Each steady foothold gives you the leverage to take the next step on the other side.

For anything with an ecosystem, momentum is power.

Even the appearance of momentum is power.

A number of tactics kick the can down the road. If you have momentum now but might not later, negotiate now.

You have to fight the law of gravity of preferential attachment and efficiency.

So do it once you have momentum.

The ability to seamlessly hop across altitudes is massively powerful.

Even more so if you have multiple thought partners who can all do it.

Standardization freezes a thing in place (no innovation) to allow open-endedness on top

So make sure that part is either boring or where the open-endedness happens.

"Obviously they have their own… particular perspective. But what I like is…"

Or "there are some things I like and some things I dislike, but…"

If they love them they'll forget the caveat.

Anyone else will think, what a curious, open thinker.

Someone who hates them will think, "hmm, that's a good point, I guess I was writing that thinker off entirely but they have a few good ideas."

A strong boundary helps reduce evaporative cooling.

Communities that can maintain energy even without a clear boundary must have a ton of potential energy.

A community without a clear boundary has a harder time with authenticity and not becoming performative.

Whereas one that has an opaque boundary, where everyone inside is also a participant, there's less performing for, more performing with.

Ontologies are structures. Like all structures, they get brittle.

"Oh hmm, this example fundamentally doesn't fit without blowing up the whole structure."

Like in bin-packing, you want the most different examples to come at the beginning (First Fit Decreasing as a nearly optimal solution for bin-packing).

If late in the game after the ontology has ossified you receive variance you haven't absorbed in your earlier more flexible phase, it will be explosive.

A scenius can start from ordinary components where everyone is basically the same but everyone detects their slight differences and then leans into them.

This process can accelerate and develop it into a highly differentiated set of experts, working together as a whole much larger than its parts.

The Radagast energy is not a generic "do whatever, man".

It's very intense, "be the best you in particular can be, together".

You can't force someone to do a creative act.

That can only happen via a pull, intrinsically.

An ecosystem growing is a self-catalyzing creative act.

An intrinsic energy.

An aliveness.

You can't create internal motivation by outside pressure.

You can't squeeze it to make it exist.