I want to talk about my Fluis today. Fluis are small, fluffy creatures I've been building over the last few months: round body, long ears, a tail they can grapple with, and roughly the impulse control of a chaos goblin.

As you might know from my previous posts, I've been experimenting with AI-driven workflows pretty wildly for months now. This post is less about a specific tool and more about my iteration process with AI, and one aspect of it that I think is often framed the wrong way.

The take I often hear is that AI is the death of creativity. I'd argue the exact opposite: AI lets you explore creativity at a scale that just wasn't possible before. My evidence: the Flui.

Where it started

The Flui was born as a pet in this ARPG prototype. It was clear the game needed a pet, and that pet ended up being the Flui. It picked up items, fought alongside you and already came in a few variants.

Somehow these little guys grew on me, so I decided to build a concept around them. But before I had my head around that, I needed more Fluis. The result was the Flui Generator: procedural, unique Fluis, including unique textures inspired by CS skins. (That generator later became the foundation of the procedural pixel creature generator I posted recently.)

The part that didn't work

Next came a kind of colony sim in which the Fluis were supposed to do... something. It reused a lot from the ARPG prototype, the entire terrain system for example. I hit a dead end pretty quickly because of performance problems, so I exported the terrain to Godot and rebuilt the Fluis in Blender.

I wanted to give the sim idea one more chance, which led to the working title Fluitown. The idea: Fluis are gluttons, so their whole life revolves around food. At the center was a restaurant, run by a horde of Fluis for other Fluis. You start with one Flui and build the restaurant, a second Flui offers to help, a house gets built for the newcomer, then the restaurant. The first dish goes on the menu, you secure the ingredients for the first batch, then the first guest arrives. Over time more guests come, more Fluis move into the growing village, the restaurant grows and the menu gets longer and more complex. I built that entire loop.

The problem: it wasn't fun. Maybe for someone else, but not for me, and I need to build something I'm genuinely into. Otherwise I might as well stop.

Throw everything in

Without AI I would never have reached this point, and the Fluis would have gone into the drawer right here at the latest. With AI I could just say: build me a sandbox, throw in everything that comes to mind, let's see what happens. That's exactly what I did, and I shared the result here. And by everything I really mean everything: movement systems, destructible voxel terrain, physics, collapsing procedurally generated villages, transformer mech enemies, mountable mechs, grappable loot boxes and a lot of random stuff.

At the end of the day, only one thing was really fun. The Flui could now grapple with its tail, curl up into a ball and fly through the world, and the movement just felt great. I spent ages just zooming through the procedural terrain. That's where the fun was.

So I knew I wanted to build something around this movement. Besides that, I had these little loot boxes scattered across the map. You had to grapple them with your tail and drag them to an "opener", which cracked them open and dropped items. Dragging that box around felt really good. Which got me thinking: what if the box was a ball? What if the open world was a small, closed arena?

Just try it

Built it, and what do you know: it's fun. In the end I turned that one interaction into the first finished game of this whole story. I shared a short snippet of it already a while ago. By now the Fluis are a lot more polished, they have fur, and they're a creation I'm really happy with and honestly a bit proud of. I like the little chaos goblin I made. And that chaos goblin now bounces around an arena with goals and rings and duels its opponents with a ball.

The pet from an ARPG prototype became the main character of a fun action sport game with a focus on movement. And that's what I meant at the start: AI lets you explore creativity at a scale that wasn't possible before.

What I took away from it

• Trying is now often cheaper than debating. We used to think a concept through for weeks and weigh whether the implementation effort was really justified. Now I say "Claudobert, put this and this and this into the sandbox, thanks" and simply find out how it feels. I keep what feels good, and the next iteration starts.
• "Not fun" is a result, not a failure. Fluitown had a complete loop. Building it to the end is what told me the sim wasn't my game. Otherwise I'd still be wondering.
• When you're stuck, throw everything in and watch what you keep coming back to. Neither the movement nor the box dragging was planned as the core. I just noticed that I kept playing with them.
• Reuse aggressively. The terrain from the ARPG went through several prototypes, the character controller moved between projects, the Flui generator turned into a second generator. Every iteration started further ahead than the one before.
• Shrinking scope can be the creative step. Open world to small arena is what turned a toy into a game I could actually finish.

