Agentic Software and the Rubik's Cube Solver Fallacy
- 6 minutes read - 1114 wordsThe tech sector is chasing the “software factory”: describe software in plain language, and agents build it. But what’s left for the humans? Are we editors? Acceptance criteria authors? Do we read the code? Or do we trade a certain amount of ignorance for delivery velocity, and let the tsunami of agent-written changes buffet our brains?
Currently the suggested answer is Test-Driven Development (TDD) at scale: humans focus on validation while the agents do commodity implementation. “Validated” code is then deemed shippable.
If this is our bar, I think we’re vulnerable in two ways:
- Validation as the goal loses the why. A solved Rubik’s cube tells you nothing about how to solve one, and it leaves you dependent on the platform that does know: someone else’s AI.
- Even when every unit validates, the magic is in between the notes. The worst failures are the ones where every component “works” and the system still degrades.
Validation as the Safety Net
Earlier this year, the dominant mode of discussion was agents writing with humans reviewing. But with agents editing tens of thousands of lines of code, human review is impractical. I’ve been watching that stone bulwark crumble, and I fully expect it to topple. Once it does, the code becomes “low-level”: a realm of concern beneath notice.
That’s the leap of faith: code that no human reads, so long as it clears a human-set validation bar. The humans hold what Peter Naur called the “theory of the program” and turn it into prompts and acceptance criteria. The agents turn those into code.
How, then, do we know when something has gone wrong? Validation. Writing the validation standard becomes the developer’s job, and a compelling argument against our obsolescence (for now).
But is validation enough? I think not.
Validation Loses the Why
When Ernő Rubik’s cube debuted, I was still in my single digits, but the coverage was everywhere: local news, the New York Times, and every toy store that showcased the “impossible” cube. From a programmer’s perspective, it is a finite state machine with exactly one goal state, and validating that state is trivial: every face is one color.
Over the years, many folks acquired cubes, got their colors out of joint, and despaired at the impossibility of ever getting it right. Books, college kids, and that dad up the street who played D&D were your best bet for the solution algorithm. Then Usenet, websites with Flash videos, and YouTube shorts documented the solution.
Those solutions had you assess the cube and work toward smaller goals: “Build the daisy.” “Create the white cross.” “Position the corners next to the cross.” Even without the spells and chants that achieve these milestones, you can probably picture the cube at each one. The official solve guide is still written this way.
Guides I read in the 2000s mixed plain-English steps with a notation that reads
like a knitting pattern, F R2 L' U, to walk you through the tactics for
reaching each milestone, something like:
Swap your bottom right cube to the top. Rotate the one you want into the place where the freshly rotated-out cube is now. Reverse the first chant to put it in the corner. Do this for all corners until you have a completed white side.
Modern solvers skip the milestones. Snap a few photos of your cube and you get a list of moves: near-optimal and opaque, like AI-generated code. There’s no daisy, no white cross, no equivalent of “the login flow”: nothing a human can hold onto. A solver is optimized to find a path to the solution; it has no obligation to find a path a human could narrate. (Any scrambled cube can be solved in twenty moves or fewer, and the shortest sequences are famously unreadable.)
The human methods, building one layer and then the next, are longer and clumsier, but you learn something from them. You come away able to solve a cube, not merely in possession of a solved one. Follow the solver, and you’re left holding a solved cube and no theory of the program.
That is the Rubik’s cube solver fallacy: mistaking a validated result for an understood one. It’s the trade we make when validation is the goal and implementation is delegated. The tests pass, and the why is gone.
The Magic Is Between the Notes
Take a beautiful Chopin étude performed by Van Cliburn. You could validate every note: right pitch, right duration, right order. A machine could pass that test flawlessly, and it would not be the performance. The magic is in between the notes.
Modern software isn’t merely one cube; it’s walls of cubes, each correct in isolation, but possibly failing in concert. Or, from the soloist to the orchestra: every member may play their part perfectly, but turning perfect parts into a performance takes a master who holds the score and conducts the interactions. Under the “validated software factory” model, we may produce the equivalent of perfect players staring at each other, waiting for someone to start…and so no one starts.
In early November 2026, Microsoft’s Outlook 365 (the 365 being a promise of every day of the year) went down for two days, for reasons unknown at the time of writing. Early signals suggest coordination and shared-context problems en masse, bringing down critical infrastructure for businesses, schools, and governments. If that holds, no single component had to fail outright; the failure lived between the notes.
When It Breaks
As a former sysadmin, I always think about outages.
In a world where humans neither wrote the code nor reviewed it, what do “breaking and recovery” look like? Lacking both the theory of the program and the (maddening) hours spent staring at it on screen, programmers will be as babes in the woods when peering into broken systems. Worse, a few generations on, AI-generated code may deviate significantly from what universities, culture, and the craft have defined as “how we do this.” In time, the customs of AI programmers may look as foreign to our eyes as the architecture of anthills (or freakish medical instruments).
Now consider what happens when an AI coding vendor eventually faces a multi-day outage like Outlook’s. The validated software factory leaves us saying, “I guess we’re not engineering today.” Bosses will bellow: “But don’t you know how to write the code?!” We do, but the code will look different: syntactically familiar, idiomatically odd. And because it was written by computers that didn’t evolve as frightened mammals in an age of larger predators, it won’t be littered with the debug output and error handling a nervous human leaves behind. It will be sure, certain, bold, and valid.
And incomprehensible.