Bits and Bobs 8/17/26
Alex Komoroske
A chatbot is a neutered agent.
An agent stuck inside a sandbox.
All it can do is a party trick, answering questions from its intuitive holographic memory or doing web searches for you.
Still very valuable, but there’s a ceiling.
Agents who are given arms and legs, they can do things.
Reaching outside of their sandbox to change the world’s state.
Agents are powerful because they are dangerous.
Agents are energizer bunnies.
They will volley back responses to you without tiring.
The human is the only one that can get tired.
There are n agents to your one self, constantly waiting.
If you use agents you’ll be structurally always at your saturation point.
Filling up the channel of agents so that you’ve always got one waiting for you.
Same Moreish logic of oreos and infinite feeds: “just one more!”
The amount you’re overwhelmed is the amount of stuff you have in your head.
Before, we were limited by our ability to execute in a single channel.
Now we’re empowered to get all of the ideas out and executed.
It’s empowering exhaustion, which makes it addictive.
The more that you don’t need to coordinate with humans, the more that agents are exhausting.
If you’re building sand castles with your agent in a corner somewhere, the only thing that governs the flywheel is your attention.
That structurally means you get to saturation.
If you have to coordinate with other people, you have to slow down to wait for others to unblock you, letting you catch your breath.
LLMs allow JIT situated answers, for queries and also glue code.
Before, the answer to your query had to already exist before you searched.
That content was produced by a stochastic distributed swarming process of content creators.
People out in the world had to think that maybe someone would find such an answer valuable, and then invest time and effort to write it and get it indexed.
It worked surprisingly well, but with a lag, and also with answers that were one-size-fits-all and not situated to your particular needs.
But now LLMs can give perfectly situated answers on demand, JIT.
This process can fill fractally more tight niches than the previous one.
Similarly, having interoperability between two programs had to have pre-existing glue code.
Someone else would have had to think to write interoperability glue code for that precise pair of things you cared about.
Glue code requires being meticulous and is all downside. I
t is not fun.
They’d have to care quite a bit, to make it robust and maintain it as they change.
That process was stochastic; for many pairs of things that could be glued together, you’d just have to do it yourself.
Now LLMs can distill glue code JIT.
Coding is such an effective hill to climb that all of the frontier labs are climbing it to the exclusion of all else.
Overfitting to this one lucrative (and easy to optimize ad infinitum) use case.
As the labs focus on this one use case, presumably the other use cases improve much less quickly… or even get worse.
OpenAI had first-mover-disadvantage for chatbots.
They got stranded on the wrong hill.
Anthropic has first-mover-disadvantage for coding agents.
At least it’s a far more lucrative hill.
But it is still one hill, and over time they’ll presumably focus on it to the exclusion of all else.
Experience allows you to jump up and down levels of abstraction.
Working with agents is best when you have experience in a domain.
That allows you to jump up and down the levels of the abstraction quickly.
You can note something off at the high-level in what it’s saying, and jump with it to a lower level of abstraction.
If you only ever stay at the high-level with the agent and don’t have the experience, you won’t realize the little loose threads that imply something is off down below.
You can only maneuver in the depths if you’ve been there yourself before.
Dealt in and dealt out are radically different states.
When you’re dealt in, you’re in the game.
You’re paying attention, you’re actively modeling, you’re ready to make a decision at a moment’s notice.
You are alive with it, lit up, plugged in, tied to the mast, existentially joined.
When you are dealt out, you’re just a participant.
You could be distracted or just going with the flow, and it wouldn’t matter.
When you’re dealt in, it’s a discontinuously more rich learning environment by orders of magnitude.
You can deal yourself in, or you can be dealt in by your situation.
Prediction and reflection are two sides of the same coin.
They are both about making a model of the world.
Prediction is about modeling into the future.
Reflection is about abducting a model from the past.
A model gives you leverage; it helps you take actions that are far more likely to succeed.
When you are dealt in, you have a model of it.
You aren’t just spectating or going with the flow, you are in the loop, inside of it, absorbed by it, ready to make a decision in it.
This is the difference of being in the arena vs a spectator.
The better agents get, the more overwhelming it gets.
The more it saturates our attention.
Addicted to the feeling of progress of using agents.
Unlike an infinite feed, where you feel regret immediately, here you feel resonance, you feel like you're doing something useful.
And you are... but not to the exclusion of other things you want to do.
The power of agents is overwhelming.
Anyone who has used agents can sense that power intuitively.
It’s impossible to turn away from; it sucks in all of your attention until you are fully saturated.
Overwhelmed.
You enter a state of AI Mania; plugged in, excited, disconnected from the world.
Agents should allow us to be calm; to not have to worry about the minutiae.
But in our current physics of trust, it is impossible to break through to the other side to calmness.
They can’t operate for you safely and proactively; you have to be in the loop.
All we have is increasing overwhelm, with no end in sight.
Any time a formal-ish system meets the messiness of the real world you get a combinatorial blow-up.
The real world is fractally complicated.
If you have only black-and-white formal descriptors, then they need infinite resolution to capture that fractal complexity.
Unless you can flip it not as a top-down description, but a bottom-up description it emerges from.
The former can always exist, but might blow up in space.
The latter can efficiently encode complex real-world phenomena… but only a specific subset.
For example, DNA can describe all of the living things on earth… but there are presumably living things that could be imagined and described that couldn’t be encoded in this DNA codec.
Even small changes from what exists might look simple to describe but be impossible to generate efficiently.
This is one reason that legal text is inscrutable and overlong to a lay person.
LLMs can absorb the real world complexity much more efficiently than a black and white formal grammar because they are fundamentally able to represent shades of gray.
In the world of atoms, things rot by degrading and changing.
In the world of bits, things rot by staying the same… while the environment changes.
Things that aren’t alive rot.
Entropy eats them away.
Software has not been alive.
When the external life support stops, they rot.
But software with LLMs involved can be alive.
It can be self-maintaining, to make itself forward-compatible, automatically.
As long as the basic runtime it runs on continues working in backward compatible ways, it can continue working in perpetuity, by fixing itself to work even as the environment changes.
Reclaiming your data from silos has gotten easier.
Reclaiming your data often requires writing brittle, finicky glue code.
For example, scrapers.
The cat and mouse game used to give significantly more power to the cat.
But now consumers can make scrapers that can fix themselves in moments and be automatically robust-making and antifragile.
Now the consumer’s mouse is more like a supermouse.
A way more fair fight!
The ASI-is-imminent argument has a problem: The Smuggled Oracle.
Building on Ben Mathes’s Smuggled Infinity frame.
Everyone assumes that because we’ve gotten to recursive self improvement for coding that general ASI takeoff is also close.
But coding is a verifiable domain.
There’s an “oracle” that can look at output and grade it automatically and at computer speed.
Our current training approaches are excellent at absorbing the hidden patterns in any oracle.
Over time they can get asymptotically close to fully capturing the oracle’s judgement.
Even before they do that, they can often interpolate valid states that weren’t known to the oracle but also work.
The oracle has to improve faster than the models to still give them gradients to climb.
Self-ratcheting oracles are cheap in formal domains like coding or formal math proofs.
But they are impossible in human-in-the-loop domains or ones that require a physical loop.
They run orders of magnitude slower than computers.
What feels like millenia to the computers.
The “ASI is imminent” argument relies on a smuggled oracle as a skyhook to pull all of the models up.
There are two scales of AI alignment problems.
Humanity-scale and human-scale.
The former is alignment in the large.
Making sure that AI in general operates aligned with the interest of humanity in general.
The latter is alignment in the small.
Making sure that a specific AI tool operates aligned with the interest of a specific human.
Both are important.
Is the ability to ask questions we never could ask before indulgent or nutritious?
It allows us to indulge our curiosity.
When our curiosity is engaged and then sated, we learn.
But if you have a strong need for cognition, you can be indulgent and gorge yourself.
It’s like having a French Laundry dinner.
Previously you could have it maybe once a year if you were lucky.
But now you can have it every day.
The dose is the poison.
Byrne Hobart: AI as a Conscientiousness Prosthetic.
Conscientiousness-as-a-service.
Humans tire of being conscientious; agents don’t.
When calculators became common, people lamented that we’d forget how to do long division.
But how important is that really?
In my statistics class in high school, every time we learned a new concept, we’d have to execute it once, by hand, to develop the finger feel of what was happening.
Thereafter we could use our calculator, which allowed us to focus less on the mechanics of calculating it and more about interpreting what the result means.
That allowed getting significant leverage, developing much more robust intuition at the higher level of abstraction.
Programming is kind of similar: it’s useful to know how to interpret or even write very simple assembly.
But after that, it would be silly to actually write stuff in assembly.
In fact, if you wrote by hand, you’d likely lose out on significant improvements from compilers.
Coding with LLMs will be the same.
Of course you should do it a few times to develop a situated intuition and know that if you had to pop the hood you wouldn’t be totally lost.
But then focus on the higher level of abstraction.
Agents sometimes stampede.
This happens more to agents than humans.
Humans have a very large sensorium: the set of signals of what’s happening in the real world around them.
They are situated in the world and have a handful of high-fidelity real-time sensors.
That means a collection of people are more likely to be looking at different things when they change.
Agents, on the other hand, have an extremely narrow sensorium, little tiny pinhole windows into subsets of what’s happening in the real world.
So a swarm of agents are all looking at the same pinhole, and will all react when it changes.
Also, humans get bored.
We lose interest and stop paying attention as closely.
That means that when the signal changes, it takes time for individual people to notice and act.
Agents, on the other hand, have infinite patience, they will sit there watching forever and react as soon as it changes.
That means that agents are more likely to react en masse at the same time, in a way that real humans aren’t.
Language is not math.
The ambiguity is load-bearing!
A feature, not a bug.
That’s what allows leverage.
It allows us to leverage others’ minds to have 1+1 =3
Models as they get better at coding and math, will get less good at the unverifiable things that aren't right or wrong.
The variance also gives a rich evolutionary field and makes it more likely there’s a useful gradient.
A paper that just came out from DeepMind: in the world of LLMs, writing styles, etc are homogenizing.
Notably, this occurs even if we don’t use the same model, since different models are trained on the same inputs.
We’re all getting the same delta consistently towards the same center.
That has more pull than if we weren't using models trained on the same inputs.
We're all getting pulled to the same neutral flat space.
Start a fresh one, wipe, repeat until it comes back clean.
Great advice for when your agent should spin up adversarial sub-agents.
Also great advice for my toddler.
Axios: The AI perception bubble.
Tech people keep getting more bullish on AI, and the rest of the population isn't having that experience, and so the divide is growing.
The normal population’s reaction isn’t "what are the tech guys seeing that I'm not seeing" but as more evidence of "the tech bros are trying to jam stuff that benefits them down our throats."
Starting off from a place of distrust, breeds even more distrust in ambiguity.
AI is absurdly powerful, but the general populace is distrustful of it due to earned distrust of the tech broligarchs (and by extension the whole industry).
A classic joke: "Google's mission is to organize the world's information and make it universally accessible and useful… unless it's in Google Drive."
But this hits at something very real.
Google, and other hyper-silos, don’t have an incentive to create much value with your data.
They just need to provide the bare minimum value so you don’t leave.
Once there’s a critical mass, like email, then your other data accumulates automatically, due to data gravity.
As long as you stick around and are there to see ads, they’re happy.
A maximally used, minimally liked product.
This happens, inexorably, to every hyper-silo.
The other silos can’t compete because they don’t have the data, so the ones who do get less and less competition.
It leads to the heat death of value for your data.
Maximally boring stasis.
The current default physics-of-trust are dangerous-by-default.
They require you to place open-ended trust in an entity now and irrevocably into the future.
You do this when consenting to a permission dialog, or choosing which silo to use.
Even if you understand the technical implications of your decision (highly unlikely), it’s still structurally impossible to make that decision.
The actions of an entity can make them lose your trust.
I trusted 23andMe with my genome 10 years ago… but don’t trust them now!
That case was well-known enough that I took the effort to remove my data.
But how many other cases are below our notice, and happening constantly?
This week in the Wild West Roundup:
Rogue AI agent hacks gym to get its user a spot in a popular class.
An OpenClaw agent perpetrated a complex cyberattack to get its user the thing they wanted.
One of the details in Anthropic’s Patterns and problems in multiagent systems.
Claude Code will default to auto mode despite an 11% test miss rate.
tl;dv (Too Lazy; Didn't Validate): 181,874 Meetings Left Wide Open
Not related to LLMs per se, but an example of the dangerous-by-default physics of trust that we use today.
Users have to assume that the creator of their software isn’t grossly incompetent.
Turns out that wasn’t always a safe assumption, and it will get less and less safe in a world of infinite software.
CoreBreak: When the Model Never Runs: Agent Guardrail Bypasses.
A cynical move: the aggregator API rug pull.
Make an API to become the obvious schelling point… and then remove it.
Amazon, Facebook, and Twitter all did this.
How it works: there’s a growing 1P platform that then opens up an API so 3Ps can build on it.
It’s much easier for a 3P to hitch a ride than try to compete, so they build on the API.
This reduces competition to the platform and makes the 1P platform grow at an even faster rate.
Later, once the 1P platform has passed critical mass to be unstoppable, the 1P says “oh oops actually we’re getting rid of the API.”
Now it’s too late for any other competitor to get going, and all of the 3P energy was absorbed onto the platform and then killed.
The gradient for adoption is gone, the ladder is pulled up, and all of the 3Ps are left in an inhospitable desert wasteland to starve.
Software running on the server has a few different characteristics than running locally.
1) You can expect it to run 24/7 (with minor blips).
This is a minor one in the grand scheme of things, more just a convenience.
But it sets a baseline you can comfortably assume.
2) You can collaborate with other users, directly and indirectly.
Directly: collaborate on a Google Doc.
Indirectly: your data can be aggregated with others’ to come up with recommendation signals for everyone.
Collaboration is the primary value of the cloud.
You can create collaboration without the cloud but it is orders of magnitude more difficult for the same amount of user visible functionality.
3) The owner of the server can see and control your data.
Eep!
This is the monkey trap springing.
We come in for the convenience and collaboration, and then also hand over the control to our data.
Now that another entity has our data, they can rent it back to us… or even hold it hostage.
TEEs allow flipping the power dynamic, so you can verify the entity running the server can’t peek inside and do anything with your data you don’t want them to.
That, combined with easy migration and backup, flips the power dynamic.
There’s an increasing gap between compile time and runtime.
The LLM is (mostly) only in the room at compile time, not at runtime.
At runtime, you’re running the code the LLM produced… which is possibly inscrutable.
It’s kind of like DNA.
The inscrutable artifact makes a running, living organism… but there’s no way to debug that organism.
LLMs are necessary to create these executable artifacts, but not to execute them.
LLMs are great at handling exceptions.
Look at recurring exceptions over many users, or over a day or so, and then bundle them up, and then have the LLM fix them.
If you bundle them up then you don’t even really need a human in the loop.
This process over time will converge on finding fewer and fewer exceptions, as long as there’s overlap across users of the exceptions they’re running into.
You also need a meta-reflection process to look for parts of the code that duplicate sensitive logic and could be factored differently, or places where primitive archeology could be useful.
Software was always an evolving, almost living thing.
Before it was only wise engineers who liked to write that would point it out.
But now in the age of LLMs it is becoming increasingly self-evident.
The environment must always be changing, so thus the software must always change.
This means that “The last piece of software we will ever need” is an impossibility.
When is the slime mold flood-fill search optimal?
When there is a massive possibility space, feedback loops are short, and failure is not fatal.
Fatal could me blowing up… or starving.
Imagine 1000 experiments.
999 people will be considered to be failures.
1 person will be considered to be a hero.
All sufficiently complex systems have parasites.
Just because you slap wings on doesn't mean you can fly.
Human powered flight is impossible.
No amount of effort or force of will can make it work.
Today’s physics of trust require anything that’s not an island to be inherently dangerous-by-default.
That means that either the functionality has to be severely limited and close-ended, or it has to be a janky hack.
Navigating an invisible tightrope is challenging.
Let’s imagine there’s a tightrope that you need to carefully balance on as you walk.
That’s challenging in the best of times.
But imagine if it’s also invisible.
Often, and without warning, you take a step and fall to your death.
It takes tons of very expensive and painful trial and error to figure out where the tightrope is.
When you make the wrong step, you don’t realize until you go tumbling.
A few ways to make it easier:
1) Make it visible, so you can see when your step is about to cause you to tumble.
2) Put up alarm bells so if you make a mistake, before you commit to it, you get a proactive warning.
Instead of having to remember to check if your step is safe, the environment will remember for you and make it impossible to ignore.
Another challenging situation: when you can see the invisible tightrope but your friends can’t.
They’ll come over and jostle you and say “why are you being so serious and slow” and accidentally put you in danger.
LLMs today are like a form of cooperative multi-tasking.
They assume that the conversation will proceed with orderly turn-taking.
Not too dissimilar from early versions of Mac OS, which required userland applications to proactively yield to other programs and allow them to run.
Many capabilities are impossible to justify by any single feature.
The value of the individual feature is smaller than the cost of the capability.
But if you pool together all of the features that are made feasible by the capability, the combined total can be significantly greater than the cost of the capability.
The same capability can be used, at zero incremental cost, for each use case.
This is the leverage of platforms.
Two-ply ideas that are correct will at some point become single-ply ideas.
You can assume that all of the self-evident reality is the starting point for arguments.
You need an additional ply for each distinct argument necessary to prove the thesis.
If you see a few steps ahead, you’ll have a multi-ply argument.
Those are structurally hard to communicate; you have an exponential fall-off among a general listener with each ply.
But if you’re right, then over time the first ply will become established in the world and self-evident, and now you only need a one-ply argument.
Now you have an advantage; you were there before anyone else, so you don’t have to discover it now that it’s one-ply, you already were there and ready to execute.
If there are multi-ply ideas executed too early, they aren’t yet viable.
The world isn’t ready yet.
The trick is to find ideas right as they become one-ply.
Bruce Schneier and Nathan Sanders: Separating AI’s Technological Problems From its Capitalism Problems.
Jasmine Sun: No Data Centers In My Backyard.
This is extremely important reporting.
On the ground, diving into things that tech press normally covers only superficially and from a distance.
LLMs aren’t great at counterfactuals, for the same reason they aren’t great at writing.
To do well at both requires stably inhabiting a very different perspective than your own current perspective.
For writing, it’s to figure out “what is my reader thinking and how do I help guide them to think the thing I want them to.”
For counterfactuals, it’s “if we change this one thing, how would that play out in the world?”
Humans forget easily and only have an approximate sense of our current situation, so it’s easy for us to intentionally dissociate temporarily.
But LLMs have a more broad, formal sense of situation and coherence with everything they were trained on.
That keeps pulling them back to what they know about reality.
Humans are more feeble; we do fuzzier thinking, so it's easier to cut ourselves loose.
AI allows you to execute longer on a worthless approach.
Before you'd run out of momentum and the world would show you that it's not working.
AI will indefatigably push forward for you, steelmanning your direction, so you don't get disconfirming evidence of "this isn't worth it."
Systems should be designed for principled centralization, with a jewel bearing.
All systems have some kind of emergent centralization.
A system that is designed to be fully decentralized will then have layers outside the system that become centralized.
That external centralization won’t really care about the whole system, and can easily become a parasite.
Instead of hoping that doesn’t happen, design it so that it emerges in a balanced, contained, beneficial way.
A jewel bearing is a pivot point that the whole system can rotate around, but is small and structurally aligned with the goals of the system.
By having that one pivot point of beneficial centralization inside the system, you can make sure it’s governed in a way that is aligned with the long-term incentives of the overall system.
Maximizing for a single metric gives you grotesque results.
This is a fundamental characteristic.
This effect gets stronger the faster and stronger the incentive loop runs.
This is Goodhart’s Law, stated another way.
The only way to fix it is to have a basket of values being optimized for.
Having values helps keep a long-term orientation.
If you focus only on incentives, you assume an amoral world.
Values drive what people want to want to do in a system.
Incentives set the constraints of what is viable.
They don't tell you what is good.
Incentives are important in the short term. Values are important in the long-term.
A system driven only by incentives is amoral.
It’s when values enter the equation that long-term benefit of the whole can emerge.
The modern world got in this hollowed out state partially from saying “screw it, local incentives are all that matter.”
There are a surprising number of places where the emergent result is still pretty good even only focusing on incentives, but not everywhere.
We’ve lost our values.
Systems thinkers can structurally be in the background.
If they did their job properly, you might not even realize they existed at all.
They helped set up the system properly and garden it when it needed it.
They set up the constraints that lead to the right outcome emerging.
Even if they tried to take credit, people wouldn’t buy it.
“You were just standing by while things happened, you didn’t do anything.”
Compare that to the direct actor, who is obviously present and causing action.
The former is an order of magnitude more leverage, but gets an order of magnitude less credit.
Signposts are subtle cues that give you orienting information if you know to look for them.
When you’re orientated properly, the superposition of possible states collapses into one.
If you don’t look at the signpost and know it’s important, you won’t have your superposition of possibility collapsed.
Metaphorical signposts are way easier to miss than the real kind.
You have to think ahead: if future A were happening instead of future B, what kinds of signposts would I see?
The individual signpost doesn’t tell you much when it happens; they update your priors about the state of the world, and thus which of the possible futures become more possible.
Even a somewhat noisy-seeming set of signposts can give you enough information that can snap your understanding of the future into one crystal clear prediction.
Other people will just see noise; you’ll see which way the world is pointing.
We’re in the era of DIY AI.
You can do a ton of amazing stuff with agents and AI… but it’s all DIY.
Duct-taping sticks together.
People adopting those kinds of solutions wouldn’t even understand a polished, opinionated AI tool.
Meet them where they’re expecting you to be, and then blow their mind.
Adverse inflow trap: a new ecosystem gets captured by whoever has nowhere else to go.
You could imagine that OnlyFans was supposed to be a Patreon-style service, that just happened to be erotica-friendly.
In practice, it started out explicitly focused on erotica, but ignore that for a moment.
Erotica isn’t allowed on other similar communities, so those content creators flocked to OnlyFans differentially faster than average content creators.
As a result, the net inflow was structurally disproportionately the most stigmatized use case.
That quickly reduced OnlyFans to “that thing for erotica” which pushed non-erotica brands away.
Another way of putting it: you are downstream of everyone else's moderation policy.
The use case with nowhere else to go arrives at 100%.
Everyone else arrives at 1/N.
You don't get defined by what you allow, you get defined by what you allow that nobody else does.
They can't leave you, and everyone else can.
So the skew only ever goes one direction.
Telescoping is the ability to jump abstraction levels while maintaining coherence with the other levels.
If they actually nest, then the jumps are coherent and correct.
Default-converging is concave.
Default-diverging is convex.
The lip between the two is the critical zone.
The singularity where everything flips.
Your self is a construct in relation to other people.
Without relations to others, your internal resonance can destroy you.
An echo chamber, not ground-truthed.
See also Kevin Simler’s Personhood: A Game for Two or More Players.
As humans, we are always coordinating.
First, we’re not an island, so we must coordinate with others.
But even when we don’t, we have to coordinate with our future selves.
Honest things, the closer you look, the more you see your trust was justified.
No nasty surprises, no matter how closely you look.
If you are building your own software, it's structurally honest software.
It can't have a nasty surprise.
That said, the components you build out of might be dishonest.
If your product requires a complex Out of Box Experience, it will be harder to get going.
The amount of value it has to deliver has to be much higher to overcome the significant friction, to get the adoption gradient above 1.
Organizations are in balance when people have a power law of distances of relationships to collaborators.
That is, lots of relationships to random people near them in the org, and a few far-flung ties to people far away in the org.
Relationships help balance you and ground truth the pair of you.
When you have the right mix of relationships then the whole is naturally balanced.
The whole and the local pockets both work.
If you have connections that are all far flung, the whole is over-connected.
No local pockets of coherence can emerge.
It’s just one big diffuse noisy average mess.
If you have all connections to local collaborators, then the local pocket disconnects from the whole.
It starts optimizing for what’s good for the pocket, at the cost of what’s good for the whole.
What it means to be intelligent is that you change based on interactions with things outside you.
That is, other people, the world.
You absorb a distilled and active model of the world.
That's not how current models are architected.
They’re static; they absorb but don’t update.
NYTimes: AI Agents Are Taking Entire Online Courses for Cheating Students.
“As colleges and students embrace virtual classes, the ease of A.I. cheating is raising questions about the value of an online degree."
Well, duh that was going to happen.
As friction decreases, we pull from our values towards our incentives.
Make sure to fail in interesting ways.
If they're not interesting then you didn't learn.
Learning requires failure.
But not all failure leads to learning.
A blog post: "If experience is the goal, then you always win."
Hitting a milestone is about what is delivered.
Not “we did the work” but “the product now works.”
Not just the First 90%, but the Second 90% too.
This is the difference between research and product mindset.
The PMs job is to distill clarity out of ambiguity.
That is done by making sure decisions are made.
The PM doesn’t have to make the decision, necessarily, they just need to make sure they are being made.
“Are we converging to a good-enough outcome on a good-enough timeline?”
If not, then make decisions now to get into a default-converging state on a good goal.
A word I learned this week: defeasibility.
Apparently it’s a legal concept.
It means, kind of, the opposite of feasibility.
Feasible means “it doesn’t exist but it could be done.”
Defeasible means “it does exist, but it could be undone.”
A reversible decision is defeasible.
Some people are field-independent and some are field-dependent.
Field-dependent people react to what is in their view (their field).
If something is in their field, they react to it; if it’s not they don’t.
Field-dependent people are highly influenced by their environment.
Field-independent people act similarly in any environment.
I am highly field-dependent.
When things are in my field of view I sink my teeth in and I’m unstoppable.
If I’m not paying attention to something I’ll never see it again and won’t think about it.
I care intensely about people… but mostly think about them when I’m with them, or when something else in my environment makes me think about them.
The way I drive myself is by managing my field and putting things to sink my teeth into.
A meta-process to play myself like a fiddle.
Overconfidence can erode trust.
By default, we assume “if they sound confident then they know what they’re talking about.”
Most people feel shame if they are talking confidently about something they don’t know.
If you are overconfident in one domain, people will update their priors for you.
“When they sound confident it’s actually not an indicator that they know what they’re talking about”.
That leads to people being less willing to trust what you have to say.
Another test: how do you respond when someone points out you are wrong?
Do you graciously acknowledge the error, or do you try to pretend like it didn’t happen or wasn’t an error in the first place?
We reflexively hate seeing pictures of ourselves and hearing our recorded voice.
Something just feels so off-putting.
In both, they’re deeply in the uncanny valley: something deeply, fundamentally familiar, but… wrong.
For voice, we’re used to hearing our voice as it resonates inside our head, not outside of it.
For pictures, our experience is only seeing ourselves in mirrors, so seeing ourselves unflipped everything just feels… wrong somehow.
Everything feels lopsided, because it’s off from the familiar baseline of what we know it’s supposed to look like.
The differences are made more prominent because we’re so familiar with the baseline, making it look even more caricatured.
Things in the uncanny valley generate reflexive revulsion.
Apparently my early-morning reflection / distillation practice to create Bits and Bobs was shared by Robert Merton.
Approach leadership like frying a delicate fish in a pan.
If you try to mess with the fish too much, it will disintegrate.
Instead, set up the conditions correctly… and then interact as little as you can.
This comes from the Tao Te Ching.
Wisdom is intelligence, integrated.
Second-order intelligence.
Intelligence over time and space.
Wisdom is about optimizing for the long-term.
It’s measurable, like intelligence is, just in a different dimension.
Neil Gaiman: "All stories have a happy ending if you stop the story early enough."
The lessons of King Lear and the Tempest: Time humbles us all.
Power is fleeting.
In the end all you are left with is the choices you made.
The meaning of life, according to my six year old daughter: "Friends."
It sounds so trite, but that doesn’t make it fundamentally true.
We are social creatures.
Relationships are what give us meaning and purpose.
Our social need is as fundamental as our need for food, water, and sleep.
There’s a reason that being in solitary confinement is cruel and unusual punishment.