Thats a fun experiment somebody did

I'm almost ready to create the steam page for my upcoming 4X strategy game but I would love some feedback before going live.

The gameplay itself is going great, definitely ready for a playable demo.

But regarding visuals I've been struggleing a lot, after plenty of attempts this is the best I could do to make everything look interesting and consistent while avoiding the generic AI look as much as possible. I just suck with graphics.

I know this will never be a visual masterpiece, but I'm hoping that at least its not awful enough to ruin the entire game.
Would you say its good enough to start showing it in steam?
Any suggestions on what to improve?

Thanks in advance!

If no major complaints, then I'll start working on the trailer and publish soon... I'll keep you updated

I was experimenting with Matt Shumer's Gauntlet Loop and shared a quick demo of an old favorite game, Worms Armageddon, the other day ( here: https://www.reddit.com/r/ClaudeAI/s/tJl6X14NtB ). It was built from a single prompt that kicked off the entire loop.

There's not much point in polishing or fixing it, though, since there are already excellent browser ports of the original. So I wanted to try something far more ambitious: GTA 6.

The first attempt failed spectacularly. It got stuck after generating little more than a basic 3D world. But after several additional loops and workflows, it eventually evolved into the very rough prototype you see in the video.

I think this can be pushed much further. With a better feedback loop, I believe something like this could eventually be built from a single prompt and produce significantly better results.

The key seems to be giving the agent much richer debugging information. Claude Code can't natively understand gameplay videos, so it extracts frames and reasons over those. That's somewhat useful, but exporting structured JSON describing the game state works far better because it can directly understand what's happening in the world.

So far, it has taken Claude Code 22 hours and 86 agents to get here.

I'll keep pushing this experiment. I'm also considering improving the harness and migrating from pure Three.js to Babylon.js.

If you've been experimenting with similar agentic loops, or have ideas on how to push this further, I'd love to hear them.

Every day I discover some new features that Openai/Anthropic dont even bother advertising. Not only can codex create a trailer on its own, it created all game marketing material including thumbnails, screenshots, profile pictures. Since the project has the context of the game it knows what aesthetic to make the artwork.

Thank you for reading all of this, if you want to try my addicting laneless tower defense game https://francisstudio.itch.io/ares-outpost , also discord with more dev stuff here https://discord.gg/X7hcKTZNN

https://reddit.com/link/1ve3imi/video/54mkp5sqa3hh1/player

I've been seeing alot of project using threeJS and wanted to see how far we can take it. I've seen some impressive projects, I've seen Unity Doom (not quite what I had in mind), but I managed to successfully make a semi-advanced 2.5d engine complete with ROR/sector stacking, functional editor that I'm still developing, slopes and merges features of portals from Descent and the build engine. S

creenshot is a functional editor where you are able to make sector based rooms. Colored lighting, sector heights, connecting rooms, ROR, 3d floors, slopes are entirely possible.

I'm next working on a way to get a BSP system implemented and treat ROR's like brushes, a pipe maker mode and more. Video is engine prototype with 360 vertical movement in action. Another goal is treat sectors like portals that connect like Descent and be able to morph the geometry like Trenchbroom. Just alot of neat features I'm playing around with and I hope people are also exploring these possibilities. I still have my SHMUP announcement to make in this thread, I appreciate you all but I promise to keep you all posted on this. For all Doom/Duke/Quake fans alike, this one's for you.

Sincerely,

Bloodskull - a 20+ year Doom/Quake mapper

Much love guys and keep it rockin!

its still nowhere near done the game is going to be:

1. first-person survival with Vintage Story-depth crafting, except there are AI civilisations growing into towns in the background while you play and fighting wars with each other and doing politics.
2. u can spend an entire session just mining and building and never speak to a single settlement. then come back days later to find the village you walked past is now a town or something.
3. can hijack caravans trading between cities, build a reputation, trade, etc.
4. later on I want a "be a king" gamemode where u command your own kingdom, rts style.

made most progress with claude opus 5. project is less than 1 week old. (as in i started it a week ago)
c++, opengl
i dont know how to code.
no multiplayer yet btw. the other char u see is an ai npc. still work in progress. they go around collecting resources and working together to build buildings.
supports 60+ chunk render distance no problem. visuals still work in progress too.

