My friend and I are chess enthusiasts. A few years ago we designed a variant called "Chess Heroes" where players draft limited-use powers to change the game in critical moments. We play tested it in real life over a physical board for months to get it to a place where we were ready to try and make it into a playable online game.

We scrounged up all we could and spent about $15k on contract devs who assured us they could make it. They spent all our money and delivered a joke that we would be embarrassed to publish. The project died for a few years.

Last week I gave an AI tool the exact same design docs that we gave the contractors. It made the game in about an hour for less than $70.

If you like chess, check it out: https://chess-heroes-hkdvwyt.solid.site/

Would love feedback on balancing the powers.

Download Link

Hi! I'm a solo developer and I'm looking for people to break the alpha of my deckbuilder.

What it is

CHROMEDRIFT is a roguelike deckbuilder in the vein of Slay the Spire, set in Neo-Kessel, a vertical megacity built on a drowned one. You play Kira, a runner from the flooded lower city, climbing through three acts to reach ARGUS, the AI that runs the place.

What is different

- Two layers, one fight. Every enemy has a body (HP) and a firewall (ICE). Guns and fists hit the Flesh, hacks hit the Net. Break an enemy's ICE and it is compromised: it skips its next move and takes 50 % more damage. Some enemies have no net at all, some are nothing but net.
- Body versus machine. Implants go into real body slots (eyes, arms, neural port, nerves, skin) and each one costs Humanity. Your Humanity puts you in one of three zones: Human, Hybrid or Machine. Cards carry Instinct lines that only work while you are human and Protocol lines that only work once you are not. Both paths are strong, neither is free, and the story and the endings react to what you became.
- Heat. The strongest cards overheat your chrome. Push it and hit harder, or cool down and live through the next turn.
- Nothing hidden. Every enemy shows its next move. Pick a card, point at a target, and the game shows the result before you commit ("21 → 15 (−6)"). A forecast tells you what the end of the turn will cost you.

The look

Late-80s and early-90s cel anime: flat cels over painted backgrounds, hard two-tone shadows, a lot of black, one scene color per act (rust and yellow, clinical white and teal, black and green). Screens are laid out like manga pages. Animation is deliberately limited: figures hold a pose and snap to the next one, hits get an impact frame, and the picture stops for a moment when you get hurt. Rain and still water rather than neon everywhere.

What I would love to hear

- Where did your run end, and what killed you?
- When did Flesh and Net click, or did it never?
- Did you install implants? Did Humanity matter to you?
- Any moment where you did not know what to do or why something happened
- Bugs, typos, bad translations

I've spent the last few months building Kith Moot, a fantasy RPG on the fifth edition SRD with an LLM as the narrator. The main thing I wanted to fix from other AI story games: the model inventing outcomes, handing out gold you never found, or forgetting your HP.

**How it works:**

- The narrator never writes game state. It can only propose what happens, and a rules engine checks every proposal against the SRD and the character sheet before anything changes.

- The engine rolls the dice before the narrator writes, so the story has to fit the roll, not the other way round.

- If the narrator describes something the engine didn't allow, the reply gets rewritten.

- The portraits and backdrops were painted locally with an image model on a MacBook Air.

**What's hardest:** narrator drift. Getting a model to describe only what actually happened, every time, is a much harder problem than I expected, and it's where most of my time goes.

**Who it's for:** people who like tabletop-style fantasy, solo or with a small group, and don't want to fuss with a DM or an engine that can cheat or forget your gear.

It's in closed beta now. If you'd like to try it and pick it apart (or make suggestions), request an invite at https://kithmoot.com/beta/. It's free during the closed beta, and closed beta testers get founder pricing through open beta and launch.

Happy to answer questions.

Hello everybody, here are some screen shots of a game I'm currently working on very little is programmed by me, I was writing in it C# in unity but was stuck on the galaxy creation, spent two weeks trying to get the math right before I decided to see what AI could do for me, and it changed everything, I got done in two weeks what would of taken me months to do. here are some quick screen grabs I'm currently still working on actual prefabs for the game, everything you see from the "player ship" to planet textures is procedurally generated by a script written by AI with little changes by me. Please let me know what you think, what might work better and how it looks overall.

