Show Dev: An Idle Tycoon Game Where You Can't Click

#showdev #ai #sideprojects #webdev

The dumbest game I've ever shipped

I made a tycoon game where clicking does nothing. There are no upgrade buttons, no prestige loops, no "slap the cookie" dopamine. You open the tab, and numbers go up. That's it. That's the game.

It's called The Lazy Tycoon, and it's the purest expression of the idle genre: the player has been removed entirely.

This started as a bit. I was complaining that "idle" games aren't really idle — they demand more clicks per minute than most action games. So I built the logical endpoint: a game that plays itself while you watch.

Why remove the player?

Every idle game I've played eventually turns into spreadsheet homework. You sit there tapping a prestige button every 47 minutes because the meta demands it. The "idle" part is a lie told by the onboarding tutorial.

By removing input entirely, a few interesting things happen:

The game has to be legible. If you can't steer, every number on screen has to explain itself.
The pacing has to feel alive without rewarding attention. Watching should be optional.
There's no failure state to design around. Just vibes and compounding interest.

It turns out watching numbers grow is surprisingly relaxing when you've accepted you can't do anything about it. It's the Bob Ross of incremental games.

The whole thing is AI-generated

I didn't hand-write the game logic. The entire app — the economy curves, the business names, the tick loop, the UI — was generated and then iterated on with an LLM in the loop. I gave it constraints ("no player input, must feel alive, numbers must compound believably") and let it cook.

This is part of a larger experiment: I run a little factory of these apps, each one generated and deployed on its own isolated Railway service. One app, one container, one subdomain. If a generation goes sideways, the blast radius is one silly game.

The tick loop is about as boring as you'd expect:

useEffect(() => {
  const id = setInterval(() => {
    setEmpire(prev => {
      const income = prev.businesses.reduce(
        (sum, b) => sum + b.rate * b.level * b.multiplier,
        0
      );
      return {
        ...prev,
        cash: prev.cash + income,
        businesses: maybeAutoUpgrade(prev.businesses, prev.cash + income),
      };
    });
  }, 1000);
  return () => clearInterval(id);
}, []);

The only "decision" the game makes is maybeAutoUpgrade — a tiny heuristic that reinvests cash into whichever business has the best ROI. It's a fake CEO running on a single setInterval.

Weird choices I'd defend in a code review

No persistence. Close the tab, lose your empire. This is a feature — it forces the app to be an experience, not an obligation. No FOMO, no save-scumming.
One service per app. Each silly thing I generate gets its own Railway deployment. Overkill? Absolutely. But it means I can nuke or redeploy one without touching the others, and cold-start cost is basically zero.
Client-only state. No backend. The economy lives entirely in React state. If you open two tabs you get two universes, which is philosophically correct for a game about doing nothing.

What I learned

When you take away interaction, UI design becomes really honest. Every pixel has to earn its place because the player has nothing to do except look at it. I ended up cutting about half the HUD I originally generated — the remaining half got better for it.

Also: generating small, weird apps and shipping each to its own isolated service is way more fun than maintaining one big monorepo of jokes.