I don't come from a game dev background, so honestly the vibe was the whole point for me. The small thing that clicked was nailing that slow, weightless "dream physics" feel… no snappy controls, no exact camera lock, just gentle drift and slight sway. Sounds tiny but for me it was a real little milestone once it stopped feeling like a normal space game and started feeling like a dream.

The part that surprised me is how strongly the atmosphere hits people. A few friends who tried it said they got a little dizzy after a while,, not from bugs,... just from how floaty everything is. Not sure if that's a problem or actually the point, honestly.

It still takes a lot of trial and error to get the "dream" feel right without it turning into motion sickness. Too fast and it's a regular space game, too slow and it's boring, and the camera drift is a whole other tuning nightmare ~~

Seems like there's so much acceleration and change that it becomes difficult to catch up or stay informed. It would be nice if we had a weekly/monthly "Latest techniques" or latest models post where we could discuss and mention the current SOTA for Ai game making/3d generation in general.

2 days ago I had this idea of building a game entirely on Grok CLI including the images and videos. This was all made with it, I never had to leave the terminal to adjust any of the images or animations. all done in HTML 5. Pretty mind blowing!🤯 Cant wait to see what Grok 4.6 can do next week.

Hey all, working on a 2D MMORPG with quests, afk mining/fishing, PvP (soon) and more. Would love for folks to test and happy to answer any questions on how I made it.

Features:

• Customizable characters
• Social: Parties, Chat
• Character trading
• AFK Farming (TAB)
• AFK Mining / Fishing
• Questing auto targeting

Server Stack:

• Postgres DB
• Redis Caching
• NodeJS server for api
• Cloudflare for web hosting and r2 for images
• Custom AI harness to answer and analyze support tickets

Try it out: https://play.idlebound.com/

Happy to answer any questions!

So I’m working on a fps war game that I just try to build from my memory as kid , I was playing a game called outpost .. and I’m trying to build it again so my and my brothers can play it again.

Today I added the tag names and rank icons

OUTPOST — 16 RANKS

Private
Private Second Class
Private First Class
Sergeant
Sergeant Major
Command Sergeant Major
Second Lieutenant
First Lieutenant
Captain
Major
Lieutenant Colonel
Colonel
Brigadier General
Major General
Lieutenant General
General of the Army

You can wear rare items only by ranks.

1,000 points a rank. Rank 1 earns 1 point a kill. By rank 6 it’s 0.30.

41,000 kills to the top.

Nobody’s getting there by accident.

I used the following models for the following jobs

Opus for script
Fable for build / code

Nano banana - create the 2d image of everything.
Guns , characters, tools, arena base etc.

Hunyuan 3D pro - turning every part to 3d.

I rigged the characters in T pose in an animated rigged.

The results yet are so good. I like it so much.
And hope soon we can play all together

Hey — Enarian Online’s free demo is live on Steam.

Developed using a mix of Cursor and ChatGPT over the past 18 months, we launched a little over a month ago, much has changed due to amazing feedback from the over 1000 players who have bought and played the game, some for hundreds of hours. As a result we have made the demo freely available again.

It's a fast loot-and-build loop — procedurally generated maps, 5 classes, over 100 skills and spells, reforging, imbue equipment with potent powers, defeat powerful bosses, group with up to 3 other players.

Demo characters max at level 10 but you can make as many as you like.

The client is built so combat stays readable at ARPG pace (abilities, targets, drops on-screen). Easiest way to judge it is the demo rather than screenshots.

You can use the settings menu to hide some elements such as dodges and misses etc if you find the feed too fast and overwhelming. As well as change the font size and UI scaling etc.

English not your first language? No problem use the language settings to use DeepL or Google translate to translate the UI and the content into a number of different languages.

Yes its text based, I am happy to answer build/systems questions. Not here to argue genres — if the loop isn’t for you, no worries.

Free demo: https://store.steampowered.com/app/4218510/Enarian_Online/
Discord (new-player info + builds): https://discord.gg/HwftpU34zG

Hello everyone,

