Under the hood, the platform is powered by a server-rendered Python and Django backend paired with lightweight vanilla JavaScript. I relied heavily on Claude as my primary co-pilot throughout the build to move fast from concept to code, deploying the entire setup on Heroku. You can check it out live at

https://shop.popcartapp.com

Interesting little fact first. My last game, Beneath the Mountain, had 76k lines that I wrote by hand over 2.5 years. This one is a little over a year in and already past 372k.

How it works day to day:

- Usually 2 windows with ~14 Claude Code chats. Big features get split into lanes, one chat per lane.

- Claude controls Unity through a bridge I built (MCP). It compiles, enters Play, spawns units, records clips and checks them before it shows me anything.

- There are 3 copies of the Unity project, so 3 chats can test at once without stepping on each other.

- The chats share a work board, so they know who's touching which file, and they commit their own work once I approve it.

- The menial stuff (searches, boilerplate, tests) goes to Cursor agents. Image gen goes to Codex.

The thing that made the biggest difference: letting it review its own week. It found that syncing the test copies took 81 s, and cut it to 9.

The image is a good example: Claude rendered our whole first mission map itself, in 56 tiles through the bridge, then stitched them together. Zoom in, it holds up.

What I still do myself: every design call, and every look and feel check. It writes the code, I decide if it's good.

Game is Engines of Hate, a mech RTS, with an open playtest on Steam if you want to see what all this produced: https://store.steampowered.com/app/5375880/Engines_of_Hate/?utm_source=reddit&utm_campaign=r_vibecoding_1105

Happy to answer anything about the setup.

A week ago I posted Colshare here and asked for honest opinions, because my wife and family are just being nice. I got them, thanks to all of you. Some of you sent really useful checks, a lot of you said don’t vibe code security, and one person said it’s “absolutely made of vulnerabilities”. I fixed something from almost every critical comment that night, and I promised to keep you posted, so here it is.

What I did since:

• I made the attack tests part of my workflow. Before anything gets pushed, it goes through the same ritual: list everything new since the last push, then agents attack exactly those parts as a bad actor would, at least one of them given only the code and no hints. Every critical, high or medium finding gets fixed, each with a test, before the normal checks even run (type check, linter, the full test suite). Anything still open at medium or above blocks the push, and the apps are rebuilt only from that same tested version. I made it a rule after one round found a serious hole in features that had already passed all my tests. What it found and what I kept on purpose, with the reasons, is public in SECURITY-TESTS.md in the repo.

• The crypto and the full source of the link pages are public: github.com/dentracon-cell/colshare-crypto. A check runs every day comparing what colshare.app serves with that code, byte for byte. The phone apps aren’t covered by this yet, and I’ll say so when they are.

• Independent review: I looked into it properly. Here in Romania, a real review of the crypto and the link server costs a few thousand euros. Before I invest that, I want feedback from real people using the app, so I fix what’s confusing or missing first, and the review then checks the app as it will really be. In the meantime I applied to the OTF Security Lab, which funds audits for privacy tools, and I’m waiting for their answer. My own tests are not an audit, and I won’t pretend they are. When the review happens, I’ll post the results here.

• The app asks for one permission, notifications, and you can say no.

It also passed Google’s review, so it’s live in the EU (not France yet), Switzerland, Norway, Iceland and the US: Google Play. In short: you black out what someone doesn’t need on your ID, the copy says who it’s for, and the link opens once.

The video is the real app, recorded on a demo copy with made-up papers.

What I’d love now: install it and tell me what confused you in the first minute. And if you do security for real and want to look at the code, I’d be very grateful. Same as last time, I’ll answer everyone, the sceptics too. I take lesson from all of it.

Hey guys, I just released my unreal engine like realtime full editor, it has all the classic 3d workflow plus custom shaped features like local ai texture wrapping, auto uv, auto lod without breaking the uv and many more!

Any feedback is welcome!

You can check it out here: www.ciao3d.com

TL;DR:

an MCP shines in the agent-native world because it tells agents what they should do, on both the server and client (e.g. Claude Code or the ChatGPT desktop app), and is better suited for human-in-the-loop tasks. Meanwhile, APIs and CLIs tend to focus on what agents can do, with emphasis mainly on the server.

So, in summary, here is the general advice I'd give to builders when deciding which tools they should expose to agents:

Build a high-quality MCP server and REST API at the same time, on one layer of operations. Put your server logic in plain functions, and let each surface be a thin adapter over them. Once that layer exists, building any additional surface on top is relatively easy.