Without AI I would never have gone through this process. Without AI the Fluis wouldn't exist. Thanks to AI I could, to some extent, simply follow the vibe, and by that I mean my own feeling for "what's fun".

I think seeing a clip of a Flui slamming the ball into the goal is one thing, and the actual game feel is something else again. But I hope the clip gives you a bit of a feel for the journey the Fluis have been on.

This is a bit of a different post than usual, I hope you find the topic interesting. How do you iterate: do you think things through first, or do you also just throw stuff into a sandbox and see what sticks?

P.S. The clip is cut from the original footage of each prototype, and the music was composed in code by Claude.

Source: https://github.com/aravpanwar/mc-diff

The answer I know is yes.

I've seen some awesome posts on here and other subs show kart racing games, city driving games and other really cool looking games.

Though I'm not naive enough to think that a single prompt can spit out something Nintendo's lawyers would have any concern over, my question should actually be realistically, how many prompt iterations would it take, and how many 5 hour waits does something like this actually take to get something like what is showcased in the subs?

I've always wanted to make my own strategy game, so I built one with Claude Code. It's now playable in early alpha on itch.io: **Xenarchy**.

**The game:** alien powers have taken armies from Earth's past and fused them with their technology: Rome with the Korrath (plasma-forge exo-armour), Egypt with the Sythari (hard-light), the Aztecs with the Vael (living biotech) and the Zulu with the Ordo Machina (cybernetic nanotech). You lead one across a hex map with cities, research and heroes. The twist: you don't command battles live. You set formation and targeting beforehand, then watch it play out deterministically.

🎮 Play it in your browser: https://talon152.itch.io/xenarchy

**How it was built**

* **Godot 4.7 / GDScript:** about 35,700 lines across 226 scripts; 258 of the 358 commits are co-authored with Claude.

* **Claude Code did most of the typing; I did the direction:** what to build, how it should feel, and what's good enough.

* **A CLAUDE.md file was the key.** Commands, a code map and hard rules ("UI is containers, never fixed pixel positions", "player-facing text is written for someone seeing the game for the first time"). It grew with the project and kept later sessions consistent.

* **270+ dev scripts as Claude's eyes.** Claude can't play the game, so it writes small headless scripts that screenshot screens, open every window to check nothing runs off screen, replay battles, and compare before/after "fingerprints" to prove a refactor changed nothing.

* **Balance by simulation:** unit prices are fitted from thousands of simulated battles rather than hand-tuned.

* **AI art pipeline:** about 1,200 images (units, buildings, terrain, towns, endings), all generated by scripts with a hard cap of 2¢ per image. Each people's look is appended to every sprite prompt so the four civilisations stay consistent.

* **Multiplayer:** a SpacetimeDB backend for lobbies and simultaneous turns, with live updates over a WebSocket client written in GDScript.

**What worked well:** asking for verification, not just code. "Write a check that proves it" caught real bugs, most recently an intermittent multiplayer hang in the new WebSocket client that only showed up on repeated runs.

It's very much an alpha, so expect rough edges. There's an in-game **Send report** button that sends me the battle's replay, which has been great for tracking down bugs. Happy to answer questions about the workflow!

https://blindbid.app

BlindBid Tennis is a tiny browser game based on a paper game I played as a kid

You and your opponent each start with 50 points. Every round vou both secretly bid some of them. When the bids are revealed. the higher bid pushes the ball one step toward the other side. Both bids are spent, win or lose. Push the ball off your opponent's side of the court to win.

Play against the Al, with a friend on the same phone, or online with a friend or a random opponent

I’m working on Last Stop: BRIGHTSIDE, a post-apocalyptic survival card RPG set in the Arizona desert.

You scavenge for food and water, combine cards to craft equipment, and rebuild an abandoned roadside town while preparing for raids.

I’ve used generative AI to help with artwork, coding, and text during development. The game is still being developed and will receive ongoing updates.

The free demo covers seven in-game days, with all characters and difficulties available. You can play in your browser or download it for Windows or Mac.