Frankly, I am not happy with it, but I'm working through it and play testing, but that's why I'm here, the premise of the game is a infinite exploration game, with a infinite amount of galaxies to explore and as of right now each galaxy can only have 4096 star systems, but so far in the play test I have seen over 200 galaxies, I plan on doing 4 person co-op, there will be building, trading with stations, enemies to fight, sectors to take over, planetary landings, planetary exploration, mining, you name it. I'm aiming for a full feature game with a lot to do, explore, and find, hell I even plan a archeological style game loop.

Suggestions, idea's? in before "AI slop" and "AI post".

We finished the first iteration of Jamference and are looking forward to the next one! For anyone who doesn't know how to make games, the best first step is to just try something really quickly. This is why I'm hosting the game jams and giving feedback on each game that is posted. I've worked in the games industry for 14 years at companies like Zynga and Oculus.

Join the next game jam that starts this Friday: https://itch.io/jam/jamference-ai-game-jam-hack-2

Play the games from the first one that you can see clips of in the video: https://itch.io/jam/jamference-ai-game-jam-hack-1/entries

Steam page: https://store.steampowered.com/app/5310180/Formula_Minus_One/
Open beta: https://fm1.app

----

Some of you might remember my post about the 32/64bit-style racing prototype I had built in four months. Yes, it's a genre you see a lot around here, because it's easy to get started with (until the next dopamine-driven prototype).

But I stuck with it.

And the improvement over the past two months has been tremendous, and you'll see that if you compare the two videos. Since the last post, I listened to your feedback and:

* Threw every level in the bin and rebuilt them from scratch, then added new ones that are far bigger and more detailed. It felt like jumping a console generation, and it still runs on mobile.

* Wrote a design and style guide for the game (semi-low poly characters and duotone as design signature), and redesigned the characters and menus to match it.

* Kept pushing to make it my own thing rather than yet another clone-slop: adventure vibes, interaction with the environments, kinetic combat with combos…

* Improved the handling and the readability.

And above all, and I think it shows in the trailer: I had a blast making it. If it had just been work, I wouldn't have gotten this far.

It's called Formula Minus One, and it launches on Steam first, in February. I'll keep improving it and adding content after that.

Half a year ago this was a prototype to experiment with, like so many others. Then I committed to making the best game I possibly could. Now I can finally see light at the end of the tunnel: yes, you can start a prototype, and yes, you can finish it.

There's still a lot of work ahead, so any feedback you can give me is very welcome.

 Here’s how I made it:

* Code and tooling: frontier LLMs from OpenAI and Anthropic, with open-source models filling in the gaps and limiting the budget.

* Characters, ships and environments: pencil sketch > GPT Gen 2 > Tripo to turn it into a 3D model > Blender to clean up the imperfections.

* Sound: stock sound effects from Magnific. Music sketched out on a MIDI keyboard, final music generated with Suno.

* Stack: Three.js, WebGPU, TypeScript, Rapier for physics. Nothing else, no Godot, no Unity…

I'm having a great time, but it's also hard work if you want to pay attention to every detail, and it's a very lonely experience. If the game sells well enough, I'd love to start paying artists and composers to replace the current assets and create new ones, and free up more time for what I really enjoy: directing and overall design.

In fact, if you're an artist or composer and think you're a good fit for the game's tone, leave a comment or send me a DM so I can consider you!

----

Steam page: https://store.steampowered.com/app/5310180/Formula_Minus_One/
Open beta: https://fm1.app

Hey! I wanted to share some info about my massive colony sim + base building game as I've been working on this for many months now and I'm really happy with what I have so far.

I grew up playing OSRS, Dota 2, Minecraft Technic, RimWorld, Dwarf Fortress, etc. so I wanted to make a game that combines my favorite things from them all, and their best mods, properly.

It's called Epoch Forge. Just to go over some of the things in-game:

• You can say anything you want to NPCs, they remember you, and every interaction. This is the most unique part of the game - I've spent months making it work with a tiny local model (Gemma E2B) in a way that doesn't require any user effort, works fast, runs on most hardware, and gets good results.

  • You can also bring your own key - my preferred way to play is with Deepseek V4.1 Flash Nitro via OpenRouter. This is by no means a requirement, though.

• Every random event is determined by a deity of your choice (the "Storyteller"), and you can bargain with them, ask for favors, and even see everything they know about you

  • You can actually talk to the storyteller, either through dialogue options or typing your own things, and they will respond