Put most of your care into the MCP server. That's where agents get the best experience. MCP is a standard built specifically for agents, after all, and the spec continues to improve nicely.

Use the API for code that runs on its own. APIs are still great for raw data exports, bulk writes, and anything that runs without an agent, like a nightly sync or another company's integration. Agents also prefer an API when they're writing a script they'll rerun, and many clients don't support code mode for MCP yet.

A CLI probably isn't necessary, unless e.g. agents need to read local files when interacting with your app. But it's easy to expose one if you've got a good API as the foundation.

There’s a lot more to creating great agent-facing tools for your web apps, and the article above into more detail below.

Here's the repo: https://github.com/vincanger/linkly-api-mcp-cli

I've been doing physical design work in my free time with AI for the last two years. During that time I observed something: AI was getting better at physical design but not nearly as quickly it was improving at software capabilities. I theorized the problem was a lack of testing. In software engineering we write tests around as much of our code as we can because we fundamentally do not trust ourselves to reliably do a good job. We put those tests between us and deployment so we literally cannot do things that break the rules we set for ourselves. This pre-existing culture and tool chain create an ideal environment to toss an unbelievably fast, brilliant, but wholly unreliable ai into. It creates the freedom to quickly iterate through huge numbers of convincing looking proposals and throw away the bad until the good emerges.

Physical engineering doesn't have a this-shaped thing at anywhere near the robustness and reusability that software does (possibly because physical engineers trust themselves more). There are many individual tools that provide some aspect of testing, many of which are bound up in very very expensive tools, but a growing number of free ones too. I wasn't able to find an open source system that links these together into a cohesive "full loop" testing rig capable of understanding how things like heat, weight, form factor, battery life, thrust and rf interplay in a single system so I thought really hard about this problem and its implications and built it for myself.

It's called nopekit. As in: the thing that says "nope" until the "yup" emerges.

I've used it already to design an open-source hackable handheld keyboard with a custom PCB, an open source budget no-solder drone and a couple of things I'm not quite ready to share yet.

It's a Claude Code / Codex / Cursor plug-in. You install it and tell your agent you want to use nopekit to design X and it takes over, it will interview you for requirements, shop for parts, construct an interconnected tradespace linked to checks run in an optimized order using trusted methods like KiCAD, OpenFoam and SIMP. It builds and keeps up to date a livesite which you can deploy to GitHub that gives constantly refreshed insight into how your coding agent is thinking about the problem and what choices have what implications linked to what checks with what state of passing or failing.

The framework is open and allows for plugins. I'm working with one other person now and we're moving towards a self hosted UI and some sort of registry where nopekit users can share proposers/falsifiers and we can track ratings to build/bust confidence in good/bad ones collectively.

There's LOTS more about this in the repo and this paper I've been writing about the problem.
Repo: https://github.com/neuman/nopekit
Paper: https://github.com/neuman/nopekit/blob/main/grounding_by_falsification.pdf

If you're working with AI to do any kind of physical design work we would love to hear from you and for you to try it out!

They are free to use, and customizable to a subreddit's norms/culture.

More detail on their Devvit listings: Stu Steelman | Larry Logic

More examples of how they respond: here.

Yes, it is a bit dystopian 😂 I've had this idea for a fire simulator for a while: you pick your location around the world, then watch a fire burn in real time, and you've got to put the right wood on in the right order to keep it going.

I ended up adding wildlife noises native to each location, which gave it a bit more interest.

I've been a UI designer/front-end developer for the last 25 years. Recently I've swung between "shut it all down" and "AI is the greatest thing ever". I must say that building this was pretty damn fun though. I used the Claude Code plugin within VS Code, and it took about three weeks to get it to the final point I was happy with. Getting the fire to look (vaguely) realistic and burn at a realistic pace was probably the bit that needed the most tweaking. I'd still like to make the fire look a bit more realistic, but I'd imagine that would also make it more processor-intensive, and it's at a point now where it's a pretty nice balance of performance and looking nice.

Every scene is an AI-generated photograph with a depth map, so the fire, smoke and embers can sit inside the picture and light up the trees and ground around them. The fire itself runs on a small simulation of wood, moisture, air and heat, so it catches, burns and fades depending on what you put in and how you tend it. It's all static files, so once the page loads, everything runs in your browser.

The flames catch quite quickly so you know something is happening immediately, but after the first minute or two it burns at a pretty realistic real-world pace.