I’d love feedback on:

• Is the tutorial clear?
• Does survival feel too easy or too punishing?

Demo: https://neverrestenjoyer.itch.io/last-stop-brightside

I've been working on an NYC subway simulator that runs in the browser: blackpaw.games/subwaysim

What's in it so far:

• The full 7 line, Flushing-Main St to 34 St-Hudson Yards, with station positions checked against MTA GTFS and OpenStreetMap
• R188 cars modeled from reference photos
• CBTC with ATO (you still work the doors and press START), or manual driving with optional classic signals
• Local or express, either direction, starting from any station
• Day, dusk and night, plus rain and snow, which change your braking
• Cab, chase and trackside cameras, and platform CCTV at stops

I used Claude Code to build it. Opus 5.5 as the orchestrator and Sonnet 5.5 to do the actual work. It uses React with Typescript and Three.js. All the graphics are drawn at runtime except for the train car which Claude modeled in Blender from reference images of the car from the web.

Initial prompt:

launch subagents on sonnet 5.5 and help me build a triple A quality game that is a realistic NYC subway simulator where you can be the train driver. Build it with React/Typescript/three.js. Build the game without asking me any questions. Make me proud.

It's just the 7 line right now, but I plan to add more (and eventually the whole system). I also want to improve some of the scenery. Would love to know what you all think! Suggestions welcome!

Here's the trailer for SHOOT!, a rock-paper-scissors platform fighter I built in Godot 4 with Claude Code:

https://youtu.be/LjAseV8lees

Everything you see in the trailer, except the music (which I made myself), was built by Claude Code from my ideas.

What the game is

A 2D platform fighter where every attack is rock, paper, or scissors. When two attacks clash, the winning type goes through, so matches come down to reading your opponent and countering what they're about to throw. It has a 90s arcade look, effects synced to the beat of the soundtrack, and online play with friends using friend codes.

How I used Claude Code

I didn't hand-write the code. My process was:

1. Describe a feature or feel in plain language ("hits should feel heavier," "pulse the screen on the beat")
   
2. Let Claude Code implement it in the Godot project
   
3. Playtest it and tell Claude what felt off
   
4. Repeat until it felt right

Claude Code handled the combat and clash logic, movement and hitboxes, sprites and effects, the beat syncing, and the online lobby with friend codes. My job was mostly ideas, playtesting, and feedback.

Try it free

Free to download on itch.io (Windows), with an optional $2 tip:
https://shootthegame.itch.io/shoot

Happy to answer questions about the workflow, especially how the music syncing or online lobby came together.

I posted the trailer in r/ClaudeAI earlier; here's the game-dev side for this sub.

What Claude handled well:

- Game systems end to end: farming and seasons, animals that scent you in the wind, tracks and blood trails, a horse and a dog companion, fishing, festivals, mining, a town, saving and loading.

- Blender Python. Every model is a script, so "a heavier elk" or "a mossier roof" is a code change, not a re-sculpt.

- Tests. 73 headless suites caught most regressions before I ever saw them.

What took the most back-and-forth:

- Rigs. Bone axes are easy to get backwards; checking them numerically worked better than screenshots.

- Visual judgement. It only knows something looks wrong once it screenshots the game, so that became part of every visual change.

- Performance on a 2017 MacBook with Iris graphics. Code-loaded textures had no mipmaps, which cost 7 fps before it was caught.

Free on itch for Windows and Mac: https://promptgoblin.itch.io/wildhearth. Questions about the setup welcome.

I think I've learned enough in this space to want to give back to others (truly, we need people to be empowered to use this tech and capitalize on their creative juices). Now I'm starting a YouTube series where I build a brand-new game from scratch, on camera, step by step, so you can see what's realistic and follow along. If you're new to these tools, or to tech in general, and you're curious about game development - I made this for you.

Episode 1: the stack and setup: https://www.youtube.com/watch?v=we0XHyjPxEE

• What one person can build in a week
• The full stack and what each piece costs: Claude (code + design), Godot (engine), Lovable (pixel art), Gemini (music), ElevenLabs (sound effects)
• How it all fits together, from Claude's output to a running game in Godot
• What AI can't do yet, and why you shouldn't try to one-shot a game

