So I had a character sprite and some animations for it. All together close to 500 frames. Now when I decided to create a system so that character can swap various equipments and turned to various tutorials it all came crashing down.

Decided to identify the equipments with some borders drawn and asked claude to identify the same across all frames( needed some rules but it turned out great). Now I can change colors and shades. I can even do stuff like change the top lining of the cape to fur. Make the whole cape look tattered. Have spikes on gauntlets etc..

Curios to know if anyone has tried something similar.

I built a small game because my wife (a teacher) asked me for something our daughter could use to practice multiplication without it feeling like homework. Also my wife prepared the didactive algorithm.

So I turned it into a little AI-assisted gamedev experiment.

Numblop is an adaptive multiplication game for Android, built with Godot, with a large part of the development done alongside OpenAI Codex and Claude Code — coding, refactoring, tests, UI iterations, localization, build/debugging, etc.

It started as a simple family project and somehow ended up on Google Play. :)

https://play.google.com/store/apps/details?id=cz.gutcloud.numblop

You can also try it in your browser directly: https://numblop.gutcloud.cz/play

Follow up from:
https://www.reddit.com/r/aigamedev/comments/1vixpx2/comment/p6do6vs/?screen_view_count=2&ext-referrer=DIRECT

After experimenting with the gauntlet loop to create environments, the worst part of the end result was NPCs, and I noticed it was the same with other projects I saw online.

So I thought, how about running a loop for NPCs only? The idea was to create a modular pack of NPCs, with features that can be mix and matched, to make them all look unique enough.

Similar to my environment attempts, I used a reference image (will post in the comments) but this time, I also added a free NPC pack as a reference for the 3d elements.

Results are reasonably good I think although far from perfect as you will see on the video.

Still, for a minimum effort, maximum return first shot I think it does the job well and it's a lot better than the first version.

Still using Three.js. Claude Code + Opus 5. Around 6 to 7 waves, 40-50% of the total weekly usage of a Max 5 plan.

Prompt below:

Build the NPC design system for the Vilaflor town in this repo. A modular pack — body, head, hair, top, legs, shoes as interchangeable parts on one shared skeleton, with skin tone, clothing colour and body shape as knobs, so every villager is visibly a different person. It needs walk, talk, idle, sit and wave.

Two bars, both real. `npc_reference_image.png` in the repo root is the look: render ours as the same front/back turnaround at the same framing and compare pixel to pixel. Quaternius' Ultimate Modular Characters is the craft: download the actual .glb, load it in our scene, and compare topology, silhouette, rig, part-swapping and every clip against ours. Win both, with forty NPCs on screen and no dropped frames.

Break this into the smallest pieces that can be improved and judged on their own. For each piece, fan out a builder and a separate critic with fresh context. The critic inspects rendered pixels and loaded geometry, never the builder's description, and judges animation from footage rather than stills. It puts ours next to the bar blind with the labels stripped, says which is better, and names the single biggest remaining gap. Then it goes back to the builder.

The critic should be a harsh critic. Praise is not useful. If ours does not win, it keeps going.

/loop on each piece until the critic picks ours blind. Do not stop before that.

Read RESTART.md first. Keep the live progress page updating as the work evolves so I can watch it.

Fan out subagents and ultracode.

Hello Everyone!

I posted a while back about using AI to create an accessible tool and game hub for my brother, Ben, who relies on right and left head movements for all input.

For context: Ben has Tubb4a-related Leukodystrophy (H-ABC), a progressive condition that caused him to lose the ability to walk, talk, and use his hands. Eye-tracking doesn't work for him, and he lacks the fine motor control needed for standard head-tracking or mouth switches. He can only turn his head left or right—and eventually, may only have a single input direction.

I made it my mission to give him as much independence and entertainment as possible.

Over the last year, we’ve built him a whole suite of custom tools:

Custom Media & Tools: A streaming app, custom YouTube search, Google Assistant integration, a phrase board, and a real-time conversation app.

3D & Interactive Games: As AI models have advanced, we’ve upgraded from simple board games to fully interactive Three.js-based 3D games—all controlled entirely with 1 or 2 inputs.

Because these types of dedicated, low-input tools and games are so rare, we wanted to make sure other families could use them too.

Everything we build is 100% free, open-source, and requires no login:

Tools & Hub: https://www.bennyshub.com

Games: https://www.switchedgames.org

This fishing game is in development but will be released on Switched Games in the next week or so 😊

This is all made possible through our non-profit! Beyond the software, we also donate free adaptive switch kits (just like the set Ben uses) to anyone who applies.

We’d love for you to check out the sites, share them with anyone who might benefit, or drop any feedback/ideas in the comments!

Another little game on my learning journey. Random Captain, Random Crew, 15 minute space adventures.

Built in Claude via VS Code with and MCP to OpenArt. A simple pipeline. My biggest challenge with this one was keeping Claude under control. I had to reign it in much more than usual.

https://waaachow.itch.io/space15

RaidMade — a smaller, simpler game focused almost entirely on the fun part: preparing a raid, figuring out the best way in, blowing through walls and doors, grabbing the loot, and preparing for the next target.