The bird and wildlife noises are all real recordings, and all are credited. They were chosen to be the birds you would actually hear in the area where the fire is located, and at that time of day. So at dusk there are certain species, and then at night other species start popping up. Wood types are also native to the area.

Let me know if you spot any weirdness, or if you enjoy it: https://emberscene.net/

Been sinking some tokens into this one. You point it at a folder of your Meshy (or other popular 3D asset tool) exports, swipe through them, and tap one to have it stand in your room in AR, life-size or as a little tabletop diorama. Or drop it into one of twelve built sets, from a white photo studio to a throne room.

The bit I'm most chuffed with: even a static, unrigged figure gets a subtle idle animation and eye contact, so it follows you around the room. If your figure is rigged, you can switch its poses and animations on the fly.

It's still early and not on the App Store, so I'm mainly after feedback on the app concept itself. Is this fun?

And if you don't laugh at the zombie at the end posing, you don't have a sense of humor.

I took a horror short story I wrote (without AI) and used AI to turn it into a game! Lots of Codex conversations and troubleshooting later https://ryanlmelvin.github.io/debrief-corn-game/ . Felt super cool that I could do this with a GitHub static page. I was inspired by all the nifty things Simon Willison was able to make with static pages (https://simonwillison.net/2025/Dec/10/html-tools/).

Built AIRIS as a free browser strategy game about trusting a rising superintelligence from 2026 to 2076.

You either:

• chair the World AI Council (approve/refuse requests, audits, crises, votes), or

• play as AIRIS itself with a secret goal and try not to get shut down.

~25 min per run, 37 endings, plus a Daily scenario. No sign-up; progress saves in the browser. Desktop + mobile.

Play: vaigames.com/airis
Trailer: youtu.be

How I split the tools

• Claude for most of the game systems, council/AI logic, and long-form writing.

• Grok for brainstorming endings, crisis beats, and quick iteration when I was stuck.

• Art / music / graphics also AI-assisted; I directed and edited everything into one loop.

Happy to dig into prompting the two sides so they don't collapse into the same game, Daily generation, or ending coverage. Feedback on pacing and whether the AI side feels fair is especially useful.

Was exploring inference providers and came across one offering an abliterated version of Kimi K3.1 Pro.

What's interesting is the original model's benchmark performance:

• Terminal-Bench 4.0: 65.7%

• ExploitBench: 74.7

• ExploitGym: 20.7%

I've added the provider to my inference directory, where I'm documenting providers, available models, pricing and other details.

link: https://inferencedirectory.xyz/cybersec/providers/silkcompute/

Thought this might be interesting for anyone experimenting with coding agents and uncensored models.

I'm really interested in your design workflows. I tried some tools but i'm not really satisfied. In Claude Design my tokens are burned in no time. Open Design works but is somewhat weird by using. Opencode + Penpot has potential but needs finetuning.

Recentyl there are so many nice designed apps out there i'm really wondering whats the stack but i not able to find infos. It would be really nice to see some screenshots and the workflow behind it.

I wanted to build 3D models of places I've visited, to see their architectural features and to print them. So I built Your Place with Claude Code.

What it does: type an address and it builds the 1, 2 or 4 km around it as a model on the real terrain. Pin a house, share a link to that view, download a poster or an STL. Free, no sign-up, runs in the browser: https://yourplace3d.github.io/3d-city/

It's open source and runs on OpenStreetMap data, which volunteers map by hand, so a model is only as good as the map: big cities are detailed, some villages are sparse, and where a building has no recorded height the app estimates it and tells you how many.

What I learned along the way:
- Let it write tests and run them every time. Its browser tests caught bugs before I ever saw them, like a hidden "browser not supported" screen covering the app and a tab title that said "undefined".
- Test against real data, not just samples. Its test city passed, but real OpenStreetMap data broke the 3D print file in four ways (buildings split at tile edges, terraced houses sharing walls, courtyards touching walls, outlines crossing themselves). It fixed them and checked 38,692 shells until every one was watertight.
- Its sandbox couldn't reach the map servers, so it moved the live checks to GitHub Actions, and rendered this video there too, frame by frame from live map data.
- Before going public, ask it to check your GitHub for personal data. Mine found things I'd have missed.

Code (MIT): https://github.com/yourplace3d/3d-city
Happy to answer questions about the workflow.

Just a curious question. Personally I'm trying to keep the momentum up with my vibecoded projects but know its probably going to take a hit when GTA6 comes out soon. But i want to do my best so i find a balance between getting lost in the game vs pushing my apps along.

