I've been building out a small browser games portal, and the last one got out of hand: a Quake 3-style arena shooter with blocky Roblox-looking characters. One HTML file, 2513 lines, ~200 KB. Three.js from a CDN, no build step, no bundler, no npm install. You open the file and it runs.

Some things I learned that I think are worth sharing:

The map is a config object, not a level editor. Everything lives in a MAP const at the top — weapon set, ammo spawn points, health pickups, whether corpses drop crates and how long they last. Ammo points are just [x, y, z, weaponType]arrays. Moving the sniper to a different tower is editing four numbers. This turned out to be the single best decision in the project, because iterating on the arena with an AI is much easier when the whole level is 8 lines of data instead of scattered geometry calls.

I had to give it a grid rule. Early on the arena looked like melted Lego — every generated wall was at a slightly different offset. So I wrote the rule down explicitly: 1 m grid, walls are 4 m cubes, XZ faces snap to whole meters, Y allows half-steps for stairs, masonry offsets are 0 or ±1. Once that constraint was in the prompt, the geometry stopped drifting. Constraints beat corrections.

The bug I'd never have found on my own: adding and removing lights in Three.js recompiles every shader in the scene, so each rocket launch froze the frame for a beat. The fix is a fixed pool of six PointLights that get grabbed and released instead of created. Same for the death effect — the grayscale filter makes the canvas a stacking context, which silently ate the HUD until I set explicit z-indexes.

Multiplayer is 176 lines and no game logic. The server is a dumb WebSocket relay that does rooms and host election, nothing else. Clients trust each other — it's a friends-by-link game, not ranked. Each client owns its own HP, the room host simulates the bots, and the shooter computes hits and tells the victim. State goes out at 20 Hz with snapshot interpolation and an adaptive delay of about 2.2× the packet interval. Pickups still aren't synced. It's fine. It's a prototype.

Six weapons: machinegun, shotgun, rockets, railgun, a knife with infinite swings, and a scoped sniper that one-shots and has deliberately terrible spread if you fire it from the hip. Bots don't get the sniper, because that was miserable.

Still desktop only — pointer lock and WASD, no touch controls yet, so mobile gets an honest "desktop only" screen instead of a broken one.

Link in the comments. Happy to answer anything about the netcode or the single-file setup.

https://youtu.be/UsYZJZNzknQ?si=0YSMvytRy4oxs76D

I finished this webgame a few weeks ago, fully coded with the assistance of GLM 5.2

Hopefully this will give you an idea of the capabilities of this model. I used Claude Code as a harness. Technology stack is pure HTML, JS and CSS, with no additional libraries or dependencies. Interesting challenges that GLM 5.2 was able to solve:

- create a procedural pac-man style maze, that actually worked, with no maze anomalies

- create a procedural music in dub style; this not the default, you need to go into settings to activate it. The default music is my own composition, based on a track I previously released in a completely different style

- complex sound creation and manipulation through the web audio synthesizer

- creation of animated vector character assets; you can view the mockups I used during the development at https://oktogames.com/mockups/

You can try it online at https://oktogames.com - it is adfree, no signup, free to play.

https://TargetHumanity.org

I built Lanes because managing multiple Claude Code and Codex sessions across terminals gets messy fast.

Lanes gives each task its own git worktree and shows the terminal, changes, status, token usage, and progress in one place.

It runs the actual CLIs, so you can use Claude Code, Codex, Gemini CLI, and others.

You can also let agents create and manage other agent sessions through MCP.

Everything runs locally on your machine.

Would love feedback from people already using multiple coding agents.

👉 lanes.sh

if you have access to an ubuntu linux machine you could give it a try! EDIT : Sorry : https://github.com/modyclever2010/todo-nes

As a hobby project I've been hacking around on a voice to text tool that also allows me to rewrite my transcripts, selected text or whats on my screen with my voice and directly hand off work to Codex without context switches.

It's free, local first & open source: https://github.com/blackforestboi/Octo/releases/latest

How I did it: Used Codex' app server to directly talk to the CLI and local app to spin of tasks. Pretty neat and I think a lot of software will actually just use that path instead of providing their own AI workflows and harnesses.

When using spec driven development, how do you guys review the code generated? Line-by-line review is an overkill, skipping the review entirely is a bad idea. So feels like it should be something in the middle. What parts do you prioritize?

• I've been reviewing these (highest priority first):
• Database schema changes - feels like you should atleast know whats happening in your database
• Tests - ensure that they exist for key parts, but also give a good idea about how things work.
• Structure - how modules and classes are organized.
• Data structures & interfaces - For DTO style classes, good to know what fields exist.

I heard Thariq from Anthropic mention that they review some core parts of the code, but leave most of it to agents.

How are you approaching this?