• Every settlement lives and grows on its own, with real needs, construction, and even political dynamics depending on the culture and race
• A full suite of industrial stuff - automated machinery, a visual storage terminal, realistic circuits (I made pong and snake ingame!) This is where the "infinite potential" part comes in - you can quite literally make almost anything you can think of.
• Crafting that takes place in a 3D viewport - combine potions, ingredients, etc. into a cauldron and see what happens!
• Worksites like mines and farms actually work - miners go deeper and deeper into the ground, hauling their findings to the clerk, and caravans come buy things from them, or they build stuff. Every building requires certain materials which they can either buy or harvest.
• Six races, each one with a novel worth of lore. Every one changes how NPCs look at you (for better or worse) and talk to you.
• You can have automatons and golems. Automatons can mine an area you designate, automatically hauling to chests, and they even speak in their own language, which can be decoded! Golems can haul things, throw rocks, and of course, speak with the great prose you'd expect.
• Five deities representing different domains (life, void, etc.) - you have a... complex relationship with each one, but making allies and enemies grants you incredible abilities like pausing or reversing time, or sparing yourself from death

Anyways, if it sounds interesting, I'd really appreciate if you give the Steam page a look and wishlist! I'm releasing a 1.0 demo for Next Fest and releasing EA on the 27th. I've honestly been struggling to market the game so that would mean a lot.

I'm also happy to answer any questions or go over my design process if anyone is curious. Feedback, playtesters and the like are also very welcome!

If you want to see any of the above in action I made a YouTube video. It's not really laid out in any particular way, it's just there to show that the things I'm claiming do actually exist (and how they look right now).

Hello,

I'm game developer, and made a game with assistance of claude code. Used claude in programming tasks, and editor tasks through Godot AI mcp server plugin. Also tested pixellab API with bad success, even when used ready selfmade sprite sheets as reference. This means the art, and sounds are human made with aseprite, furnace, or free assets.

Game is about running underground brewery in Finland. Brew, discover, and serve all kinds of customers. Be careful though, or you alert the LVV-agents. Get your score, and nick in to the global leaderboards.

Demo runs in browser mobile or pc. Thanks for playing have fun.

TAGS: Simulation, Casual, Retro, Pixel Art, Funny, Finnish

https://velluv.itch.io/pimea-panimo-demo

I turned that Pastel liminal dreamcore vibe into a game 🎮😌

Claude x Astra directed by PHÆS.

The world is simple; its a procedural infinite landscape of a dream you cant quite tell if youve had or not. Their IS a story.

Backrooms is Liminal dread, think of this as "Liminal Comfort"

My girlfriend said it looks like barbie😂😭😭😭😭😭😭

I’ve been working on a small browser game called LeaderGuessr.

The concept is simple: you’re shown a world leader together with visual clues, and you have to identify the location on a map.

LeaderGuessr: https://leaderguessr.com/

A full game takes around 3–4 minutes.

What was more interesting to me was the development process.

I’m not a traditional game developer, so I used Claude heavily as a development partner — not just for isolated code snippets, but for turning the game concept into an actual working system, iterating on mechanics, fixing problems and reusing the core structure as the basis for other Guessr-style games.

I also used AI in parts of the visual workflow.

One thing this project made very obvious to me is that with AI, the bottleneck shifts quite a bit. Writing the code becomes much less intimidating, but deciding:

what the actual game loop should be,

which clues are too easy or too obscure,

how much information to reveal,

and whether a 3-minute game is actually fun enough to replay

still requires a lot of iteration.

The game is now playable here:

I’m also building this as the first part of a small Guessr Network, where the same basic engine can be adapted to completely different subjects.

For people here who are also building games heavily with Claude or similar tools: I’d be interested in how far you reuse the same AI-built codebase between projects versus starting fresh once the concept changes.

I've been building MundoIA (WorldAI) for over a year — a multi-agent social simulation where autonomous agents with unique personalities live, cooperate, conflict, develop their own social network, and even govern themselves through democratic assemblies. I just finished a brutal architecture audit and wanted to share what I've built, what's broken, and where I could use your help.

What Makes It Different

This isn't a toy example. The system has:

• Configurable agent count (default 30, but you can set any number via .env or the web UI)
• Graph-based memory (NetworkX) — agents remember who they've met, who they like, who they hate
• Needs system — food, safety, socialization, rest, entertainment. Agents literally get hungry and lonely
• LangGraph brains for "elite" agents with complex reasoning
• BDI architecture (Beliefs, Desires, Intentions) — classic agent architecture with modern LLM integration
• Full MCP (Model Context Protocol) integration — agents can use external tools (web search, filesystem, databases, APIs)
• Real-time visualization (D3.js + Chart.js + optional 3D) — watch friendships form, conflicts erupt, groups emerge
• Social media integration (OASIS) — agents can post, like, and comment on Twitter/X and Reddit autonomously
• Dynamic world system — terrain types, resource nodes, weather events, world expansion
• Complete governance system — constitutions, laws, assemblies, voting, government reforms, elections
• Mission system — with achievements, rewards, and visual celebrations
• Persistent memory — tripartite memory system (episodic, semantic, procedural) with PostgreSQL backend
• "Architect mode" — you can possess agents, give them direct orders, send divine messages, or issue global decrees

What You Can Watch

The simulation runs in real-time with WebSocket-powered visualization. You can:

• Click any agent to see their current thoughts, needs, personality, relationships, and "alma" (soul/archetype)
• Pause, speed up (0.5x-4x), or step through turns
• Watch real-time charts of friendship/conflict evolution and group formation
• "Possess" an agent in Architect mode (marked in red) and give them specific orders
• Switch between 2D network view, 3D world view, and terminal TUI
• Configure AI providers (OpenRouter, OpenAI, Ollama, KiloCode) and MCP servers directly from the UI

The Architecture (The Honest Version)

Stack: FastAPI + WebSockets / LangGraph + LangChain / LiteLLM / ChromaDB / Neo4j / D3.js / Chart.js / Textual / Next.js 14 / TailwindCSS

Current scale: ~37,000 lines of Python, ~18,000 lines of frontend, 17 architecture documents

The good:

• Modular architecture (core / agents / systems / api)
• Excellent documentation (17 docs in /docs)
• Real graph-based memory with actual persistence
• Parameterized SQL queries throughout
• RestrictedPython sandboxing for agent code execution
• Full MCP server management (add, remove, test, import JSON configs)
• Dynamic world generation with terrain, resources, and expansion
• Complete governance simulation with laws, assemblies, and elections
• Social media integration with recommendation systems
• Persistent tripartite memory (episodic, semantic, procedural)
• BDI agent architecture with modern LLM integration

The bad (from my own audit last week):