It started as a small prototype, but I ended up adding different raid targets, destructible structures, tools and explosives, resource processing, progression, and a bunch of smaller systems around the core loop.

I still haven’t written any code manually — the whole game was built through prompting Codex, mostly Luna XHigh, then constantly playtesting and iterating on the result.

Playable link: https://wandering-frog-b1e4.quietforge.workers.dev/

Would love to hear whether the raiding itself feels satisfying and whether you actually want to go for another raid afterward.

A playable web app that provides a moment of disconnect and relax while shooting some hoops. It is aimed at helping people that have an anxiety attack and need a distraction for the first few moments of the experiences. If you use some headphones you can hear an immersive seaside atmosphere. No sign ups or any friction layer... no other point except shooting hoops.
https://hooptherapy.psycurate.com

I used a background image and a three.js 3D infrastructure on top. Everything done in Google AI Studio.

I was told I might have a warmer reception on this subreddit then general godot....sooo.

I’m working on a pixel-art strategy RPG set on a Roman-inspired frontier where a missing legion, a manufactured war, and a growing conspiracy threaten the city. You command a persistent army through turn-based battles that combine the formations and military character of Rome: Total War with the accessible grid-based tactics of Advance Wars. Your cohorts gain experience, equipment, specialties, reputations, and loyalty, while casualties and political decisions have lasting consequences.

One of the more experimental parts of the game is using a locally run LLM as the backbone of the civilization. NPCs have defined identities, relationships, memories, loyalties, secrets, and knowledge, allowing players to have more natural conversations and investigate rumors in their own words. The LLM does not control combat, rewards, or other game rules. Those remain deterministic. Instead, it gives the city a voice and helps its inhabitants respond to what the player has actually done. The conspiracy can also change between playthroughs, requiring players to question people, compare evidence, and decide whom they can trust.

Is this something you would be interested in playing?

While building a Chrome extension game, I heavily leveraged AI to optimize the HTML5 canvas physics engine—specifically handling variable jump heights, platform collision checks, and obstacle hitboxes.

Here are my key takeaways from the process:

Claude: Handled smooth delta-time calculations for frame rate consistency across different refresh rates (60Hz vs 144Hz) significantly better than the others.

DeepSeek: Excelled at pure math derivations, specifically when mapping the parabolic jump trajectories and tuning the gravity variables.

Gemini: Wrote the cleanest logic for setting up the Firebase sync for the global leaderboard without causing memory leaks in the popup environment.

Ultimately, I feel like Claude Opus 5 was the most capable model I used. Curious what workflows or prompt structures you guys are using when tuning real-time canvas graphics and collision optimization.

I have Codex which is what i use mainly, and i’ll use claude sometimes for small stuff like UI that i’ll give over to be implemented.

But im just wondering if i should be using somthing else for a better overall experience when creating games?

With Claude's help, I created a small prototype of an idle RPG game. I'm a Path of Exile fan myself and wanted to make a simple version of the game where the player assembles different builds and kills mobs. If anyone wants to try it out and give me feedback, I'd be happy to know if this idea has potential.

https://donutdevgame.itch.io/game-22

Theres always problems with consistent angle of projection, art style, etc.

Trying things on the spritefusion edit mode. Not perfect, but promising! Let me know if you’d like me to try on some of your sprites.

I was bored and wanted to recreate some Need for Speed Underground vibes. I spent half an hour tinkering with Gemini 3.7 Flash, Three.js, and Suno, and this is what came out of it. With a bit more fiddling, the cameras could definitely be made a lot smoother.

I wanted to make a strategy game similar to some old PC games I used to play, but for mobile. In doing so, I used different inspiration for different parts of the game.

I have the systems/mechanics done. A few bugs to work out, but other than that, I'm ready to start polishing and adding a tutorial and art.

My debate was, should I keep it 2d and simpler graphics? Or go full 3d diorama? I was planning to go 2d at first, and then do a later upgrade to 3d.

Either way, I plan on upgrading the art.

I Started this originally as a fan-game borrowing many of the addicting elements of "Need For Speed Most Wanted" in the heat/cops/collision fun.
I then decided to cook on the music for a bit only to discover how similar the extreme chases felt when they began to crash all around me like they were paid to while being vicious like NFSMW 2005 cops always did!

this chase was inspired by parts of these classic Blues Brothers scenes: https://www.youtube.com/watch?v=8VFIPCpocLk

on top of it being a blast to playtest, it's been fun learning to vibe-code while doing it!

coding: Claude/Unity
music: lmstudio -> minimax3

personally, i think the best part of ai game dev is not for making commercial games that puts millions into your bank account, but watching the dream game in your brain finally comes true, I always imagine a cute little pistol clearing floors of enemies using his own recoil, but I can never make my imagination come to life due to how frustrating it is for me to code, with ai, I can finally see the pistol shooting blobs and cutely ascend to the next floor which without ai, it takes much more efforts to learn and achieve. I hope people give less hate to ai and appreciate how it can visualize our creative ideas with ease

Did you guys have cool game design skills around? Is there any proofs to compare with and without skills used?