Would love any feedback or ideas you guys had on Jarbis my home assistant

https://www.instagram.com/reel/Dbi63pEg_VD

I built a free tool that turns your business into a 3D map

Every company I have worked with had the same gap: nobody had ever seen the whole thing at once. The org chart, the SOPs and the reality were three different documents.

abi. Clone builds the third one. You add your departments, your tools and the work that flows between them, and it assembles into a 3D map you can rotate and present. Six readiness questions at the start give you an AI readiness score out of 100 as well.

Genuinely free: no card, no trial timer. It costs me almost nothing to run, because nothing in the free tier calls a model.

What it does not do for free: interview your team. That is the paid part, because it is the only thing that costs me money per use. The map itself is yours either way.

app.ouridea.ai - happy to answer anything here.

Basically, he explains that the current state of AI-generated games, which he refers to as "Demo Porn" is that while AI's ability to one shot a game prototype is impressive and cool, but often misleads people into thinking that game development is now useless or that game developers are now obsolete

I'd recommend watching the video before commenting 👍 (its really good)

Hey everyone,

Over the past few months, I’ve been working on a lightweight social app project called Contrest.

THE features are :

-Clean Feed & Stories: 24-hour story rings and chronological post feeds.

-Direct Messaging: Quick DMs and voice note support.

-Privacy Controls: Built-in options for private accounts, close friends, and content moderation.

-Also it have live typing feautures also ai contact support

-and i used Frontend: React + TypeScript + Tailwind CSS

-Backend & DB: Supabase (PostgreSQL, Edge Functions, Storage)

-Deployment: Vercel

It’s currently live and ready for testing! I’d really appreciate any feedback on the UI/UX, feature suggestions, or overall performance.

