Early Work

After the early sketches, programming became less about one canvas and more about making small systems work. I was still interested in visuals, but the shape of the work changed: pages, state, routes, sessions, APIs, databases, and interfaces that had to remember something after the first interaction.

Before Spotify Colors, I also had a basic Discord casino-bot idea in this same direction: a bot where people could bet on casino games with an in-built balance, then spend winnings on emoji packs that changed how card suits were represented. Even as a simple concept, it was already about state, game rules, player accounts, and small economies inside an interface people actually used.

Spotify Colors

In 2022, Spotify Colors was one of those projects. It connected a music idea to a real application shape: Svelte views, an Express server, Spotify API work, session handling, and later a client-side version that brought in MongoDB through Mongoose. The core idea was to store Spotify statistics over time, calculate the weekly delta between snapshots, and turn that into something like Spotify Wrapped at a week level. It was not polished like a product.

ARESTv

In 2022, ARESTv was another step in that direction: a small naval strategy game with a lobby, navy builder, ship stats, abilities, a grid-based battle screen, and an account layer. It started from a friend's Discord community, where people were playing a more advanced version of the game through Google Sheets. I found the format compelling and thought it should exist as an online app instead of being managed manually in a spreadsheet.

The code was not refined, but it pushed me into the kind of app work that sits between a visual sketch and a full product: React screens, canvas drawing through Konva, Socket.IO game state, Express routes, JWT authentication, MongoDB/Mongoose models, and game rules that had to stay coherent across multiple views.

2048NN

Also in 2022, 2048NN became my first AI-training experiment. I built it from intuition after watching the 3Blue1Brown neural-network explanation, then turned the idea into a small JavaScript system that could play 2048 repeatedly and improve across generations. The important part was the affinity for AI it revealed before the LLM expansion made AI feel broadly available.

The code used a hand-built 2048 simulator, flattened the 4x4 board into 16 inputs, normalized each tile value, and fed those values through neural-network layers that ended in four outputs: up, down, left, and right. A population loop kept stronger networks, mutated the next generation, and saved progress between runs. The saved file confirms that training state was being persisted, but I do not want to turn that into an inflated score claim. What I remember is more important and less flattering: after about an hour of running it, the first noticeable improvement was only from roughly 250 to 800, and after that it plateaued hard. It was not good at 2048 in any serious sense, but it was my first direct experience of training behavior, persistence, and the limits of a simple model.

Roulette Game

In 2024, Roulette Game pushed the app side further, but it also came from a very specific school assignment. For an English project, we had to teach the class something connected to the short story we had been assigned: an Irish story about a boy who falls in love with an older girl, builds an expectation around her, and then has that expectation collapse. The game used roulette to create the same emotional shape. It built up the expectation that someone would receive a prize, then revealed that nobody received one.

Technically, it was built around logic that had to coordinate between people instead of only responding to one local input. The stack included Next.js, Socket.IO, Redis, and JWTs, which meant I had to think about state across a network, authentication, game flow, and what happens when multiple clients need the same shared truth. AI was present by this stage, but not in the agentic way I use it later: it was non-agentic assistance, not a system planning, coordinating, or carrying the build.

Those projects sit between the p5.js archive and the later portfolio work. They are not the cleanest things I have made, but they show the part of the timeline that is easy to miss: before agentic LLM workflows became part of my process, I was already learning how classes, state, sockets, databases, authentication, and application structure fit together.

That is why the AI part of the story matters differently to me. LLMs accelerated and expanded an existing builder mindset. They did not create it.