With the resource required to create arbitrary software going to zero, we might see new types of carnivalesque or competitive software games emerge.

Chess is an instructive analogy here. Consider different factors of the base game and how turning the respective dials yields divergent types of play.

• Time constraints: how long each side gets to move. E.g. bullet chess (1-minute games)
• Team dynamics: how many people per side or per board. E.g. bughouse (2v2, captured pieces pass to partner)
• Board conditions: shape, size, or piece density of the board. E.g. hexagonal chess or Horde (crowded pawn mass)
• Win conditions: what counts as victory besides checkmate. E.g. King of the Hill (reach the center)
• Information constraints: what you can and can’t see of the game state. E.g. Kriegspiel (opponent’s pieces hidden)
• Starting conditions: how the initial setup is arranged. E.g. Chess960 (shuffled back rank)
• Piece economy: what happens to captured pieces. E.g. Crazyhouse (captures return to play as your own)
• Simultaneity: how many games one participant plays at once. E.g. simultaneous exhibition (one player vs. many boards)

If one takes building software as a now trivial game then the question becomes, “What’s the new meta game we’ll replace it with?”

This isn’t the same as a hackathon, where resources are pooled and used in a short, intense burst to bust through the sociotechnical walls of a system. It’s also not the same as creating software to serve a user need, sustain a business, or capture value from a market. It’s more like code golf or recreational math.

The factors available to create these new games are more numerous than chess, though. It could even take the form of something like the software Olympics. Within the conventional Olympics, the exhibit is the capacity of the human body to perform at the extremes of certain attributes. For example:

• Speed/power: sprints, swimming, speed skating, weightlifting, track cycling; pure output, no opponent interaction needed.
• Endurance: marathon, long-distance swimming/cycling, cross-country skiing, triathlon; same idea, longer time constant.
• Precision/accuracy: archery, shooting, diving, gymnastics (apparatus), figure skating; judged against a fixed target or ideal form rather than an opponent.
• Direct combat: boxing, wrestling, fencing, judo, taekwondo; win by directly disabling or outscoring an opponent in real time.
• Territorial/tactical team games: soccer, basketball, handball, water polo, rugby; shared board, ball as contested resource, win by score differential.
• Net/asynchronous combat: tennis, volleyball, badminton, table tennis; opponents don’t touch, but alternate control of a shared object.
• Combined/multi-discipline: decathlon, heptathlon, modern pentathlon, triathlon; aggregate score across otherwise-separate events, testing generalism.
• Aesthetic/subjectively judged: gymnastics (floor), diving (form), figure skating, artistic swimming; score is a judge’s read on execution and composition, not a stopwatch.
• Equipment/vehicle-mediated: rowing, canoeing, cycling (road), equestrian, sailing; performance gated by mastery of a device or animal, not just the body.
• Strength/max-output: weightlifting, shot put, discus, hammer throw; single maximal effort, no endurance or opponent component.

A software Olympics could exhibit a similarly dizzying array of human capacity to wield digital machine logic. If we map the above attributes onto something more software-y, we get:

• Speed/power → raw generation velocity: solve N well-specified problems in a fixed short window, no opponent. Capacity exhibited: latency between intent and working code.
• Endurance → sustained correctness over time: capacity exhibited isn’t speed but not degrading; architecture and judgment holding up over hours without the codebase rotting.
• Precision/accuracy → economy of exact expression: hit a fixed target with minimum waste, judged against an ideal, not a rival.
• Direct combat → adversarial reasoning on contested state: real-time, one side’s move directly disables the other’s.
• Territorial/tactical team → coordination under resource contention: shared board, contested resource (compute budget, rate limits, shared modules), win by throughput or uptime differential.
• Net/asynchronous → interface discipline without direct contact: opponents never touch code, only alternately stress each other’s contracts.
• Combined/multi-discipline → generalism vs. specialism: aggregate score across sprint, golf, debugging-under-time-pressure, and from-scratch build.
• Aesthetic/subjective → taste as a judged output: score isn’t pass/fail but a panel’s read on elegance, restraint, surprise.
• Equipment/vehicle-mediated → mastery of a specific gated instrument: performance capped by fluency with a constrained tool, not general ability.
• Strength/max-output → peak ceiling, single maximal effort: no endurance or opponent, just “how much can be generated correctly in one shot.”

Such an exhibit might conceivably be a better benchmark for agentic technologies and released intelligences.

Most benchmarks compress down to pass/fail on a fixed set of tasks. These get quickly gamed because the economic pressure atop the final scoring is so high. Or they go in the other direction and seek an untouchable level of generality, such as the ARC-AGI benchmarks.

A software Olympics, however, profiles across axes—speed, judgment under pressure, taste, endurance—in a way closer to a decathlon score than a single test result, testing distinct, competing attributes of an underlying participant in structured, sustainable ways.

It may also turn out to be a better orientation for the world now unfolding. The old world measured software by whether it shipped or captured a market, and assumed building was the bottleneck. But once building is free, the frontier is determined by who wields unlimited production well.

The software Olympics could be more entertaining, more informative, and more useful than what we have now. Instead of dubious benchmarks, marketing hype and alignment incidents, we could have a recurring spectacle that showcases what these systems (and we in turn) can do.