Same project, same skills—better tools. What changed when I built an Atari RL dashboard nine months later.
Like many people of a certain age, Atari games permanently rewired part of my brain. Simple graphics. Brutal mechanics. Immediate feedback.
So, when I began paying attention to reinforcement learning, Atari showed up again—not as nostalgia, but as a benchmark. It was impossible to miss the early work from Google DeepMind, where classic Atari games became a proving ground for modern RL agents. I’d read those papers casually, not to understand how to replicate, but enough to understand the concept: let an agent learn by playing, failing, and improving.
But what if I could build a simple web dashboard that allowed me to watch that learning happen?
Before going any further, it’s worth being explicit about something upfront. I am not a machine-learning engineer. I’m not a front-end developer. I’m not an RL researcher.
My coding skills are basic:
- I can read Python without panicking
- I can write small scripts
- I’m comfortable in a terminal
- I know how to SSH into a remote machine
That’s it. What follows is not a story about hidden expertise—it’s a story about how far basic literacy plus modern tools can now take you.
What Changed In 9 Months
During my first attempt at building this simple web dashboard, the tools failed me. I had AI coding assistants, I had enthusiasm, but what I didn’t have was success. The front end broke constantly, the backend logic drifted, and the reinforcement-learning pieces were either misunderstood or confidently wrong. After weeks of effort, I didn’t even have a stable interface, let alone an agent that could learn anything. The failure reinforced my skepticism of AI hype. So I shut the repo and moved on (at least, that’s what I told myself).
As like most of my vacations, the break from day-to-day seemingly causes projects to emerge (and feel urgent). Nine months after my first attempt I found myself reopening the repo and attempting again. Not out of false confidence that I was now a better developer—I assure you, I’m not)—but because I had watched from the sidelines as the tools improved…significantly.
The newer AI coding agents were noticeably better at reading existing codebases, proposing structure and explaining their decisions in plain language. They didn’t just generate code; they navigated ambiguity. That difference mattered more than raw intelligence.
AI as My Translator
I didn’t comb through the old repository line by line (I couldn’t have even if I wanted to), instead, I asked the AI to:
- Read the codebase
- Explain what each part was supposed to do
- Identify what was missing or broken
That set the tone for the entire project. The AI wasn’t replacing expertise. It was translating complexity into something I could reason about.
My role quickly became editorial:
- Does this structure make sense?
- Does this align with what I remember from reading RL papers?
- Is this directionally correct?
I wasn’t writing clever code. I was making decisions.
Building the Dashboard | Full Stack, Without Pretending I’m Full Stack
This is where the project diverged completely from my first attempt.
One AI agent focused on the front end: a simple dashboard with a canvas to render Atari frames and basic metrics. Another worked on the backend: running the Atari environment and streaming data to the browser. The integration problems that had completely stalled me before—data flow, synchronization, live updates—were handled methodically.
During my first attempt, I lost hours just trying to connect these pieces. But this time, I quickly validated outcomes.
What would someone smarter than me do next?
I want to be very clear here. I am still not fluent in reinforcement-learning algorithms. While I’ve read some of the well-known Atari papers and know names like DQN, I can’t tell you which exact algorithm DeepMind used in which experiment or why one variant beats another.
And the reality is, you don’t need to build what I did. With the right prompting AI will fill in the blanks based on more research than I could humanly do. I allowed the agent to choose the algorithm to use and explain why they made the choice in layman terms.
The agent chose Rainbow DQN and explained it simply. I didn’t design the learning algorithm. I reviewed it, asked naive questions, and made sure nothing felt wildly inconsistent with what I vaguely remembered from the literature. That was enough.
The first full run, the dashboard loaded, frames streamed to the browser and the agent played terribly. But, remarkably it worked. However, the training was painfully slow. At that speed, learning anything meaningful would take days, maybe weeks. I didn’t know how to fix it, but you guessed it, my agent knew.
The AI suggested EnvPool, something I had never heard of, and explained that instead of running one Atari game at a time in Python, you can run many in parallel using a faster system. The AI guided the integration, I validated the result and the training speed improved dramatically. This pattern repeated throughout the project. Deep knowledge wasn’t needed, just enough understanding to recognize progress.
The AI pointed out the obvious: training neural networks benefits enormously from GPUs, recommending Thunder Compute. I spun up a remote GPU machine, connected via SSH, and ran training entirely headless—with step-by-step guidance of course.
I packaged the application, deployed it to a VPS, configured the server, and pointed a domain to it. Late one evening, I opened a browser and saw the Atari dashboard loading from the cloud. I had done it, I built an Atari RL dashboard. Something that five years ago would have been impossible, not procedural.
As you can see, the site shows a live Atari game driven by a learning agent. You can watch it play, struggle, and slowly improve. In some modes, you can even take control yourself. Every interaction feeds back into the system.
So, can anyone build anything now?
Is AI hype starting to live up to its grand promises. Well, I’ll start by saying, I’m still allergic to AI buzzwords. But the fact is, with basic coding skills and today’s AI agents (which are only going to continue improving) I didn’t need to consult an expert to build something outside of my expertise. The expertise was embedded into the workflow.
From my content here on LinkedIn and the conversations we have over on
Navigating Major Programmes
, you’ve probably already inferred that I am passionate about AI integration. This is just a fun, small project that illustrates the possibilities it opens up for individuals to thrive and bring ideas to fruition with fewer roadblocks. It all leads me to ask: what will I build in nine months, and how much faster will I be able to do it?