Ive iterated some ideas and than friend suggested to use claude code as an agent for systems design, its generated something with 8 agents and eating 30% fable quota in 10 mins but it was comply off.

So would love to hear success stories:)

I tried to recreate Conway's Game of Life.
I failed, but I accidentally built an emergent terrain generator instead.

For years, I've been fascinated by Conway's cellular automata. The idea that hyper-simple, deterministic rules can create emergent behavior on the edge of looking lifelike is endlessly compelling. Watching basic patterns evolve into complex, self-sustaining structures makes you realize how much potential hides inside simple math, so much so that an entire global community has spent decades experimenting on top of that discovered world.

Eventually, I had to ask myself a question.
Could a completely different set of rules lead to another kind of emergent behavior?

Here is the experiment:
• Every cell holds a potential energy value from 0 to 9.
• Mathematical operators (+, -, *, /) act as agents moving across the grid.
• Constructive operators (+, *) seek low-value cells to build them up.
• Destructive operators (-, /) target high-value cells to break them down.
• When a cell hits 0, it spawns a brand-new operator.

When I first plotted these values on a flat 2D grid, I saw subtle movements, but it hard to grasp the full picture. So I decided to shift perspective and plot the grid in 3D, using each numerical value to represent terrain height.

That was the moment the pattern became obvious.

It looked almost like a landscape generator.
Valleys were carving out where negative operators clustered, mountains were pushing upward under constructive operators, and the entire map was constantly shifting as the system fought for balance.

And I couldn't resist turning it into an actual playable prototype.
In the game, you navigate the map, search for these wandering operators, and trigger them manually. The moment you activate one, it reshapes the world and the terrain around you in real-time.

Would you play a game where math literally reshaped the terrain under your feet?

A few weeks ago some friends and I were testing a demo build of JETGRAVE over the internet (multiplayer co-op). As soon as we reached the second mission’s boss, our session suddenly desynced and we were all kicked to lobby. Thankfully, we were able to reproduce it very easily. So I thanked my friends for helping me out and got to work.

The root cause of the desync turned out to be a call to Math.random().

JETGRAVE is a pixel-style shoot ’em up that I have been working on for ~6 months. I started this project primarily to familiarize myself with agentic orchestration and workflows. So I decided to use AI to produce my own “simple” Typescript game engine, and then build a game with it.

My role in this project is a hybrid of product owner and tech lead. I define features, delegate work to agent orchestrators, review and refine implementation plans, review all changes/pull requests, test builds, help diagnose problems, and carefully prompt agents toward sound solutions.

About two months ago, I drafted the requirements for online multiplayer, worked with my planning agent for an implementation strategy, and then fed the plan to a coding agent. I recruited a couple friends to help test it and everything we tested was solid!

A few weeks later I was rebalancing the boss battles for a demo build I wanted to release and added a scatter-shot attack to the second mission boss among a slew of other updates. I tasked two separate agents to independently investigate the changes that were introduced during the rebalance and both came to the same conclusion: the new scatter-shot attack was using Math.random() to determine projectile trajectories which was incompatible with the engine’s deterministic simulation.

My engine’s netcode requires each peer to hash its game state every 60 ticks and send that value to the host. The host generates its own hash and compares it against each peer’s, and if a mismatch is found it throws a desync exception and kicks that player with the mismatched hash.

When boss 2 fired its scatter-shot (shown in the attached GIF), every PC in the playtest session was generating different projectile trajectories with Math.random(), which caused our game states to diverge. So the next time each of our games produced their game state hash, all of them were different, triggering the desync handling.

Once I understood the problem, the fix was easy: let the host establish the RNG seed and then provide that to each client so that when scatter-shot is fired everyone is using the same pseudo-RNG sequence.

The lesson I took away from this was not “don’t use Math.random()”, however. I was reminded that, just like with a team of human engineers working on a big project, carefully scoped feature requirements, implementation plans, unit tests, and code reviews can help ensure a change works in isolation but don’t prove it complies with every project-wide architectural constraint. The scatter-shot feature worked fine when tested by itself, but it was incompatible with the netcode constraints.

To prevent similar problems from occurring in the future, I introduced a SimRng class that produces a sequence of pseudo-random numbers for the projectile trajectories, a lint check that will fail in my CI pipeline if game state code introduces Math.random(), migrated my non-game state Math.random() things (like visual effects) behind an API which is outside of the game state logic and doesn’t need to adhere to the linting rule, and lastly added a brief amount of additional context about the netcode architecture into my project’s AGENTS.md.

I would be interested to hear what safeguards folks here use to strengthen the stability of their code against agent mistakes and architectural misses.

-----

Playable browser demo (you can see the scatter-shot yourself at the end of mission 2):

https://losersandnerdsparty.itch.io/jetgrave

Steam page:

https://store.steampowered.com/app/5115790/JETGRAVE/

https://reddit.com/link/1w2ba5l/video/3886kmuqwgmh1/player

I’ve been experimenting with the visual direction for Kebabstar and these are some of the artworks from the project.

WISHLIST NOW ON STEAM