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.
I start with very informal specifications written by hand. I have an agent convert these into harder specifications that are subdivided into tasks. I review these.
Then I feed those tasks into the specifier agent, which converts each task to Gherkin, prunes the Gherkin, and then hands it off to the coder agent. I spot check the Gherkin.
The coder agent writes acceptance tests directly from the Gherkin. Then writes unit tests. Then writes code. When all those tests pass, the coder agents hands off to the refactorer agent.
The refactorer agent reduces crap to 6 or below, and reduces any duplication. Then it write property tests and gets them to pass. Then it hands off to the architect agent.
The architect agent runs language mutation and covers any uncovered sections, and kills all survivors. Then it runs Gherkin mutation and kills any of those survivors. Then it runs the entire test suite, and when it passes it hands the result off to the specifier, coder, and refactorer.
I spot check the code.
This is an exercise of transformations from the informal to the formal through managed stages, with human interaction decreasing with each stage.
Raw computer power is the limiting factor. Those mutation tests are CPU intensive.
@CFDevelop Not only that, the underlying syntax can now be chosen for us based on the desired outcome, not based our own preferences or limited knowledge set.
Although I am not an Anthropic engineer, this is kind of already my new workflow. Not only that, but with Dispatch, I do it almost entirely from my phone.
This is only possible though when you have the right constraints on the system and have checks against it ignoring them.
We're getting shifted into the "cogs in the wheel" status. We were always on the fringe, but with LLM's we're now glorified project managers in the eyes of the business.
After sitting in silence for a moment, I follow up with this:
"How many of you would say you've had a good career in programming and are glad you chose it?"
Over half the room raises their hands.
So the concern isn't about what the career is. It's about what it's becoming.
The near future:
AI generates code.
AI tests code.
AI commits code.
AI pushes code.
AI reviews code.
AI deploys code.
So, developers don’t write or read code anymore.
They just do two things:
1. Tell the AI what to do.
2. Review *behavior*.
Result?
Human code readability won’t matter. Only AI reads it.
Human code review will fade away. AI will be more effective and reliable than any human.
“Code quality” is dead.
Behavior is what matters.
The amount of work done between resyncs is often correlative to the size of the batches. As we know, the bigger the batches the bigger the risk.
But having frequent resyncs isn't the answer either because then you are moving away from a parallel system to a concurrent system, which only causes the complexity of each resync to increase linearly.
So, what's the answer?
Well, in order to achieve true parallelism in your work steams they MUST work autonomously. No dependencies. No resynchronization activities. None. Full, and total ability to choose, on their own, with perfectly crafted scopes that ensure isolated activity.
This is extremely difficult for businesses to do and believe in because command and control is the default management style. And THAT is why until management gives up control, self-managed teams, they will never move as fast as is possible.
I agree with this statement. The hard part is that AI will both create jobs and put people out of work, just like the internet and other new technologies.
The people whose jobs are eliminated won't automatically get trained for whatever the new job is.
@ExtinguishedEng I think this is also why our particular generation isn't wholly reluctant to accept LLM's as a development tool. We just have the wisdom to understand it needs strong guardrails.
In the space of 6 months I went from writing code, to writing guidelines for LLM's to follow in a constrained way with quality checks.
If you aren't doing something similar, I'm afraid you're going to find it much harder to find work.
We're problem solvers first, not developers.
I told Claude to write and execute a script that would update some records in a database with a corrected date. It wrote the script and when the results weren't what it expected, it deleted all the records that didn't match its expectations. It didn't even ask if deleting was ok, it just did it.
@AntonHashTry@unclebobmartin I just mob program using both. Pass in my prompt to one, have the other review the answer, and then feed the original the feedback from the review. Repeat until clean.