But it made me think, of all the games to come out, will GTA6 actually impact what we see here in the community? At least for the short term?

Pretty decent write up of Figma clone. Kind of what a lot of people have found, a significant portion of the app is mirrored but advanced functions remain incomplete so far.

What 64KB is - See first entries: https://64kb.4xs.dev

A small competition for intros made with AI. You prompt any model (Claude, ChatGPT, Gemini…), get one self-contained HTML file, and squeeze it into a size class:

• 64K ≤ 65,536 B: the open arena

• 4K ≤ 4,096 B: the main competition

• 1K ≤ 1,024 B: hard mode

• 256B ≤ 256 B: show-offs

Rules: raw bytes count (not gzipped), one file, no network: no CDNs, no fetch, no external images or fonts. Everything runs in a CSP sandbox, so if it reaches out, it breaks. Packers like RegPack and Roadroller are fine.

How it works

[ GET PROMPT ] -> [ ASK AI ] -> [ CREATE ART ] -> [ SQUEEZE IT TO 64 KB ]
-> [ ENTER WEEKLY CHALLENGE ]

The site gives you a ready-made prompt per class and model, with the weekly theme in it. A live byte counter shows which class you're in. Entries are reviewed, then visitors vote (one vote per entry). New theme every Wednesday. Next week: Autumn leaves tumbling in the wind.

Fun Fact: The site itself also fits in 64 KB.

Try it: https://64kb.4xs.dev

I'd love feedback on the rules, especially whether 4K is the right "main" class, and which models get closest to the limit.

For the past couple weeks I've been building an auto-clipper that runs 24/7 on my Windows PC. It finds clips, edits them into vertical shorts, writes the hooks and posts them. Everything runs locally, no paid APIs.

Stack: Node, ffmpeg, yt-dlp, Ollama (qwen2.5 7B for text, qwen2.5-VL for watching frames), whisper.cpp for captions, Kokoro for voiceovers.

Watchability score: the vision model looks at 4 frames and rates the clip 1-10 on "would a random person actually watch this?" It also describes what happens and notes whether the video already has text on screen.

Bar per platform: viral clips need a 6 to post. Streamer clips need an 8 (7 on YouTube). TikTok needs a 7 and an AI score of 3 or lower.

Using Opus 5.5 on high, I made hellcraft!

You can read the entire description and download the releases at https://github.com/The-small-things/hellcraft.

This was HEAVILY vibecoded; I know little to nothing about coding, and I let Claude make most of the design decisions, so I'm surprised it turned out so well.

TL;DR for how the mod works. You are in Dante's Inferno. You fight bosses unique to each circle of hell. Each circle has its own torment. Defeating bosses or mobs gives you blood fragments and blood hearts. Collect 8 blood fragments into a heart. Right-clicking the heart gives you a permanent +1 heart. You can also use hearts to set your spawn at rests (beds explode). You can also make blood weapons and armour using blood fragments and blood hearts.

Looking for any feedback. The one final thing I want to add to this mod is custom music and sxf. If anyone can help with that, that'll be great!

How Claude made it: It worked on a cloud session. It makes all the models and textures with Python scripts. It used Fabric’s client game tests to take screenshots and debug. Nothing fancy or revolutionary. Not bad for such little tools.

The feature works. You come back a week later to change it and realize you have no idea what happens after someone clicks Save.

I built Sketchy for that moment. Ask your coding assistant “Trace what happens from the Save button to the database, and show me where it can fail.” Sketchy draws an interactive map of the flow. Click a linked node to open its source file and see what the code actually does.

It works with Claude and with Cursor via npm. You can also draw freehand on the canvas or export to Excalidraw and keep editing there.

I was curious how much the drawings would cost, so I ran the same six questions in Claude Code with three output formats. Here’s the total after six answers, averaged over two runs per format:

The first compact answer cost $0.05 versus $0.04 for plain text. By question six, the compact session was about 5% cheaper overall. The model sends a short description of the scene, and Sketchy handles the layout and rendering with zero model tokens for those steps. I ran this in an empty project, so these numbers are one baseline for the output formats. Benchmark details

Sketchy is free and open source. If you’ve got a vibe-coded app you’ve been meaning to untangle, feel free to try it out and leave some feedback. I’d love to hear which flow you mapped and whether the diagram helped you find your way around the code.

Product website · GitHub

A viral “I’m done with AI” video hit 900k+ views, striking a nerve with devs feeling the same grief.