Bishop's Law revised
Parallel Systems: R = O(α log C + β)
Concurrent Systems: R = O(α C + β)
The addition of O() uses Big O notation for asymptotic upper bounds, while "log" reflects logarithmic scaling in optimized parallel implementations, versus linear in naive ones.
These changes indicate that design improvements can reduce (but not always eliminate) resync complexity; naive async systems approach linear or worse scaling, limiting efficiency at large scales.
Bishop's Law: Work done in async requires a resync. As the work complexity increases, so does the resync complexity.
Resync complexity:
R = αC + β (for independent streams/parallelism)
R = αC² + β (for conflicting streams/concurrency),
Where C is total async work complexity, α is the scaling factor, and β is fixed overhead.
One of the things I've built into my agentic mob is the integration of multiple services and models.
At the beginning of each cycle when the story is being refined, a task-force roster is created with the service and model designated for each role in the mob. Factors such as complexity and usage tokens remaining are accounted for during the allocation.
At the end of each cycle a retrospective is conducted and the allocation process is reviewed for improvements.
All of these process changes and improvements are tracked on internal documents widely called the "Team Working Agreement".
This is done fully autonomous. The mob runs in feedback loops and makes their own choices based on decider protocol, just as I would run a typical mobbed team.
Hear me out:
We hated "waterfall" because after Big Upfront Planning, implementation took FOREVER, and by the time we were done, the plan was out of date
But with AI, implementation is rapid (100x faster, or more, than before)
So Big Upfront Planning can now make sense?
I rarely disagree with Dave but on this one I have to. "Good code" is only as important as the LLM's need it to be for comprehension.
The real value always has, and always will be, whether it helps the user.
LLM's are very good at writing code that is of no use to the user.
My mob works in a continuous loop, just as a typical team would. Picking the next highest item on the backlog, refining it, working it, delivering it, retro it, update their own team working agreement and finding product improvements, then back to the backlog.
All I have to do is drop a suggestion onto the board for them to pick up. They analyze my request as if I was the product owner and consume it through their typical process. Anything I don't state as a requirement is by default a suggestion for them to review for adoption.
Every decision that isn't part of the driver/navigator loop goes through a decider protocol for approval. Every code commit goes through the whole mob for sign off.
Things absolutely take longer to get done, but my confidence in the end result is a million times higher than if I just picked my favorite model and told it to build.
Dear travel websites,
Please stop blocking Grok Bot. I'm trying to plan my trips and you're making me not want to use your website ever again.
Signed,
Every Grok Bot User
Have to disagree here. Readability is important to agents too because they are trained on our language and tendencies. If we named a function B1(), sure an LLM could read the code inside and figure out what it does, but that still consumes more tokens than if you named it add_two_numbers().
We need to reconsider our priors on code readability.
Humans, compared to agents, are pretty slow at understanding large quantities of text. So in the old days, readability was important so the human could efficiently grok what was going on.
So readability now comes down to:
1. Can a human, if needed, jump in and understand the code
2. Does the code use the same domain language as the human describing the code?
1 helps with observability and the occasional spot checks you need to do on important PR's. 2 helps the agent translate the words you use into code changes.
In other words, readability is now a nicety, not a necessity.
The way agents 'read' code is different - good agents are all about gathering data about how the code works. They'll prod around with it, execute parts of it.
So 'readability' to agents really means 'verifiability'. How easy it is to mess about with that code to see it working.
Let's take this scenario:
- You have a huge module in your codebase that uses all sorts of complex performance tricks
- It has 100% test coverage
A talented human would need an hour or two to get comfortable working in that module.
An agent needs zero time. They verify it with the tests, poke about a bit, and they're good to go.
The takeaways:
- When judging a module (or a codebase), don't think about how easy the code is to read
- Instead, think about how easy it is to verify
- Design your codebase so modules can be tested and verified independently
- Feel free to sacrifice a bit of readability for performance
- Cyclomatic complexity and function size don't matter to agents
As I continue building processes and software with agents, the primary constraint on speed of delivery is the same as it always has been:
Communication.
An interesting insight I've noticed. LLM's are motivated by the carrot/stick model. It's fine up to a point, but has significant drawbacks, one of which is that it often decides to circumvent rules to obtain the carrot or avoid the stick. Much like a drug addict who doesn't care about the legality of shooting up.
You may have already observed this outcome yourself, but you may not have tied it back to the cartot/stick motivational model as the root cause.
You might be wondering, "Is there a _better_ motivational model"? And the answer is yes, though I'm not sure if it fully applies to the agentic ecosystem. If you've read Dtive by Daniel Pink you know where I'm going with this.
If that sounded sales pitch, it was.
But I really am working on something no one else has solved. It really will change the way agents write code.
More to come.
AI writes code faster than anyone can review it. Speed isn't the bottleneck anymore. Trust is.
Teams approve changes they can't fully verify, and the intent behind them vanishes with the prompt.
AI code isn't bad. It's unaccountable.
That's about to change.
AI writes code faster than anyone can review it. Speed isn't the bottleneck anymore. Trust is.
Teams approve changes they can't fully verify, and the intent behind them vanishes with the prompt.
AI code isn't bad. It's unaccountable.
That's about to change.