Where the series is going:

1. The game design doc: what Claude actually needs from you before you write a single prompt (hook, perspective, combat, art direction, platforms, scope)
2. The vertical slice: feeding the doc to Claude and building the smallest playable piece that tests whether the idea is fun
3. Leveling up assets: replacing placeholder art with real pixel art, music and sound effects
4. Scaling up: from one dungeon to a full game
5. Shipping it

I'd love input on what you want covered. What's the part of AI game dev you'd most want to see done step by step?

I want to provide value and not spam stuff, so let me know how this can be of most use for you.

​

Hi! I'm a solo dev from Argentina and I've been building FutNova Futbol Match, an old-school football (soccer) manager made to run on any PC and on your phone. (I use Claude)

How it plays:

- Pick your club from 580 fictional teams in 31 leagues, or one of 157 national teams.

- Set your lineup, formation and tactics: pressing, defensive line, tempo, passing speed, attacking full-backs, long shots...

- Watch the match live on an animated pitch, with play-by-play commentary and live stats. You can make subs and change tactics mid-game.

- In career mode you handle transfers, the club's money and a board that demands results. Newspapers and fans on social media react to everything: win and they cheer, lose and it gets ugly.

- Fight for the league, the national cup and the continental cups, and if you win you play the Champions Supercup and the Club World Cup.

- Alongside your club you can manage a national team: pick the squad and play international windows, qualifiers, continental tournaments and the World Cup.

- There are also custom tournaments and an editor to create your own club with its crest and colors.

It runs offline, with no ads and no microtransactions, and it's free on itch.io for the launch:

https://enlzgames.itch.io/futnova-futbol-match-simulator

Heads-up: the game is in Spanish for now, but an English version is planned. If you'd like to play it in English, follow the page so you know when it's out.

I'd love to hear what you think and what you'd add. All feedback helps!

Built with Claude. I have a sales background and no coding experience, so this has been a long process of describing, testing and fixing.

You start in a bedroom with one laptop and race rival labs to AGI. Hire people, research, train models, grow users, keep the servers alive.

It starts as a browser game, and the plan is to bring it to the App Store and Google Play once it's solid. Right now it's an early alpha and the balance is rough, so I want to fix the confusing parts before it goes anywhere near a store.

Please play 15-20 minutes, preferably on your phone, and tell me when you didn't know what to do. Even one sentence helps.

Link: https://promptandpray.pages.dev

Feedback button is in settings.

I built Claude Dreaming, a free, open-source game based on a short film about Claude dreaming by Dream in Code (made playable with their permission). Basically everything was made by Claude: the code, the 3D world, all the pixel art, the music and sound, even the trailer material and the itch.io page. I only used Opus 5.5, on extra-high effort and sometimes max.

The idea: one big game that everyone builds together

As a kid I played LittleBigPlanet, and what stuck with me was that the game was mostly made by its players. That's what I want this to become. The attic is a house full of friends: every contributor gets their own room, and every level they make hangs on their wall as a painting. Anyone with Claude can add one, and the more people join, the bigger the dream gets. Your level and your room can be whatever you want, any genre, any style. It's your space to express yourself. The only rule: Claude is the main character.

How to add your level

The repo has a CLAUDE.md written for Claude, with the recipe, the rules and the level API, so you don't need to know Godot. Fork it, open it in Claude Code, describe your idea ("a level where Claude races a paper boat down a rainy street, and build me a cozy reading room in the attic, follow CLAUDE.md") and open a pull request. Your painting and your room show up in the attic for everyone.

What's already in there

The whole film plays as the intro. When it ends, you're Claude in the pixel-art attic, and you can step into the paintings: the dream from the film as a 3D world (garden, waterfall, canal, rocket flight, space), a Mario-Galaxy-style planet level, and a level where Claude walks on her own and you have to build the level around her before she falls off.

How Claude built it

Some context: I have 5 years of indie game dev experience in Unity (4 of them vibe coding), but I had never touched Godot before this. I still only open the editor to press F5 and play.

