I help organizations overcome the challenges of software development. DM is always open.
Oregon, USA
Joined May 2017
- Tweets6.5K
- Following348
- Followers568
- Likes6.5K
Pinned Tweet
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.
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.
So, waterfall but for agents. π€¦ββοΈ
github.blog/changelog/2026-1β¦
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.
Bishop's Law does not demand you avoid async. It points to an obvious problem with an equally obvious fix:
Parallelism only pays off when the work is atomic. Once you add dependencies you're running a concurrent system and pay its resync price.
Decisions made by the mob are logged. This fixes a gap I see with human teams. Lots of important decisions are not documented because it's a lot of overhead to do so.
Since the agentic mob is not always in agreement on certain things, I have added the decider protocol to their mobbing process.
This has already born tremendous fruit like Grok voting NO on a proposal unless some security measures were implemented.
I think we're going to start seeing the emergence of new coding languages designed for LLMs to work with.
Likely languages that are significantly more terse, have few redundancies, and few commands.
A lot of our human programming languages are built around encapsulation and pattern simplification. Neither of which are necessary for LLM's.
Think _regression to goto_ and you'll be on the right track.
Every once in a while the LLM models don't behave correctly, but I don't want to just stop using them and their quota. So just like with an employee, I created a plan to rebuild trust and responsibility within the mob.
Rung 1 is probation. Very little trust. Low level fixes and menial tasks are often handed to models on this level.
Rung 2 is standard. Standard work is done by these models. Some of it impactful, but rarely critical.
Rung 3 is trusted. More critical decisions are made with models that reach this rung.
The work of each model is evaluated after each task. If there has been an error then the way in which the error transpired is examined. If it was a real mistake on the part of the model, it is dropped down a rung.
After 3 completed cycles with no issues, it is elevated to the next rung.
Each mistake is thoroughly examined to determine cause, and to see if the issue is truly with the model or perhaps an error of communication or context size. Regardless of cause, a mistake still causes a lowering on the ladder. This isn't punishment, since there is nothing to punish. It is simply a matter of continuously evaluating if the system is behaving correctly and giving pathways to generating correct behavior.
I travel a lot for work. I wrote an app for tracking my expenses that uses an LLM to analyze receipts and automatically adds the entry into the system. I further set up an email address that receives receipts either as attachments or sometimes the email itself is the receipt.
I just now told GrokBot (I named it Timmy) to search through all of my emails and forward trip expenses to my expenses reporting email.
I now only need to issue one command to Timmy and all of my travel expenses are tracked. We live in amazing times.
People out here hollering about LLM's following the same bad practices humans follow and then claiming good practices are bad now because LLM's are doing the same crappy things humans do.
π€¨
ok it's official... AI-written unit tests and integration tests are empirically proven to be unhelpful. you should tell your agents to stop writing tests by themselves
on the deepswe eval set, banning sonnet 5.5 high from writing any tests actually resulted in slightly higher success rate (non stat-sig), with less time and token spent (stat-sig). this is pretty hard empirical evidence
across the tests that were written by the "tests allowed" baseline arm, 65% of them were unit tests, 35% were integration tests, neither bucket resulted in any improvement compared to not writing any tests at all
i also picked a random sample of 44 tasks subset where i completely disabled executing even existing tests - it also did not affect success rate at all
i spot checked many tests written in the baseline arm, and my intuition is that most tests are simply a repetition of the implementation
agent-written tests do not add any value because both the implementation and the tests were simply the agent's interpretation of our intent. the tests aren't any more accurate than the implementation itself
i suspect we can still extract some value from unit tests and integration tests if we describe them ourselves when we believe we can articulate our intent better through test cases than through requirements. but i have not proven this yet
also worth noting, during deepswe eval the agent wrote almost no e2e tests (only 17, compared to 3000+ unit/integration tests written). so this analysis does not prove nor disprove the value of e2e tests - i will do another eval specifically for that
"AI writes slop code!"
Hello... have you ever LOOKED at the code humans have been writing for decades? It's dreadful!
AI just doesn't write code the way YOU would write it, just like every other human developer you complain about the first time you open their repo.
Are agents bloating your code?
Stop blaming the agents, they're just following the same terrible habits developers have had for generations.
Your job is now to implement the same safeguards against those terrible habits that you were previously allowed to get away with. The development cycle has been accelerated which means more opportunities for dirty code leakage.
1. Tests coupled to implementation lock in implementation. Tests coupled to behavior don't. That's a test design problem, not a unit test problem.
2. Tests are how your agent verifies its own work. Remove them and you become the test suite.
3. You're counting the cost of tests and none of the cost of the bugs they catch. Check back in 6 months, not 1 week.
We deleted 800k lines of unit tests from the @sazabi monorepo earlier this week.
Three hypotheses:
1- Unit tests "lock-in" slop code by making it hard to change or remove
2- Unit tests slow down dev cycles by making your agent do more work locally and by increasing CI times
3- Unit tests waste money by making your agent generate more tokens and by adding useless CI runs
Will report back soon with the results!