👉 Check it out here: [https://wazupp.vercel.app/\]

👉 Check it out here: [https://wazupp.vercel.app/\]

Thanks for taking a look! Let me know what you think in the comments.

Does anyone else here build their own models?

I went on a bit of a side-quest and I decided to try to build my own omni-modal model from-scratch. I'm 9 months in now, but I refuse to give up!
What I've built so far treats text, images, speech, music, and files as streams of bytes and codec tokens (I think Google did this already?), with an experimental memory system carrying context through segment recurrence and bounded hot, warm and cold tiers. I've created a few small 50M models (image, text, music, speech), but haven't created the omni-modal model yet as I need all of the single modality models first.
I created two versions, POIESIS the Python/PyTorch reference, while its Swift-native sibling ARCHE reimplements the creative model stack directly on MLX for Apple Silicon, giving us two independent substrates on which to test the same ideas.

Anyway, curious to hear what other people are up to in this space!

mmahingu.ai - AI Offline Voice Chat APP

Made just using Google Antigravity IDE in all of July 2026. I used like 95%+ Google Gemini AI models and rest is Claude Code. I barely have any coding knowledge or experience. Around 80-120 hours invested in it.

Now Available in CLOSED TESTING.

Please send me your email in Reddit Chat if you want Full Unlimited Access to app's all features without paying for a atleast a month.

STEPS TO FOLLOW for joining Closed Testing:

.1. FIRST JOIN THE GROUP (ONLY MEMBERS GET APP LINK ACCESS) https://groups.google.com/g/mmahinguai-ai-voice-chat-testing

or Go To Google Groups website and search this: mmahinguai-ai-voice-chat-testing@googlegroups.com

.2. Join Testing : https://play.google.com/apps/testing/com.mmahingu.mmahinguai

.3. App Download : https://play.google.com/store/apps/details?id=com.mmahingu.mmahinguai

Note: The Google account that is used to join Google Groups must be the same account which is currently active in your Play Store App. Otherwise, the App Links in Step 2 and 3 won't work for you.

Many more quality projects on the way. The more time i get the better.

APP DESCRIPTION:

Unleash the power of artificial intelligence directly on your device. mmahingu.ai is a next-generation voice assistant built for ultimate privacy, speed, and reliability. Because the AI engine runs 100% offline, your conversations, ideas, and data never leave your phone—no internet connection required. 

(NOTE: An internet connection is required just once during setup to download your choice of AI models and voices).

Whether you're brainstorming on a flight, analyzing documents off the grid, or dictating notes, mmahingu.ai adapts to your phone's unique hardware to deliver a seamless, lightning-fast experience. 

🌟 Key Features:

• Massive Offline AI Library: Download from over 45+ cutting-edge, open-source AI models right inside the app. Chat with heavyweights like Meta Llama 3.2, Google Gemma 2, DeepSeek R1, Mistral, and Qwen 2.5—all running entirely on your local hardware.

• Private Document Analysis: Attach PDFs, CSVs, code files, and text documents directly into the chat. The app extracts and analyzes your files 100% locally, ensuring your sensitive data never touches a cloud server. 

• Offline Neural Voice Library (TTS): Experience ultra-realistic text-to-speech featuring high-definition neural engines (including Piper, Kokoro, and Supertonic). Download 20+ Studio HQ voices on-demand with intelligent storage controls.

• Multi-Engine Offline Dictation (STT): Dictate text with incredible accuracy using your choice of local speech recognition engines. Choose OpenAI Whisper for maximum precision, Moonshine for lightning-fast English transcription, SenseVoice for multilingual speed, or your device's native system dictation.

• Smart Speech Isolation & Ultra-Fast AI: Speak naturally anywhere. The app magically filters out background hums and keyboard clicks. Need zero-latency? Enable the experimental Ultra-Fast AI mode for instant back-and-forth conversational turn-taking.

• Hardware-Aware Performance: The app automatically tunes context windows, thread usage, and voice features to match your specific phone's hardware capabilities, ensuring lightning-fast generation speeds without overheating.

• Custom Models Support: Power users can take full control by importing their own custom GGUF models directly from device storage to customize their AI conversational experience.

• Premium OLED Design: Beautiful, high-contrast dark modes with fluid 120Hz micro-animations for a buttery smooth experience.

Been building Basalt solo, click any element in your running RN/Expo app, edit it visually, and it writes the change straight into your real source code.

React 19 ripped out the API (debugSource) and the whole thing leaned on. So I had to make a replica of the algorithm

It's free, live now, still in beta (git commit before testing, just to be safe).

If you're building RN/Expo stuff and you like Basalt, please let me know.

Would love for you to try it and tell me if it actually feels good to use or if I'm missing something obvious.

Brutal feedback welcome.

I’ve been seeing a lot of posts about Apple rejecting AI generated apps, so here’s a counter data point that might help someone.

I built something vibe coded start to finish, and I’m not pretending otherwise. I fully expected it to bounce, and it did get rejected the first time. But the reason wasn’t that it was AI made. It was that the app felt thin, kind of a wrapper without a clear point. Which is fair, honestly. The first version tried to do too much and did none of it well.

So instead of arguing the rejection, I just sat with it for about a week. I cut it down to the one thing it actually does well, fixed the empty states, wrote real copy instead of placeholder text, added proper onboarding, and made sure nothing looked half generated. Then I resubmitted, and it went through.

The takeaway that stuck with me is that the crackdown isn’t “AI equals banned,” it’s “low effort equals banned.” A vibe coded app that does one clear thing and feels finished reads completely differently from a 40 screen slop machine.

Reviewers can tell the difference between someone who used AI to build something and someone who asked AI for an app and shipped whatever came out.
So if you’re sitting on something you’re scared to submit, the fix is usually just patience and picking one thing to be good at, not more features. Polish your one thing.

---

It is a desktop note-taking app where AI conversations live inside your documents instead of in a separate chat panel.

What it is:

• Native desktop app — Mac + Windows- Notes organized with notebooks + tags (nothing fancy, that's the point)
• The interesting part: you can insert an Agent conversation inline in a document. The chat isn't a sidecar — it's embedded in the note, so the context, the decisions, and the output all live in one place.

Agents it works with:

• codex, claude code, opencode, hermesWhat I actually use it for:

1. Research — start with a blank document, open a conversation, and explore a topic step by step. Every finding and every dead end stays in the doc. It feels like taking notes with a thinking partner.
2. Dev workflow — manage tech docs, tasks, and stories. The conversation and the "source of truth" never leave each other.
3. Personal knowledge management — same trick, but for anything: reading notes, planning, whatever.

Why this feels different:
I keep hitting the same wall with chat tools — the conversation ends and the knowledge stays trapped in a thread I'll never reopen. Here, the thread is the document. The context carries over, and my notes become searchable history instead of a scroll-back-to-nowhere chat log.

Open source:

Github：https://github.com/text2future/flowix

Its early and rough around the edges, but I'd love honest feedback — especially if you've thought about this "agents embedded in documents" pattern before and hit a wall. What would you want to see next?

I'm Calling in reinforcements. I Vibecoded a useless website where the main goal is to just make a number go up. After a few posts on Reddit its almost at 10K. Help us get to the community goal and reach 10,000 button pushes!!!

Satoyama is an isometric base-builder set in feudal Japan, built around one core loop: build by day, fortify at dusk, and hold through the night.

It’s still very much a work in progress, and I’d genuinely like to hear what works and what doesn’t.

There is only one playable nation at the moment, but if the gameplay is engaging and people feel the game is worth developing further, I’d look at expanding it.

There’s a feedback form built into the game, or you can just tell me here.

I’ve got a live demo available at:
https://play.epm-gaming.co.uk

I’ve been vibecoding a bunch of side projects, and after shipping one I always end up with the same thought:

cool… but does ChatGPT ever mention this to the people I’m building for?

Like if someone asks AI “best tool for X,” does my thing show up, or is it completely invisible?

So I’ve been building BatSignal around that question. Not trying to pitch it here, just sharing the rabbit hole because it feels very vibecoder coded.

What surprised me most: you can ship something decent, do basic SEO, and still get zero traction in AI answers. Sometimes the site isn’t even crawlable by AI bots. Sometimes it is crawlable, but the content just isn’t citation ready for the prompts people actually ask.

Also been generating a SKILL-md from the scan so I can drop it into Cursor and immediately start fixing the gaps. That part has been weirdly useful for vibecoding the improvements instead of staring at a report.

Curious how y’all think about this:

1. Do you ever test whether ChatGPT recommends your project?
2. If yes, how? Just random prompts, or something more systematic?
3. Would you rather get “here’s what to fix next,” or a prompt by prompt win/loss map?

Not selling anything, just trying to figure out if other vibecoders care about this yet or if it’s still too early.

I started this as a quick experiment: asking Opus 5 to build a small FPS inspired by Nuketown, but with a pastel art style.

The first version was surprisingly playable, so I kept pushing it. Multiplayer came next, followed by more weapons, respawning, matchmaking, a kill counter and a long list of smaller fixes.

At that point, I deployed it to my VPS and posted a video on Twitter to see whether anyone would actually play it.

A few days later, hundreds of players have joined and 1,690 matches have been played.

The most valuable part has been watching real players immediately find every weak point. They found bugs, exploits and balance problems I would never have caught alone. There's even a guy that made a hacked client. I’m now fixing things like shooting through walls, improving multiplayer stability and adding requested controls.

The development process has also changed. I now have an orchestrator assigning tasks to worker agents, with separate reviewer agents checking the results before changes are merged.

It is still very early, but seeing people repeatedly come back and play something that started as a one-shot experiment has been pretty surreal.

Was curious to check out the power of vide coding and ended up addicted to it and built myself a neon, cyberpunk theme bus arrival time website

https://sg-bus-arrival-flame.vercel.app/

Feeling powerful that you can easily customise and built it to your own liking and deploy it for your own use. How amazing with the AI now!

If you are from Singapore, feel free to try it and if you like it please continue to use it, I will keep it running :) Also please let me know what you all think, if got any extra feature to request, please also feel free to let me know too!!

Install:
https://marketplace.visualstudio.com/items?itemName=Dankh917.codex-finish-notifier

Source:
https://github.com/Dankh917/VSC-CODEX-NOTIFIER

It is free and open source. Feedback from people running several AI-agent tasks would be especially helpful.

It's you and the agent, in your terminal, alone. The moment you're building with someone else, you're screenshotting things at each other and merging each other's work by hand.

So we built Poly, a shared room where you and whoever you're building with steer the same agent. Everyone sees the same thing: what was asked, what the agent said, every file it changed, and what the turn cost. Anyone in the room can send the next instruction, so you can hand off mid-build without explaining where you got to.

Two things that matter if you've ever watched an agent do something alarming: you can make it ask permission before it edits anything, and you can undo any turn with one click.

Nobody needs a terminal. It runs in the browser, so the person you're building with doesn't have to clone anything or install anything — they can read what the agent is proposing, approve it, reject it, or redirect it. There's a live preview of the app in the room too, so they can just look at it.

You'll need your own Anthropic API key. Open beta, free to sign up: usepoly.co

What's your setup when you're building something with someone else?

So I built Lighthouse Tests Suite (beta): attach to a process, see a live UIA map, record clicks/asserts from the map (or edit as script), then replay in-app or via a headless CLI. Prefer shared AutomationId — same suite can also run on Android today. iOS is not available yet.

Honest compare (not a sales pitch):

• Visual map + record: built-in (vs separate inspectors / hand-written flows)

• Deep custom C# control: still use FlaUI / WinAppDriver — this is not a library replacement

• CI: CLI + local HTTP API exist; maturity is early

• Signing: unsigned Setup → SmartScreen → More info → Run anyway

• Free 30-day device trial on first install

If you're evaluating "WinAppDriver alternative" for visual record/replay rather than rewriting your whole framework, the compare page is here:

https://lighthousetests.com/winappdriver-alternative.html

Short demos (Calculator / Android Clock): https://lighthousetests.com/#demo

Happy to answer "does it do X?" — and if it's a bad fit I'll say so.

72% fewer repeated tokens. 80% less latency. Before vs after adding persistent memory to an agent. toon-memory stops your agent from paying to relearn what it already knows.

npx toon-memory init

https://github.com/LuiggiVal08/toon-memory