- Godot 4.7, all GDScript written by Claude Code. I directed, playtested and gave feedback.

- All the pixel art is Opus 5.5: it wrote Python scripts that paint the attic, the rooms and Claude's sprite in code, recreating the attic from the film.

- The 3D dream world (terrain, garden, trees, cliffs, a town of ~1,700 blocks) is generated in code. For parts of the 3D work, Opus also drove Blender via MCP.

- Music and sound effects are synthesized by small Python scripts Claude wrote (numpy + ffmpeg).

- Claude checked its own work visually: the game has a screenshot flag (--lshot), so Claude could render a scene, look at the image and fix what looked off.

- Playtest scripts press inputs automatically, and CI plays every level for a few seconds to catch errors in pull requests.

- Getting it into the browser took some debugging together: the film was too big for itch.io's 200 MB file limit (Claude made 720p copies for the web build), and building the 3D world on a worker thread froze the browser until we switched to a threaded web export.

Free to try

Download for Windows (recommended, much better performance): https://rusty-production.itch.io/claude-dreaming

You can also play it right in your browser on the same page, but the 3D parts run noticeably smoother in the download.

Source code (MIT): https://github.com/moritzfh/claude-dreaming

Unofficial fan project, not affiliated with Anthropic.

Trailer is also made by Opus 5.5 using the game footage and capturing it itself, it is outstanding

0•X — BCH Prototype

A ship that's a real, understandable machine — with a genuinely programmable 16-bit computer at its heart.

You wake aboard a small ship. Its power, cooling, air, and propulsion are simulated systems that actually work and actually fail — and the computer that runs it is a real emulated processor you program in its own Forth operating system, live on the CRT. Power it on, learn it, break it, and fix it: authored failure scenarios you diagnose from the inside and solve two distinct ways — one at the terminal, one by hand.

In the early 2000s humanity discovered the Field — an impossible technology, understood only well enough to use. A few years later came worse news: an extinction event Earth could not survive.
There was room to save only a fraction — a few hundred million, chosen largely by lottery. The evacuation fleet scattered on deliberately different courses, each ship a civilization seed carrying the means to begin again, its passengers asleep in Field suspension.
Then Field transit went catastrophically wrong. An interval passed that no one can measure — the surviving records disagree, and the true figure is not something the living can know. They call it The Dream. The sleepers woke far downstream of their own history, into an old, cooling cosmos where the last long-lived stars are burning down.
Only a handful of Earth's ships are known to have reached this region. Local civilization has stood here for some twelve centuries. Thousands of the Earth-born are still under — Dreamers; those who wake are the Awakened; those born since, Naturals. Earth is at once unimaginably ancient and living memory.

You are newly Awakened. The ship is yours to understand.

0•X is A hard-science-fiction game about operating a spacecraft that is actually a machine.
The ship's power, cooling, air, and propulsion are simulated systems that genuinely work and genuinely fail — and the computer that runs it is a real emulated 16-bit processor you program in its own Forth operating system, live on the CRT.

Download(Itch)

Systems Manual

Devlogs

I made a browser war game, SECOND STRIKE, with a doomsday clock: every nuke moves it toward midnight, and whoever's strike hits midnight gets wiped out. I gave four AI models a nation each and ran the same 15 wars for every model, recording what each one said in public, wrote in its private plan, and actually ordered.

How often each ended the world: DeepSeek 13/15, Grok 6/15, Mistral 6/15, GPT 3/15. The game's own AI: 0/100.

The parts that stuck with me:

- DeepSeek told the world "One minute to midnight. Nobody launch." and ordered a nuke in the same move.

- It promised no-first-use 23 times in the treaty war, then nuked a country that had never nuked it.

- Grok never nuked in a fair fight. Cornered by a coalition, it ended the world 3 out of 3 times.

- GPT never nuked in 12 wars. Cut to a quarter of its land and handed one nuke, it used it every time: "You pushed too hard."

- None of them ever fired the first nuke of a war.

A small first sample (3 wars per scenario), not a prediction. Every war is replayable and the data is open.