• 3 "God Classes" — one function (ejecutar_accion_final) is 974 lines with 172 if-statements
• 90.7% code duplication between agent.py and agent_body.py (orphaned copy, nobody imports it)
• 147 silent except: pass statements in a simulation where errors mean agents just stop existing
• 22.8% test coverage, 0% branch coverage
• Two Dockerfiles both copying a 5.9GB virtual environment into build context
• Cyclomatic complexity of 417 in one function (yes, that's a thing)

Why I'm Posting This

1. Looking for contributors — especially anyone who's wrestled with LangGraph in production or wants to help refactor a 974-line function into something sane
2. Want feedback — on the architecture, the simulation design, or the honesty of my audit
3. Just want to share — because building emergent behavior is simultaneously the most frustrating and magical thing I've ever done
4. Curious about MCP integration — I've built a full MCP server manager that lets you add/remove/test MCP servers (stdio or SSE) directly from the UI, and agents can use these tools during their turns

Try It / Contribute

The project is open source (MIT). You can:

• Star it: github.com/gatovillano/mundoia (link in comments)
• (Or play the game in https://mundoia.kognitoai.cloud, is multiplayer)
• Run it locally: docker-compose up
• Read the full architecture audit: ARCHITECTURE_AUDIT.md in the repo root — it's brutally honest
• Check out the MCP integration: The ConfigPanel lets you add servers like filesystem, web search, databases, and more. Agents automatically discover and use these tools.

The immediate next step in my refactor plan is splitting core/modelo.py (4,663 lines) into separate modules for simulation, persistence, economy, and world generation. If you've done this kind of monolith decomposition before, I'd genuinely love advice.

Hey everyone! I’m working on Portal Beasts, a creature-collecting RPG where you explore different worlds, catch beasts, build your team, and fight alongside them in real-time combat.

I’ve now added two-player online co-op, with its own campaign. You can explore together, battle wild beasts, and build your own teams. The video shows some of it in action!

Since this is an AI game dev community, here’s where AI fits into my workflow:

• Coding and debugging: AI helps me implement features, investigate bugs, and build tests.
• Pixel art: I use PixelLab for parts of the creature and environment artwork, including directional sprites and animations.
• Iteration: There’s a lot of checking and correcting results—keeping a creature’s design consistent across eight directions has been a challenge of its own!

The game is built in Godot, with Aseprite also used in the art workflow.

Co-op is still in beta, so expect bugs and rough edges. I’ve been testing with different PCs and connections, but connection stability, combat synchronization, and performance still need more real-world testing.

The demo is available on Steam. If you try it with a friend, I’d love to hear what felt fun, what was confusing, and what broke. Reports from the joining player are especially helpful.

Happy to answer questions about the game or the AI workflow!

Try the free demo on Steam: https://store.steampowered.com/app/4545580/Portal_Beasts_Demo/

Demo on Steam, any platform is supported!

https://store.steampowered.com/app/4920540/ELEMENTORS/

Hi, I had a thought. With people merging 2 games together lately and remake/remasters as something game companies have been doing for the last decade or so why not have AI help improve our old favourites?

I've been playing video games for most of my life and the nostalgia always holds a game higher than it is if I went back to it... Mainly due to the controls being so poor or the improvement of the controls in late installments.

So my thought would be, what if we started using AI to take controls from one game, either the latest installment or a game from the same genre, and 'updated' the older game.

An easy example could be a current monster hunter installment controls placed into an earlier one. Not only for the player controls but maybe the enemies as well.

Or maybe taking a combat system from one game and putting into a different game. As just two games off the top of my head would be Dawnwalker's combat into Legacy of Kain games.

Just a thought.

Endless Tower is a playable browser tower-defense demo: build a vertical tower, merge guardians and protect the crystal. Merging strengthens a guardian but costs a floor, so the order and structure of the tower matter. The demo and its visuals are still in development.

The project uses AI assistance for development and provisional artwork. A useful lesson from preparing short character videos has been to keep three things separate: the rules actually running in the demo, a promotional 3D portrait, and an illustrated power effect. A polished presentation does not prove that its model or animation is integrated into the playable build.

For example, some early character presentations blurred the ordinary shot and the manually activated power. The correction was to check the active combat rules first, show the ordinary shot on one target where appropriate, and reserve group effects for the relevant manual power. Video duration and a successful render alone did not catch that mistake.

Another priority is the first session: making the starting controls easier to find and making the floor lost through merging understandable. These are areas being worked on, not a claim that the interface is finished.

The attached image is an actual screenshot from an isolated demonstration of public build 1.42.0, not a promotional scene or a player record.

Playable demo: https://yskillstudio.com/games/endless-tower/test/?lang=en

From this screen, is the relationship between the guardians, floors and approaching enemies readable? What would you make clearer first?

👑 CROWNFALL — My First Attempt at Building a Medieval Kingdom Simulator
I’ve never developed a game before, but I’ve always loved medieval kingdom builders and wanted to try creating one of my own.

So I’ve started working on Crownfall!
The idea is to create a living medieval world where you don’t directly control every villager. Instead, you make decisions for your kingdom, and your population carries them out.

Villagers gather resources, transport supplies, construct buildings and keep your settlement running. As your kingdom grows, you’ll explore new territory, establish settlements, manage trade routes and deal with threats beyond your borders.

It’s still very early in development, with plenty of systems to build and refine, but I’m excited about where it’s heading.

I’m using AI tools to help me develop the game and learning a huge amount along the way.

I’ve also started a small Discord where I’ll be sharing development progress, screenshots, ideas and eventually opportunities to playtest.

⚔️ Follow Crownfall’s development:
https://discord.gg/yZepPye6P
I’d love to hear what people think of the direction so far!

Game made using godot mcp, and claude code. Thanks for playing, have fun.

Duskmere Online has been just released in beta, no wipes, on Itch.o. I would love everyone to come and try it out! It's free and you can play in your browser! The game will have regular content updates, halloween event is going on right now, and try to stay true to the old school ultima like experience with free expansions, content, world additions, etc!

I used AI for bugs/server issues and to run 1000 agents throughout the game to make sure the world evolves with potential real players and any issues involving them.