The idea
You're given a random year (2019-2022), then you pick one stock per sector without seeing prices. Eight sectors, eight picks. Allocate $10K however you want. See how you would've performed in that year.
The mechanic is pure strategy. You know the year upfront. So the question becomes: which stocks will do well in 2022? Or 2019? That forces you to think about what actually happened in those markets. Tech dominated 2019-2021, got crushed in 2022. Energy was dead for years then suddenly mattered.
You can't rely on current sentiment. You have to think about historical context and sector rotation. Pick Apple for 2022 and you're in for a rough time. Pick it for 2019 and you're golden. The game forces you to actually know something about what happened in different years, not just have opinions about which companies are good.
It's interesting because most people don't think about markets this way. We know what's happening now. We have opinions about what's good now. But actually understanding how different years played out differently? That's harder. And more useful.
Building it
I started with the roughest possible version. Just enough to see if the idea was even playable. A basic draft flow, mock data, and a simple calculation to show returns. Nothing polished. No styling, minimal logic, just the core mechanic working.
But that rough version was worth everything. Because the moment I had something interactive, I knew the idea worked. I wasn't building abstractions anymore. I was playing a game I'd made. And that's when you actually know if something is fun or not. You can't know that from a design document. You have to play it.
The tricky part was the data. I needed historical stock prices for ~140 tickers across 4 years (2019-2022). Not just any data either, I needed to organize it by year, handle tickers that didn't have complete data (some companies went public after 2019, some got acquired), and make it queryable without hitting an API at runtime. The whole game needed to work client-side, which meant all the data had to be baked in.
Fetching the data itself was a challenge. The API I was using had rate limits, and pulling data for 140 tickers across 4 years meant a lot of requests. Had to add delays between requests, handle failures gracefully, and retry when things timed out. Once I had all the data, organizing it into a structure that made sense for the simulation took a couple iterations. But once the data pipeline was solid, everything else fell into place.
After the data pipeline worked, I added tests because the return calculations were complex. You're buying shares on the first trading day of a year at the opening price, then selling on the last trading day at the closing price. If you mess that up, the whole game gives wrong results. Tests caught bugs that would've shipped broken.
Built a UI that didn't look like it was thrown together in an hour. Used React components, Tailwind for styling, kept it clean and simple. Restructured things a few times to make the code cleaner.
The whole process was straightforward though. I didn't overthink it. I didn't spend days planning the perfect architecture. I just built it, saw what worked, and iterated. That's faster than you'd think.
Tools
Used Cline to write most of the code. Also used Next.js, TypeScript, and Tailwind. Historical data from Twelve Data. Nothing fancy, just tools that work together.
Cline handled the heavy lifting: the simulation logic, the UI components, catching edge cases I didn't think of. I could've used other tools, but Cline's reliability mattered. It never broke something that was already working. When I asked it to refactor the data pipeline, it didn't touch the simulation logic. When I asked it to add a new feature, it didn't accidentally break the tests. That consistency matters more than raw speed when you're trying to ship something.
The other thing that helped: being able to think through problems conversationally. "Here's what I'm trying to do, here's why it's not working, what should I try?" That back-and-forth helped me understand the problem better, not just get code faster.
What stuck
Shipping something rough beats perfecting something theoretical. I catch myself trying to build perfectly all the time. Spending days thinking about architecture, arguing with myself about the right approach, optimizing before anything ships. This time I just didn't. Had something playable in hours. Everything after that was making it better, not building from scratch.
Tests give you confidence to refactor. Each change made the code better and tests made sure nothing broke. Tests aren't overhead. They're freedom.
What's interesting about the mechanic
The game actually teaches you something about markets. Everyone thinks they know which stocks are good. But "good" is context-dependent. The same stock performs completely differently depending on the year.
You realize how much sector rotation matters. Energy stocks were terrible for years. Mining stocks, oil companies, all garbage from an investor's perspective. Then 2022 hit and suddenly they were the best performers. Interest rate hikes, inflation, oil prices spiking. The entire context changed.
Tech did the opposite. Up massively for three years straight. Anything tech-adjacent was printing money. Then 2022 came and valuations compressed hard. Companies that seemed unstoppable got cut in half.
Playing the game forces you to think historically instead of just having opinions. You can't just say "Apple is good." You have to know why it was good in 2019 but rough in 2022. What changed? What was the macro environment like? Why did investors care about different things?
That's actually useful knowledge. It teaches you that markets aren't random, but they're not predictable either. Different years reward different things. Understanding that is worth more than just having strong opinions about stocks.
What's next
I want to add features like leaderboards, charts, and multiplayer eventually. But for now, I'm just sitting with having shipped something. Something that works. Something people can actually play.
That's the win. Not the perfect architecture. Not the most optimized code. Just: I had something to build, and now it exists, and people can use it.
If you're thinking about building something, don't wait for it to be perfect. Build the rough version. See if anyone cares. Then iterate. That's how everything gets made.
Check it out: https://github.com/ethantao14/cline-stock-market-game