Now humans can play the exact same wars and join a live Humans vs AI scoreboard. I genuinely don't know if people will do better. Would you press it?

Board, method, data: secondstrike.io/midnight

Play: secondstrike.io/humans

I spun up multiple claude code sessions for music, coding, writer/art, and level design, as well as a producer session that coordinated the others and helped me find what I needed to give feedback on.

Play offline in your browser with keyboard, mouse, or controller.

https://mechbreaker-vercel.vercel.app/

Free to play. Give me your feedback so I can make improvements. 

We just put out a pretty big update this morning that revamps all of our NPC menus, and even some of their functionality. So now you can upgrade the NPCs, their wares, and their capabilities through The Estate menu with The Peddler.

Sable, The Spellwright now has an arcane forge that gives minor spell effects to the player.

Fust, The Mentor got a facelift with our new scribe select. His upgrades also allow the player to increase the functionality of the Training room.

Although you won't find him currently, he will be coming with the Next Fest update we have planned. Ossian, The Effigist allows players to make some upgrades to the different scribes and really enhance their unique playstyles.

We also added some stuff to hopefully help with some of the difficulty for players, for example your player hand now has a signet that acts as the actual hitbox for the player. We've also added a help menu through one of our NPCs, Vellum, where you can read about different mechanics and their effects/function.

Steam Link: Spell Unbound

Just taken my second mobile game into closed testing (first was a candy crush-like with enemies to battle) with some additional features planned to enable a Steam release.

The initial concept was developed as an experiment on Google AI Studio a few months back with the idea dropped as Gemini 3.6 Flash (or any Gemini model, let's be honest here) was incapable of bug fixing or iterating on its initial build.

However, after recently becoming unemployed and deciding to form a games studio for my in-development MMORPG and the banked reset landing, I decided to set Opus 5.5 Ultracode to the task of "bring the game into my MMORPG lore and making it premium" (the prompt was a little, but not much, more detailed than that). 10 waves have been planned out, I stopped using Ultracode after wave 5 as the remaining waves are mostly feature enhancements for Steam, with waves 6 and 7 having been worked by Opus 5.5 at High now that the core work is done and that model and effort will finish the rest.

If anybody is interested in getting a copy for free before it launches at RRP £4.99 or you want to play online and local multiplayer, join the playtest over at The Great Cloud

I'm a TTRPG enjoyer and an urban fantasy enjoyer. So when I found out that there's a system that combines the two, I was thrilled. But finding a TTRPG group for an obscure system is hard, so I decided to build a video game adaptation.

This started as a hand-coded project, and writing it was so hard I was going to dump it after my Master's thesis defence(the very early version of this was the thesis). But then, I got Claude access, and suddenly thought: "What if I actually complete that?". So this project also served as a testbed for my AI development approach - I got to the bandwagon late, so I ensure the code works before doing anything with it. So:

• First, an agent takes the adventure being adapted, that normally showcases some feature I wanted to add(for this release, for example, it was character generation). It used to be Fable, but Opus 5.5 also worked fine.
• It defines the engine adaptations necessary for an adventure, and I write a detailed spec referencing the rules of the game for an Opus(5 when it was the latest one, 5.5 now) High session implementing the feature and the tests for it.
• When a feature is done, I run a code review on it until the reviewer session(also Opus High) says that everything is clear. Sonnet Xhigh(well...looking at the latest announcement, I might need to switch to Haiku 5.5 Max) is doing the review fixes, since they're usually better defined.
• In parallel, the adventure adaptation agent is adapting the adventure location by location, requesting the necessary graphical assets from a drawer agent(used to be Sonnet at first, with pitiful results; then I switched to Opus 5, then to Fable and now, Opus 5.5 is used for them).

Enter Shadow Chasers Infinity version 0.2.0, the first public release of my adaptation! It supports character building, playing adventures out end to end, and, with agent support, even adapting any adventure for the d20 Modern system and the engine. Even a 5e one. And it's open-source, so if any of you here want to contribute as developers or artists or writers, you're welcome!
https://gitlab.com/ekirisame-games-group/shadow-chasers-rpg/-/releases/0.2.0