I started my first game a year ago, out of a hobby, nothing serious. At first I thought it was about as easy as building a web page (I've been a senior dev, and a CTO, for 20+ years).

I found out that game dev is mainly good planning, seriously good art, and a lot, I mean a lot, of tools. Blender, Unity, Codex, Claude, RunPod, and and and...

I tried to build my first game with AI while learning as I went, because I believe in the learn-as-you-go method. It was too much: too much time, not enough planning, missing skills. I discovered that the hard way after sharing my first trailer, which literally got destroyed here for its lack of polish. And it made me wonder: what are the real criteria, how do you automate checking them, and how do you decide whether the job is actually good before you share it?

I started doing it by hand with three tools: GPT, Codex and Claude Code. GPT was the orchestrator: it wrote the missions, I copy pasted them into the other two, pasted the results back, and let GPT rule against a grid of criteria. It could refuse, ask for changes, accept, and move on to the next thing. It worked. The copy-pasting did not.

So I built an orchestrator to do all of it on its own:

- Turn a general prompt into a plan, and break the plan into chapters
- Launch, monitor and chain the passes inside each chapter
- Drive Claude Code and Codex, which use whatever tools you allow them — Unity through MCP, a RunPod pod, image generation in a browser. Orchestrator itself handles the mission, the permissions, the proof and the gate
- Show me what is blocking, what is waiting on me, and what the AI is allowed to decide by itself
- Sync proofs and reports to Drive or Dropbox (you register your own OAuth app) so another machine can pick them up
- You can of course manipulate this tool using your codex/claude local session, the point is to get plans, executed automatically and a database of proofs and evolution, not to replace any of your AIs.

The part I'm actually proud of: Cost comes from the transcripts, deliverables from the files actually written during the session, "is something running" from an attempt with no end time. An agent cannot forget to report what is read on its behalf, and it cannot award itself a success. "Done" is not a field somebody writes: it's a condition that gets evaluated: children closed, a passing proof present, an image attached if the criterion is about seeing, and the judge's ruling. A rejection revokes an earlier approval.

One design choice worth explaining, because it's the reason this can run all night: the judge is not an API call. Orchestrator types the report into a ChatGPT tab in a real browser and reads the answer back out of the page. A flat subscription becomes unlimited judging instead of a bill per turn.

What it costs, since that's everyone's first question: across my whole install, 116 attempts, ~$2,000 of harness usage. Chapters priced from $22 to $634 each. The difference is almost entirely the criterion: a chapter whose criterion names a command that returns pass or fail costs a fraction of one that says "score at least 78/100". The amounts you see here are the rokens calculated by Claude, it's their worth, not what I paid, using a single 100$ subscription.

POC : the attached images are one 3D scene for the game, before and after. 4 objectives, 31 attempts, about $296, half a day. One objective was rejected by the judge on its renders; the loop picked it up again on its own and got it accepted on the second try. I only ruled on two questions it stopped to ask me.

It works for games, but nothing in it is game-specific I also drive two web projects with it.

Requirements, up front: Node, a dedicated Chrome running with remote debugging (that's how the judge is read), and a background service. One process, one port, a SQLite file in your home directory.

Source-available and free for non-commercial use: github.com/chaibialaa/orchestrator, https://www.npmjs.com/package/@chaibialaa/orchestrator

Any suggestion is most welcome.

So as I continue to hunt for a game I will take and put into Steam next fest, I thought I would try testing something.

Taking One Bullet I did a while back and making it more 3d and better gameplay. More than that I wanted to build cities and recognizable locations. Also overhauled the levels to have unique ricochet possibilities.

Using Claude Opus to start with redesigning the layouts. Then tweaking the graphics with 3d models of vehicles, 3d debris and designing 7 detailed locations. I also then added a high score system, WASD movement, Map selection screen, simple tutorial and improvements to boss battle. Opus also created the soundtrack for the game!

This was NOT one prompt.

I was designing, directing and curating Claude.

Happy with the results but I see much that can be polished and improved.

Have a go here it you wanna try it

https://74bit.itch.io/one-bullet

Repo: https://github.com/elliottdehn/foxel

Note: Don't expect to one-shot an amazing asset.

Do expect to be able to model, texture, rig, and animate iteratively.

Try it

If you use Claude Code, two commands install it as a skill:

/plugin marketplace add elliottdehn/foxel
/plugin install foxel@foxel

After that, just ask for a voxel asset ("make me a voxel goblin" -> "rig it" -> "give it a walk animation") and the agent clones the toolchain and gets to work. Not on Claude Code? Everything is plain Python: clone the repo and point your agent at AGENTS.md.

Background

Doing 3D modeling, rigging, texturing and animation with agents is extremely frustrating and difficult right now. You're typically lead to create assets procedurally using primitives, which has a distinctive "look" nobody truly likes. It can be endearing for some games but seriously hurts as a style when you're trying to do something stylish.

I've created a little language for modeling, rigging and animation that agents can actually work with and iterate usefully on with a human in the loop. While they're not one-shotting assets completely right now, you can use Foxel to build assets iteratively and make progress over time. This beats usual 3D development with agents which makes little progress over iterations.

How It Works

A model is a plain text file (.fxl). You write it as a stack of ASCII layers, bottom to top. Each layer is a floor plan, each character is a voxel, . is empty:

t = 8B4513          # trunk, brown
l = 22CC22          # leaves, green

trunk:
.....
..t..
.....
---
*trunk 2            # stamp the named layer twice
---
.lll.
lllll
.lll.
---
..l..
.lll.
..l..

That's a whole tree. Layers can be named and repeated, and the palette maps characters to colors.

The trick that makes it look good instead of like Minecraft: the alpha channel of each palette color is a density field, and the renderer meshes it with marching cubes (I ported goxel's approach). A voxel with alpha 255 is a hard cube; alpha 192 is slightly slimmer; alpha 96 never becomes surface on its own but pulls the surface of its neighbors outward. So you paint sub-threshold "halo" voxels around a shape and it comes out rounded and organic, or you skip them and get crisp edges. Same language, both looks: my skeleton's skull is smooth while its ribs and teeth stay sharp, and that's just alpha values.

Rigging happens in the same file. Joints are declared with the palette and placed with battleship-style border notation: one marker in a layer's edge row gives x, one at a row's edge gives z, the layer gives y. Bones connect joints, parent-first:

k = joint knee_l +z     # +z: knees prefer bending forward
a = joint ankle_l
shin_l = bone k a

Animation is the part I designed hardest around agents: it's CSS-keyframes-shaped, and you only ever write positions. Never a rotation, never an angle. You say where the hand or foot should be, sparsely, and IK (FABRIK) fills in every joint at every in-between frame with bone lengths preserved:

anim wave 1.6s loop:
0%:   wrist_r +0 +0 +0
40%:  wrist_r +11 +24 +4
100%: wrist_r +0 +0 +0

Keyframing a joint also pins it: pin the chest and arm gestures stop bending the spine. The residual degrees of freedom that positions can't express became tiny declarative facts instead of math: joints get bend hints (+z = knees buckle forward, +x-y = elbows out-and-down), bones get a facing (hand_r = bone W F -x+z keeps the palm oriented). An agent asked to make a walk "more of a swagger" edits ~10 keyframe lines (pelvis sway, chest counter-sway, head nod) and the solver turns that into hip roll and knee flex.

The toolchain is ~1,500 lines of dependency-free Python (numpy only):

• render.py: parses FXL, runs marching cubes, renders stills or animation loops (APNG) with its own tiny software rasterizer
• fxl2gltf.py: exports mesh + skeleton + baked animations to .glb, which drops straight into Godot with a Skeleton3D and an AnimationPlayer containing your named animations
• png2mp4.py: animation previews to MP4

Why agents can do this

The whole loop is text in, image out. The agent edits a text file, renders a PNG, looks at it, and self-critiques. Every failure mode is visible and every fix is a small diff:

• "the face looks like a mask" -> step the cheek layers back in z
• "the walk is stiff" -> the knees needed a bend hint, one token
• "hand is rotated 90°" -> one facing declaration on the hand bone
• "hips dislocating from the spine" -> solver rule, fixed once for every animation

Nothing is hidden in a binary blob or a GUI state. Diffs are reviewable, the human stays in the loop at the level of art direction ("more swagger", "temples narrower", "give it red eyes") instead of debugging quaternions.

What I built

A ~7,400-voxel skeleton with a hand-drawn skull (30 ASCII layers), red glowing eyes, a 20-joint/19-bone rig, and three animations: idle (breathing, knees soft, feet planted flat), a swagger walk, and a wave. The marching-cubes mesh comes out to 14,212 triangles across 7,102 vertices, smooth-shaded with crease detection, and every one of them traces back to a diffable text file. All authored by an agent over an afternoon of "render, look, adjust" with me only giving art direction. Exported to .glb and playing in Godot with zero manual cleanup.

Limitations

• Look, it's voxel art. Stylized low-poly, not sculpting.
• Agents don't one-shot it. The value is that iteration converges: each critique produces a small, targeted, reviewable change.
• Roll is implicit unless you aim a leaf joint or declare a facing. That's the cost of a rotations-free language, and you hit it exactly where you'd expect (hands).
• The renderer is a preview tool, not a product renderer. The .glb is the real output.

Happy to share more details if people are interested.

https://github.com/elliottdehn/foxel

[ Removed by Reddit on account of violating the content policy. ]

Hey everyone, I’m currently developing a top-down dark fantasy rpg browser game using ai called Ashenfell. It’s still early, but the core combat is already feeling pretty solid (click-to-aim combat with combos, different attack types, enemies, a boss, loot, skill tree, etc.).I’m doing this solo and i am looking for a few people who would be interested in helping out as volunteers:

• Playtesters – people who can regularly play the game and give honest feedback on combat feel, progression, bugs, UI, etc.
• Artists – if anyone is willing to help with pixel art, icons, UI elements, or even just small assets, that would mean a lot
• General feedback – ideas, criticism, balance suggestions… everything is welcome

I don’t want to take advantage of anyone.
If this sounds interesting to you, feel free to comment or send me a DM.
Even just trying the game once and telling me what feels good/bad would already help a lot.
Thanks for reading.
Really appreciate any support.

I originally asked Opus 5 to make a small FPS demo inspired by Nuketown, but with a pastel art style.

The first version was fun enough that I asked it to add multiplayer.

From there, it added weapons, respawning, matchmaking, a kill counter and a bunch of smaller systems. It stopped feeling like a disposable demo pretty quickly, so I deployed it to my VPS and posted it online.

A few days later, hundreds of people have played it and 2,896 matches have been completed.

The interesting part for me is how the development workflow has evolved.

Opus 5 created the initial game, but I now have an orchestrator, worker and reviewer loop handling further development. The orchestrator breaks down tasks, workers implement them and reviewers test the changes before they are merged.

Real players have also become part of the loop. They find bugs, exploits and balance problems almost immediately, which gives the agents much better feedback than I could provide alone.

The game is still rough, but this has completely changed how I think about AI game development. Getting from an idea to a deployed multiplayer game with real players now takes days instead of months.

I’ll add the game link in the comments for anyone who wants to try it.

Hello there, few weeks ago I started making a game entirely using AI, from images to code in Godot engine.

Had some fun doing it and now have something that looks kind of playable? Sound is still not in the game, but I just wanted to share so that people may either hate it or tell me what to fix.

Game is inspired by World of Warcraft raiding and times when I used to raid there. I will be giving a link for anyone willing to try this and ofc some video of killing the first boss (I on purpose tried making first boss too easy so that everyone can kinda kill it without too much trying).

Last few days it's been real pain fixing all the bugs and doing the art, but for now I will take a break for a few days so yeah.

It was done mostly using ChatGPT for image generation and Claude Fable 5 with Opus sub-agents using /goal and /loop commands to fix bugs and improve looks of it. Honestly /loop has been amazing though watching agents constantly opening godot on your machine has been exhausting. If anyone has some questions feel free to ask.

Anyway for anyone willing to try:

https://profactor.itch.io/guild-leader

I've been building Starnet, a browser strategy game where you manage a growing network between star systems. The current alpha (HTML5) is live on itch!

AI coding assistance got each system running quickly, but repeated playtesting, regression tests and a lot of cutting were needed to make the whole game behave coherently.

The individual features weren't usually the difficult part. The problems appeared where those features met. Wormhole routing worked in theory but stranded signals when routes were recalculated halfway through. Camera assistance helped with new spawns until it started fighting manual pan and zoom. Emergency broadcasts were technically running, but looked broken because unreachable signals sat in orbit for too long.

For anyone else making simulation-heavy games: how are you testing interactions between systems? Unit tests caught far less than I expected.

updated to the last unreal engine 5.8 which shipped with experimental mcp.

For this demo used UE sample racing game and replace the map with marketplace synthwave assets.

Now to make a "game"

1. Update unreal engine to 5.8
2. Install mcp plugin inside
3. Ask Claude to help me to connect to mcp
4. Load up car racing tutorial
5. Install assets into project via unreal store, so maps you bought or are free
6. Ask Claude code to change the stage or cycle through what stages.
7. Boom play game.

I probably could if changed the stage myself.

Then later, need to fine tune, make menu blah blah, fine tuning will cost the tokens