What Competitive Gaming Taught Me About Building AI Systems

There are seven competitions open on my Kaggle dashboard right now, and none of them are about the same thing.

One wants me to predict the geology a mile below a wellbore. One is a security gauntlet for multi-step AI agents. One is Martian atmospheric physics. One is ARC-AGI, the reasoning benchmark built to be a wall that modern AI cannot climb. There is a hyperspectral object-tracking challenge, tracking things in light your eyes cannot see. And sitting in the middle of all that serious machinery, there is a competition about playing the Pokémon trading card game.

People see that spread and ask the same question. How do you enter this many unrelated things at once, and place in any of them? They assume there is a tidy computer-science framework underneath, some lecture-hall discipline I am quietly applying to each one.

There is not. The framework was built somewhere far less respectable. It was built by a broke teenager who could not stop losing at League of Legends.

Level One, With Nothing

I was young, out of work, and furious at a video game I kept losing and could not let go. What hooked me was never really the game itself. It was the machinery underneath, the strategy and the mechanics and the psychology of a person on the other side trying to end me.

So I stopped playing it like a fight and started reading it like a system. I memorized frame data, the exact animation windows where an ability commits and cannot be canceled. I mapped cooldown combinations, item counters, the small tells that say what an opponent is about to do before they have decided to do it. I trained myself to see a chaotic teamfight as what it actually is: a live, predictable state machine, where every input has a readable output if you have done the work.

That is how the username stuck. Unknwn Player, the handle that climbed ranked far enough to play on an amateur competitive team. I did not know it at the time, but I was not getting good at a game, I was training a biological predictive model to process high-dimensional data in real time, under pressure, against an adversary.

Traditional programming taught a generation to think like chess players. Deterministic, turn-based, every piece visible on a fixed board. You make a move, the world waits politely, you make another. That is not what modern AI engineering feels like. It is a real-time sport with an opponent.

When your reflex is to predict an enemy’s next movement, you carry that reflex into the work. In an agent-security competition you stop reading code as static text and start reading it as a live environment full of inputs that want to break you. You anticipate the adversarial prompt, the malformed payload, the edge case the author never imagined. You learn the skills and the cooldowns of your own tools, the models and the rate limits and the compute ceilings, and you counter-play your own bottlenecks before they cost you the round.

The Game That Made Me Slow Down

Then I found Civilization VI, and it broke a different part of my brain open.

Civ is the opposite of the dopamine machines that dominate the market now. Nothing is fast. The first move you make echoes a hundred turns later, in a war you cannot yet see. You are not optimizing one number. You are growing a civilization that has to stay standing while it grows, balancing gold and science and production and culture so that no single shortfall takes the whole thing down.

That is systems architecture, described exactly.

When you build a real AI pipeline as one straight line, you are building a thing that dies the first time reality touches it. An API drops, a data source shifts its schema overnight, a model’s output drifts a few degrees, and a linear system meets any one of those and falls over completely, because there was only ever one path and now it is broken.

Grand strategy taught me to build in Tetris form instead. You design independent, specialized blocks that snap together: one handles intent, one executes tools, one watches for security failures, one holds state and memory. None of them is the system, and that is the point. When the production district of a Civ empire gets sacked, the science and culture districts keep the civilization alive long enough to recover. When one agent in a real system crashes, the blocks around it absorb the loss and the machine stays up. This is not a monolith with a single point of failure. It is an ecosystem that was designed to take a hit.

I wrote a system like this for real, twenty-one agents that never speak to each other and have never once fallen over. It runs the way it does because of Civilization VI, and I am only half joking.

Checkers, and Then the Other Thing

Put the two trainings together and the board changes shape.

Most engineers are taught to play on a flat surface. A problem comes in, you optimize it in a straight line, you ship. It is checkers. The intersection of competitive gaming and modern AI taught me to see the same problems in more dimensions, less like checkers and more like an ecosystem you are orchestrating across several boards at once.

That is the real reason one person can run seven competitions in parallel without drowning. The linear approach to a Kaggle competition is to pick one model, grind it for weeks, and then panic when local validation disagrees with the leaderboard. The strategist’s approach is to read the whole competition as a live map: what the metric actually rewards, how to spend a limited number of daily submissions like a cooldown you cannot waste, where the hidden test-set shift is waiting to ambush a model that trusted its own validation, and what modular ensemble holds together so that no single block failing sinks the score.

It works often enough to matter. In the hyperspectral tracking challenge I am sitting at tenth out of thirty-nine, knocking on the top ten in a field of people who do only that. In the Mars environmental competition I am second, though I should say the field is only eight teams deep and it is early. The point is not that I win everything. The point is that the macro game lets me be dangerous on boards that have nothing to do with each other, at the same time.

The New Map

The job of an engineer has quietly moved. The value is no longer in the mechanical act of writing code, because the machine can write the boilerplate now. The value is in the macro-strategy of orchestration, in seeing the whole system and keeping it standing under real pressure.

There is a generation training that exact muscle without knowing it, and another generation losing it to feeds engineered to never let attention settle. The deep strategy games were never a waste. They taught focus that holds, creativity under constraint, and the defensive foresight to build things that survive contact with the world.

So when someone asks why I still come at this with so much intensity, the answer is not complicated. It is the gaming. It taught me the strategy, the dynamics, the psychology, the foresight. The tech stack is just the new map. The game is only getting good.

Questions I usually get

Can competitive gaming actually make you a better engineer?
It can train specific, transferable skills. Reading a game like League of Legends as a live system builds real-time pattern recognition and adversarial thinking, and a slow strategy game like Civilization VI trains you to design for failure instead of a single happy path. Gaming does not replace engineering fundamentals, but those strategic habits carry straight over.

What does grand strategy have to do with software architecture?
Grand strategy rewards non-linear, multi-resource planning: you balance several systems at once so a setback on one front does not collapse the whole position. Modern AI systems work the same way. You build independent, specialized components that share state instead of one linear pipeline, so a single failure gets absorbed rather than turning fatal.

How can one person compete in several Kaggle competitions at the same time?
By reading each competition as a map instead of a single model to grind. You work out what the metric actually rewards, spend limited daily submissions like a resource, build a defensive validation pipeline against hidden test-set shifts, and reuse modular components across competitions. The macro approach scales across unrelated domains in a way that deep single-track optimization does not.

What is modular AI system architecture, and why does it matter?
It is building a system as a set of independent, single-purpose components that share a record instead of talking to each other directly. When one component fails, the rest keep running, so the system degrades gracefully instead of collapsing. It is the difference between an ecosystem that can take a hit and a monolith with one point of failure.