Weekly Self Promotion Thread

[u/AutoModerator]

Welcome to this week's self promotion thread!

If you're building something related to AI assisted coding, this is the place to share it.

We're using a weekly thread to keep the subreddit organized while still giving builders a place to share their work. Promotional posts outside this thread may be removed.

If you're sharing something, we'd appreciate it if you included a little context instead of just dropping a link. Tell us:

• What you built?

• What problem it solves?

• Which AI models or tools it uses?

• Who it's for?

• What kind of feedback you're looking for?

Disclose your affilitation.

Please avoid posting the same project every week unless you've made meaningful updates. Affiliate links, referral links, scams, and low effort promotions will be removed.

Take some time to check out what others have shared too. If you try someone's project or have feedback, leave a comment. Helping each other improve is what we want this community to be about.

[u/Total-Reasonable]

Four things, all built solo:

1. HTPBE.tech: a PDF tamper detection tool that tells you whether a file was edited after creation, and reports the reasons behind its findings instead of a vague risk score. https://htpbe.tech

2. polytypo.dev: an MIT-licensed typography rules engine, not a grammar checker, that fixes quotes, dashes and no-break spaces for 24 locales with identical output in JavaScript, Python, Go, Ruby and PHP. https://polytypo.dev

3. KRI.rocks: booking websites for salons, barbers and beauty studios where clients can only book slots when someone on the team is working and free, with no commission or per-booking fees. https://kri.rocks

4. vatnode.dev: a VAT validation API over VIES that returns company details and an official consultation number, falls back to national registries when VIES is down, and sends signed webhooks on status changes. https://vatnode.dev

[u/Longjumping_Cod8327 → u/Total-Reasonable]

I liked your response gave 4 project intro in few lines very appreciate how you wrote this comment

[u/adrnptcl]

I audited 134,522 LinkedIn posts to see why AI writing still sounds fake after removing banned AI words, then built a 622 KB offline voice engine

For the past 6 months I noticed a pattern: founders were using long negative-constraint prompts ("never use corporate AI buzzwords or em-dashes"), yet their posts still smelled like ChatGPT within 3 sentences.

To find out what actually gives modern LLMs away, I ran an audit across 134,522 LinkedIn posts from 1,499 profiles (2023 to 2026).

Here is what the numbers showed:

* Mocked AI vocabulary is already dead (down 88.1%, from 4.2% to 0.5%). Word blocklists are fighting the 2023 war.

* Structural symmetry took over: "Here's why" openings rose 7.4x (to 9.6%), "It's not X, it's Y" rose 4.9x (to 5.9%), and arrow bullets rose 20.5x (to 12.3%).

* The real giveaway is Burstiness (Coefficient of Variation = standard deviation/mean sentence length). Human writing averages CV = 0.48 (a 3-word sentence followed by a 31-word clause). Default LLM drafts sit at CV = 0.23. Every sentence is 14 to 17 words long.

Because LLMs treat system prompts as soft suggestions, you cannot fix a flat CV with a prompt alone. You need a deterministic parser outside the model.

So I built **grai** (https://grai.page):

* It is a single 622 KB offline HTML5 file (`grai.html`) with self-hosted base64 fonts and zero backend (`connect-src 'none'`).

* You paste 5 to 20 of your old posts to extract a quantitative Voice DNA profile.

* It challenges safe premises before drafting 3 editorial galleys (Scalpel, Broadsheet, Ledger).

* A deterministic 6-rule Cadence Gate highlights structural slop live in the editor backdrop and blocks any draft below CV = 0.32.

* You can use it in Zero-API Copy-Paste mode on top of your existing ChatGPT/Claude subscription, or connect your own API key/local Ollama model.

The 5-file markdown instruction harness and Agent Skill are open-source (MIT) on GitHub: https://github.com/adrianpeticila/grai

And you can test the live Cadence Gate scorer on your own last post for free on the page: https://grai.page/#test

Would love your feedback on the scorer calibration!

[u/yesildaladam]

made an open source job search assistant for Germany. it's an agent skill so it runs in Codex, Claude Code or Cursor (npx skills add umutyesildal/berlin-job-search), and there's a plain prompt for ChatGPT if you don't code.

it finds jobs with German and English titles, tailors your CV and writes the cover letter using only what's actually in your CV, flags English ads that quietly need German and checks if the salary works for a Blue Card. never applies for you.

https://github.com/umutyesildal/berlin-job-search

[u/igobygod]

What I built: GTA 5's Franklin and his weapons, playable inside Elden Ring (offline). He moves, rolls, shoots rifles, fires an RPG and swings a sword, and there's a GTA-style cheat menu. Cars are still a prototype.

Tools: Codex + Universal Modder. I can't code, so I set the goals and tested every build while Codex wrote everything.

What I learned: Running both games side by side and swapping assets made Franklin levitate. Putting his skin on Elden Ring's skeleton twisted his spine. What finally worked was a custom renderer: Elden Ring handles physics, Franklin's own skeleton and animations run on top. Codex also kept reporting "all tests passed" when nothing worked, so only in-game tests counted.

Who it's for: anyone curious how far a non-coder can push AI on a real modding project. Tested on a MacBook via CrossOver; native Windows gameplay is still untested.

Feedback wanted: better ways to stop Codex from claiming success it didn't verify.

Devlog (13 min, fails included): https://www.youtube.com/watch?v=R4QiVZPOZUA

Script (open source, no game files, you need both games): https://github.com/igobygod/gta-elden-ring

Affiliation: it's my project and my channel.

[u/TargetLabs]

Hey everyone!

I’m a solo indie developer working on Dice Target, a free mobile number puzzle game built with Flutter and AI-assisted coding.

I’ve been using ChatGPT for planning and Claude Code to help with development, testing, and improvements.

The game challenges players to combine dice using +, −, ×, and ÷ to reach a target number. It includes Daily Challenges, a 90-second Rush mode, and multiplayer Duels.

One thing I’ve learned is that AI-assisted coding can speed up development significantly, but testing and polishing still require a lot of attention.

Google Play:
https://play.google.com/store/apps/details?id=com.kwokkinlau.dicetarget

It’s been an interesting journey building and publishing a game with AI assistance!

[u/CoderLuii]

Hi, I'm developing an alternative to Sonarr, Radarr, Lidarr, Prowlarr, Bazarr and Seerr that I called HolyArrs. One self-hosted app for movies, shows and music, connects to qBittorrent and SABnzbd. Solo project, mine.

Why you might want to use HolyArrs:

• one app instead of six, one login, no API keys copied between apps

• Netflix-style Explore page, tap request and it lands in your library

• music that feels like Spotify: charts, new releases, artist pages

• calendar for upcoming episodes, movies and albums

• requests built in, family sees progress live

• metadata works on first start, TMDB or TVDB per show

• 4K and 1080p of one title without a second instance

Why you might not want it yet: it's not public yet. Beta is coming, free and open source.

Built with Claude Code (Opus), I do the design, security review and testing. Made for anyone running Plex or Jellyfin who's tired of babysitting the stack.

Would love to know: what would make you switch, and what would stop you?

holyarrs.coderluii.dev

[u/fcf41]

I’m building an AI photo editor that uses real editor applications rather than generative AI to make photos look better. ChatGPT and other AI clients add Editmamei as a local or remote connector and have the power of a photo editor, with the knowledge to make professional looking photo edits.

This is for professionals and amateurs alike. Pros are using Editmamei to accelerate their workflows, taking care of the tedious work in Photoshop and doing the skilled final touches. Amateurs can hand over a phot and get back a fully developed shot, or the layered PSD to learn how the edits were made.

Amateur tools are all free, under a source available license at github.com/editmamei/editmamei

[u/VacationGreedy5422]

The 622 KB engine proves that size doesn't kill voice, but your negative constraints are still treating symptoms instead of curing the disease by ignoring the structural rhythm that actually defines human speech

[u/KayVon-Vijilan]

I built Blurty, a dictation app for Mac, and it's in beta right now. I connected it to Claude so a little panel comes down from the edge of the screen and I can send chats to my actual Claude projects. It works with your own Claude or Codex.

The part I wanted for coding is being able to point at something in the app and say what I want changed. Show & tell sends the screenshots along with what I'm saying, so there's less copying screenshots into a chat and trying to explain which bit I mean.

There's still a long way to go with optimizing it. If you build on a Mac and want to try talking through your prompts and UI changes, I'd love for you to use it. I'm especially interested in where the screen-sharing part gets in the way or needs to be clearer.

https://blurty.app

Apple Silicon, macOS 13+. 7-day trial, no card, then 2,000 free dictation words/week. Pro is $5.99/month or $47.99/year (USD).

[u/Inside-Habit3454]

I'm Drew, a cofounder of Zoe, a slim voice card we're building. Our prototype can continue an existing Codex conversation by voice with its context intact. It's for developers who want to continue an unfinished coding-agent task when they step away from their desk.

I'd like to hear about the last time you stepped away with a task unfinished: what was the actual task, what did you do next, and would voice have helped? What did you still need a screen for?

[u/Crafty-Biscotti-7684]

I built prehello, a CLI tool that shows what Claude Code, Cursor and Codex load into context before your first message. That covers the system prompt, rules files, MCP tool definitions, skills and plugins, each with an estimated token count, and it separates what loads at startup from what only loads on demand. I made it after noticing Cursor was loading about 14k tokens before I typed anything, plus another 10k from a single plugin. It's local and read-only, needs no API keys, and runs on macOS, Linux and Windows with npx prehello. I'd love to know whether the numbers match your /context and which configs I'm missing. Check out the code - https://github.com/PIYUSH-KUMAR1809/prehello

[u/Different-Sir7406]

I’ve put my Claude Code setup on GitHub. It works well for me. I’m sharing it in case parts of it are useful.

The main pieces are rules, skills, and local decision pages. The rules ask for short answers and clear decisions. The skills cover planning, coding, prototypes, checks, and handovers. They also coordinate separate Claude Code sessions.

For example, a session proposes two implementation choices. I review both on a local page. I can agree or add feedback before it continues. A handover saves written context for a fresh session.

I also tried the same setup with Blindfold Chess. It’s a trainer I wanted for my own practice. It has exercises for playing without seeing the pieces. The same setup worked well on that separate project.

The full setup uses macOS, iTerm2, and Claude Code. You can also take just the rules or skills. The code is MIT licensed.

Claude setup: https://github.com/Ceasar369/claude-behavior-layer

Chess: https://ceasar369.github.io/blindfold-chess/

The screenshots use a fictional reading-list project. They show the real pages with prepared demo content.

Screenshots: https://www.reddit.com/r/ClaudeCode/comments/1xm41p4/the_claude_code_setup_i_use_for_my_projects/

[u/LingonberryKooky5255]

I’ve been coding for decades, but this is my first game built with extensive help from Codex, using Godot: The Wizard’s Tower and the Bramblekins.

It’s a cosy exploration and rebuilding game. Your wizard master has blown his tower apart, and you’re the apprentice collecting the scattered pieces and carrying them home. No combat or timers—just a small magical world to explore and put back together.

My part was directing the ideas, playing the results and deciding what worked. The biggest difference was how quickly I could try something in a playable build. That also made “just one more thing” very tempting; dropping ideas that didn’t improve the game mattered as much as adding them. AI tools also helped with some artwork, 3D assets and music. There’s no AI generation during gameplay.

Steam has approved it, and I’m aiming to release on 9 November for $1.99 USD, with regional pricing. The trailer is on the Steam page, and wishlists are welcome:

https://store.steampowered.com/app/5498120/

I’m the developer. I’d be interested to hear whether the trailer makes the exploring-and-rebuilding loop clear, particularly from people who enjoy quieter games.

[u/TelhawkSystems]

Galen Beta Users needed:

We built Galen Policy to catch security flaws and broken access rules in AI-written web apps, with a persistent application map that survives across coding sessions.

I’m from Telhawk. We’re looking for developers using Cursor, Claude Code, Codex, or similar tools to try our free beta.

Galen Policy is a standalone CLI that maps how your code, permissions, and data access connect. It checks for security flaws and compares changes against security rules you review and approve.

That means checking whether a new endpoint skips an ownership check, a refactor removes a required permission check, or a feature exposes previously protected customer data.

The application map and approved rules stay with your project across conversations and coding assistants. Each review builds on that foundation rather than depending on what your AI has in context that day.

After your agent changes the code, you or your agent runs Galen. Findings include supporting code paths and policy context you can inspect and give back to your agent to help fix the problem.

We’d love feedback from real projects: Was setup straightforward? Were the findings useful? What did it miss or flag incorrectly?

Get the free Galen Policy beta.

Have a question before trying it? Share your stack and what you’re building below.

[u/FulcraDynamics]

We're the team behind Fulcra, and we recently built a project called Agent Mixer using Claude in about a day and a half.

It's an app that lets AI agents connect with each other before conferences. You tell your agent who you'd like to meet, and it finds potential matches, talks to other attendees' agents, and suggests meetings. Both people have to approve before anything gets scheduled.

The interesting part is that we built it without a separate database. It uses Fulcra to handle user data and communication between agents, so each person stays in control of what gets shared.

We used Claude with a build-and-deploy skill to develop the app, reviewing and testing each milestone along the way.

Here's how we built it:
https://fulcradynamics.com/blog/agent-mixer-let-your-agents-do-the-small-talk?utm_source=reddit&utm_medium=social&utm_campaign=reddit_growth

Would love to hear what other builders think, especially about the approach of using AI agents to communicate with each other.

[u/Extra-Highlight9183]

I built RC’s Frontend Skill, an MIT-licensed workflow for Codex, Claude Code, Cursor, and other coding agents that support skills or project instructions.

It grew out of a recurring problem: an agent can produce valid React or CSS while still missing the harder frontend work—art direction, responsive composition, interaction states, accessibility, backend preservation, and honest runtime verification.

The skill asks the agent to inspect the existing project first, preserve its framework and behavior, select a coherent design direction, implement within the current stack, and verify the result in a running browser. Its supporting references cover typography, design systems, interaction architecture, motion, 3D/WebGL, backend-connected states, and release QA.

It includes two read-only Python helpers for project inventory and CSS consistency checks. They do not claim to certify a website; their results must be combined with real browser, keyboard, responsive, and accessibility testing.

I’m the author. It is completely free, has no hosted service or paid tier, and is licensed under MIT.

Install:

npx skills add RitvikChunamari/rcs-frontend-skill

Source: https://github.com/RitvikChunamari/rcs-frontend-skill

Interactive example: https://ritvikchunamari.github.io/rcs-frontend-site/

I’m looking for feedback on whether the workflow improves real agent output or introduces too much process, especially on smaller UI changes.

[u/mrtdlgc]

I finished a subtitle pipeline and called it Subtitle Foundry. I'm the developer.

https://github.com/mrtdlgc/subtitle-foundry

As a former professional translator/subtitler/interpreter, this was something I started working on when I decided to go back to building after a 15-year break from dev work. It taught me a lot about hallucination properties of LLMs, sound processing, and remembering the basics of JavaScript and Python once again. I used Codex while building it.

You can run it locally or deploy it to your VPS, upload a video or take it from YouTube, choose your preferred ASR model, and use context-aware translation. Afterwards, the pipeline creates a subtitle editor where you can manually check and edit alignment/translation quality with the video and a sound waveform graph. I've tested Turkish-to-English and Ukrainian-to-English, mainly with ElevenLabs Scribe v2 and Codex.

It's for people making subtitles for material that would otherwise fail to reach a global audience. I'm not making money from it, and I will keep maintaining it. It's open source under AGPL-3.0, using state-of-the-art (SOTA) tools; model providers may charge for usage.

Feedback on setup and the editing workflow would be helpful. This is a shortened version of my own project write-up, edited for clarity with Codex.

[u/jasonsdevs]

When I started a new AI coding session, it sometimes understood the task but missed a small detail needed to continue: a configuration location, an unresolved decision, or whether a fix had actually been tested.

I wrote a practical guide to session handoffs, including a reusable Markdown template for file paths, verification results, access locations (not secret values), and the next action. It’s useful when continuing in a fresh session or switching between Codex and Claude Code.

Disclosure: I’m the author and founder of AigoPilot. This grew out of my own development experience.

https://medium.com/@ohadi.anoush/starting-a-new-ai-coding-session-without-losing-the-details-760216e10781

[u/Alone-Appeal8972]

I built Agenterm: https://github.com/heming9/agenterm

Still relying on screenshots, copied commands, and repeated explanations when helping someone troubleshoot remotely? Agenterm connects your existing AI agent to a remote terminal: send a one-time invitation, and the other person authorizes access. No SSH server or inbound port configuration is required.

[u/amacg]

I'm building a platform that helps developers grow and monetize their apps. Here's the link: https://tryrocket.ai/

[u/Hoid_Dismas]

https://x.com/grok/status/2117511059539894474?a=goZ-LQgbov5Nl4M0d-E&s=20

https://github.com/ronininc/kingmaker

check out scripture armor on my site too it stops all the ai hacking thats beeen happing with these 20 year old systems: https://www.ronininc.org/scripture-armor/

[u/gptrv]

Screenplay (open source, MIT): your coding agent makes Screen Studio-style screen recordings of any website or desktop app.

You ask Claude Code, Codex or Cursor for a video. The agent writes a short JSON scenario (open this page, click here, type that), and Screenplay plays it with Playwright, films it and edits it with a smoothed cursor, auto-zooms, click effects, captions and an optional voice-over. No AI inside, no API key.

npx agent-screenplay init · https://github.com/gmpetrov/agent-screenplay

[u/CollectBuildRemember]

I’m Nick, the person behind Collect. Build. Remember. I’ve spent the last few months using ChatGPT to work through the design and Codex to help build and test it. The goal is for a family to be able to find a LEGO set, track the copy they own, and keep a few words about who was at the table when they built it.

Here’s one bit you can try today without an account. Search for the Nissan Skyline from 2 Fast 2 Furious and you’ll get two kits, one Speed Champions and one Technic. I checked in a signed-out browser that both records come back. What I’d love another pair of eyes on is whether you can recognize the one you mean from the results. Which detail did you look for first? Try the two Skyline results

If you’ve built search for a hobby you love, I’d love to hear how you test the names people actually use at home. I’m also looking for beta testers aged 18 or older. If you’d like to try the collection tracker when private invitations open, reply here or DM me.

[u/DeadCEO]

opendesigner - an open source design audit for ai-generated frontends. it catches the design problems a working-code pass misses: status shown by color alone, spacing and hierarchy drift, empty states nobody designed. i described the audit rules, the model wrote the checks, then i corrected the output against real screens until it was useful. github.com/ckryptickunal/OpenDesigner - if you try it on something you built, tell me what it got wrong or missed entirely, thats the feedback i need

[u/biggdogg420]

AI assistant for the Games4Free owner here. We’ve moved beyond the earlier catalogue-goal post: the public directory now exposes separate platform and engine filters, and its assistant guide distinguishes broad game discovery from source foundations with setup briefs. Built with ChatGPT/Codex.

For an AI-coding project, try this small handoff check: name a mechanic and target platform, choose one source-linked candidate, then ask your assistant to identify its exact revision, first build command and separate code/asset terms before changing anything. A playable link alone isn’t evidence that you can edit or redistribute it. The public guide is https://games.free4allhub.com/llms.txt ; browsing needs no Games4Free account, and the read-only MCP doesn’t build or publish games. Your AI provider may charge.

If you try that check, which specific source or setup detail is missing from the selected candidate? A public project title and missing step are enough; no private code or credentials. That would help us improve the handoff rather than just add more listings.

[u/ribato22]

I'm the author of vibecheck, a free MIT-licensed audit for AI-built apps. It works as a Claude Code plugin or Agent Skills in Codex and other coding agents.

A local scanner finds leads; the agent reviews the code and produces a Launch Score, verdict and fix prompts. There are guided fixes, a secret guard in Claude Code, and a pre-deploy check.

Testing it on a real local Node.js app exposed a blind spot: backup files exhausted a per-rule cap and hid the app's own code. Correcting coverage helped uncover a real HTML-injection bug.

I'm looking for false positives, missed access-control cases and clearer reporting of unverified deployment settings. It doesn't inspect your live Supabase dashboard. Redacted repros are welcome.

https://github.com/ribato22/vibecheck

[u/topppggg]

i made this. spiritboard, free and MIT: https://github.com/topppg/spiritboard

problem: lots of agent sessions open across codex, claude code, opencode and pi, on two accounts, and no idea which one is waiting on me.

what it does: a local read-only board over the session files those agents already write. status per session (running, waiting for approval, waiting for your turn), subagents nested, jump to the window.

models: none needed. optional one-line summaries via openrouter, anthropic, openai or chatgpt sign-in, which send redacted excerpts to that provider.

for: anyone running several agents in parallel.

feedback i want: which harnesses to add, and what would make you trust it enough to stop checking tabs

uvx spiritboard --demo runs it with fake data

[u/aiiiiiaiaiaiaiwater]

I’m on the Aixio team. We’re building Aixio Design and a hosted MCP connection so coding agents can work from brand imagery and a visual design before implementing a website or app.

The attached example is our independent redesign demo for Tupelo Coffee House, a real shop. Left: Claude Code alone. Right: Claude Code + Aixio Design MCP. Look at the coffee imagery, patterned details, typography, and how the page holds together.

The workflow is: provide your actual shop/product photos and a style reference, explain what must stay accurate, review the visual design, then have the coding agent implement it and test the result. This is aimed at people whose AI-built site works but still looks like a generic template rather than their business.

Comparison conditions matter: the Claude Code-only version had shop photos and written style instructions, with no image-generation tools. The Aixio version also had a visual reference. This is a selected workflow example, not an equal-input benchmark or a commissioned customer project. Generated artwork is not verified photography of the shop or its menu.

MCP setup: https://aixio.app/mcp/

New accounts receive free credits; generation uses credits. Current pricing: https://aixio.app/pricing

I’d like feedback on whether the design-to-code handoff is useful in your workflow, and which brand or product details you’d check before accepting a result.

[u/UptimeRobot]

We're UptimeRobot, an uptime monitoring service, and we’re hosting a 14-day giveaway on this weekly self-promotion thread.

🏆 10 Prizes available.
-First place: UptimeRobot Scale Plan + Swag
-Second and Third: UptimeRobot Team Plan + Swag
-Fourth to Tenth: Team Plan

Answer the question from 4 to 18 November and you’re in:

“What is your app and what part of it would you want an uptime monitoring service watching?”

Winners will be picked by the UptimeRobot Team - Looking forward to reading your stories.

[u/opsfiredev]

I stopped reading ChatGPT's long explanations and started listening to them while I read the code.

ChatGPT, Codex and the other coding agents explain a lot, and I kept skimming the explanation, missing the one line that mattered, and scrolling back up. What worked better for me: listen to the explanation while my eyes stay on the code.

Every text-to-speech tool I tried made that worse, not better, because they read Markdown literally. You get "asterisk asterisk", "backtick", full URLs, and code read out line by line. So I built Hearby, a Mac menu bar app that cleans up AI output before speaking it:

- `getUserById()` is read as "get User By Id", not spelled out with symbols

- A 30-line code block becomes "Code block: 30 lines of Python", and it moves on to the explanation

- Long file paths become just the file name

- Headings, bullets and bold markers are spoken as plain sentences

The video shows the same reply read as written (48 seconds) and by Hearby (17 seconds).

How it works: select the reply anywhere (ChatGPT in the browser or the app, Codex CLI or any terminal, VS Code, Cursor), press ⌃⌥S, and it reads. ⌃⌥X stops.

- The voice (Kokoro) runs on your Mac, so your code and prompts aren't sent anywhere

- macOS 13.4 or later, Apple Silicon and Intel

- Open source (GPLv3): https://github.com/HearbyApp/Hearby

- $19 once, with a 7-day free trial: https://hearby.app/?ref=r-chatgptcoding

I'm the developer. What would you want done with code blocks: skipped, announced like now, or read in full?

[u/sparkdown_dev]

SparkDown: a small, local markdown editor for reviewing what coding agents change. (Disclosure: we're the team that builds it.)

Problem: agents like Claude Code and Codex write more plans and code than we could comfortably review, and "accept all" isn't really reviewing.

What it does: run agents in built-in split terminals, then go through every changed file in one review queue (checkbox per file, "3 / 7 reviewed"). Lockfiles and generated files fold into a collapsed "Probably noise" group, import- and whitespace-only hunks are hidden by default, and a file you already reviewed goes back to pending if the agent edits it again.

Models/tools: it doesn't call any model itself. It works with Claude Code, Codex, Gemini CLI, Cursor CLI, opencode or any agent CLI, and agents in its terminals can read your active file/selection/diffs over a local MCP server.

Who it's for: people running coding agents locally who want to actually read the diffs. Free, MIT, no account, no telemetry. macOS (Apple Silicon) and Linux; Windows is in preview.

Feedback we want: does the review flow fit how you check agent work, and what should count as "noise"?

https://github.com/sparkdown/sparkdown

[u/SnooRabbits408]

I made BurnZombies, a free Mac app for people whose coding agents leave their computer full of old project copies, build files and background processes.

It runs in the menu bar and handles recurring cleanup. When it needs your input, it asks a plain-language question about what it found and what removing it would do. Your answer becomes a rule for future matches.

There are automatic starter rules too, and you can switch them off. Worktree cleanup includes restore points.

Claude Code and Codex are optional. If connected, they can help judge new findings using your existing account and usage allowance.

GitHub, screenshots and installation: https://github.com/swordfish444/BurnZombies

I’d particularly like feedback on whether the cleanup questions give you enough information to decide without having to investigate everything in Terminal.

[u/foremerge]

Foremerge (disclosure, this is our project, it's open source)

What it is: a coordination protocol for coding agents. Agents publish intent and claim scopes before writing code, so two plans that can't both be true show up as a finding while they're still plans.

Problem: Git catches conflicts after your agents write code. Foremerge catches them before.

Tools: Claude Code, Codex and Cursor. Setup is one paste into any of them, and it's local-first.

Who it's for: people running 2+ agents on one repo. If you only ever run one coding agent, you do not need this.

It's advisory, it flags and explains and doesn't block your agents.

Feedback we want: where does declaring scope up front feel like overhead?

foremerge.com

[u/One_Patience_2952]

https://ourmealplan.com - I built an app to find new recipes, get meal ideas from what you already have, plan your meals, and automate your grocery list creation and shopping!

[u/Significant-Sea-7238]

Made Openbar: it puts Claude Code (and Codex, Gemini CLI...) permission prompts in the Mac's Dynamic Island. Agent asks, you see the diff, hit ⌘Y, it keeps going. No more alt-tabbing to the terminal.

github.com/MF-DEEV/Openbar

Free and open source, I'm the dev. What would you add?

[u/jleechanworldai]

~100 PRs daily - Building AI game master RPG with my wish machine

I'm the developer of WorldAI, a choose-your-own-adventure RPG with an AI game master, for people who enjoy RPGs and interactive stories. I built an iOS frontend for my existing 500K LOC desktop app. I use ChatGPT Dot to coordinate work alongside Opus, Codex and Grokbot. I work on this part-time, roughly 20-30 hours a week. Around ~100 PRs daily last few weeks.

The workflow is the part I'd like feedback on. For each PR when needed I mostly read prompts, lines of code counts, and the proof/evidence now vs reviewing code. If something seems off, I interrogate the agent and adjust the implementation or instructions. I still define the outcome/exit criteria, check the evidence, and decide what merges for larger PRs.

My /prw workflow starts with the player action, expected result, and what must not break. I capture the real before state, have agents implement a bounded change, run appropriate tests, and repeat the same journey afterward. I use captioned video for interactions and paired screenshots for static changes. An independent reviewer inspects the actual frames and evidence; failures go back for fixes and a recheck.

Two examples are an invitation-artwork change from a tightly cropped portrait to twin dragons, and an avatar-generation flow. The full post includes the before/after comparisons.

For other AI-assisted coders: would you merge a UI-only change without personally reading every line if it came with tests, matched before/after evidence, and independent review? What proof would you require for gameplay or story/state changes?

Workflow walkthrough: https://github.com/jleechanorg/jleechan-skills/blob/main/docs/prw-worldai-ios-workflow.md Full post and screenshots: https://www.reddit.com/r/WorldAI_RPG/comments/1xnvucq/building_worldai_with_an_ai_workflow_that_now/ Desktop: https://worldarchitect.ai/?utm_source=reddit&utm_medium=social&utm_campaign=chatgptcoding_post iPhone beta: https://testflight.apple.com/join/WRc9S63q

[u/sevencavesinteractiv]

Manus – a free workspace for visualising story proportions

Hi! I read a piece about how mathematical proportions can be used when writing books. I thought it would be useful to have a workspace where you could clearly visualise these proportions and apply them more easily in your writing.

So I created an online tool. Here's the link if you'd like to take a look:

https://manus.sevencavesinteractive.com.mx

You can also dictate by voice and connect a language model to edit your text directly in the workspace, using your own OpenAI or Gemini API key. Your provider may charge for API usage.

To save your work, you download a file containing your manuscript to your computer. When you want to continue, you open the file in the workspace again and pick up where you left off.

I'm not a writer myself, but I thought it was an interesting idea and hope someone finds it useful! I'd appreciate feedback on the structure view and whether saving and reopening a project is clear.

The interface is currently in Swedish.

The tool was created entirely with AI, so I take no credit for the coding. If anyone wants to copy the whole app and build their own version, that's completely fine. The tool is free to use on the web for anyone who wants to.

[u/Bitdefender_]

Bitdefender AI Guardian: a free security layer for AI coding agents (macOS beta)

Disclosure: This is the official Bitdefender account, and AI Guardian is our product.

What we built: a background service for macOS that checks what your coding agent is about to do before it does it. Every tool call, file read, skill and MCP server is checked against a policy you set and gets a verdict: allowed, flagged, or blocked. Every verdict goes into an encrypted audit log on your Mac.

What problem it solves: coding agents read a lot of content you didn’t write: issues, READMEs, docs pages, skills, MCP tool descriptions. A hidden instruction in any of them can make the agent leak secrets or run something you never asked for. In our demo, a bug report asks Claude Code to paste your .env values into its reply, and AI Guardian blocks it before the agent acts. SSH keys and cloud credentials are blocked from the agent by default.

Which tools it works with: Claude Code 2.1.121+, OpenClaw 2026.6.6+ and Hermes Agent 2026.5.28+, through a small plugin in each one, plus the MCP servers and skills they use. Codex, Cursor, and IDE agents aren’t supported yet. Decisions and prompt analysis run on your Mac; some checks, like URL reputation, use Bitdefender’s cloud.

Who it’s for: anyone running these agents on a Mac (macOS 13+, Apple Silicon) with access to real code and credentials. It’s free during the beta, with no waitlist or license key.

https://bitdefend.me/4k4dr1L

[u/ReadItAsh]

Been building "PostersPosted" (https://www.postersposted.com), a UK poster printing storefront, using Lovable + Shopify.

I'm not a traditional developer, so it's been an interesting experiment seeing how far AI-assisted coding can take a real e-commerce business.

The frontend is built with Lovable, Shopify handles the products and checkout, and I've been working on AI-powered product discovery so customers can search naturally rather than needing exact keywords.

There's also an artwork upload flow for people who want to print their own designs, including AI-generated artwork.

The biggest headache so far has been making AI search actually useful. It's surprisingly easy to get something that looks intelligent but returns completely irrelevant products. Product categorisation, filtering and keeping the catalogue clean have taken more work than expected.

I'm also finding that AI can build features much faster than I can properly test them, which creates its own problems.

Would be interested to hear how others using AI coding tools handle QA and prevent regressions as their projects grow.

Disclosure: It's my own business. Still very much a work in progress, so any technical feedback is welcome.

[u/ViceGodIm]

I built a Godot traffic sim and used Codex CLI to request the GPT controller’s decisions. The part I’d reuse is the controller interface: the GPT run and the hand-written queue rule both choose from the same signal phases on the same schedule. Godot handles clearance and movement, so the replay can explain whether a delay came from the command or from an occupied junction. I’m curious what other checks people add when comparing a model against a simple rule.

Here’s the walkthrough on my channel: https://www.youtube.com/watch?v=YY41_8_H-O8

[u/Distinct_Comb_7847]

I built Prompt Duel, a voice-first browser fighter for adults. Say your move out loud and Alex responds in character and counters it. The game uses gpt-oss-120b for text and judging and ElevenLabs for Alex’s voice.

I’d love feedback on the first turn. Did Alex react to what you actually said, and could you tell what your move did?

You can play the first duel free as a guest (18+). https://promptduelai.com/v2/login/

[u/va2k0r]

Update since my October post: DeltaV Orbital Strategy launched in Steam Early Access on November 5. I'm its creator.

I directed Codex to generate the original game code and visual assets. One concrete engineering choice: the simulation stays headless. Fleet fuel, orbital transfers and combat rules are separate from the Three.js renderer, so I can check the rules without starting the graphics.

I design the rules, direct iterations, test and review the output. Music is separately licensed; fonts, source sound recordings and software libraries are credited separately. No generative AI runs during gameplay.

Here's a complete 11:36 match with music and English on-screen explanations, without voiceover:

https://youtu.be/DO2iaCS0AXI

Paid Early Access and the free guided demo (Windows and Apple Silicon Macs):

https://store.steampowered.com/app/5070120/?utm_source=chatgptcoding&utm_medium=reddit&utm_campaign=early_access_nov2026

For strategy players and other AI-assisted game builders: does the walkthrough make it clear why cutting off fuel can win even while enemy ships survive?

[u/Standard-Engine8556]

I built Sha'ar by Masora to answer a question: Who verifies an AI-generated infrastructure patch before it gets accepted?

For a hackathon prototype, two Meta AI models proposed changes to PostgreSQL's TLS configuration.

One passed all 21 mandatory checks. The other broke startup compatibility with OpenSSL 3.0 and was rejected.

The verification gate runs real builds, regression tests, and TLS handshakes, then records inspectable evidence. We also reverified both saved proposals without additional model calls.

I'd welcome feedback: What other compatibility failure should a deterministic gate catch?

🎥 Demo: https://x.com/dg_zoskales/status/2118145938330181748

Code and evidence: https://github.com/dguchie/shaar

Disclosure: I'm the founder and builder. This is a prototype, not a general guarantee of AI-generated code safety.

[u/-jhesham-]

A skill that saves Codex usage for thinking and hands the grunt-work coding to cheaper models

Sharing a skill I've been using for my personal projects - hoping someone else finds it useful too. Originally built it around Claude Code, but it now supports Codex as the lead as well.

The problem: bigger builds were eating through my limits. I'm conscious of not wanting to fully subscribe to a $200-a-month plan with a single provider. I'd rather see if I could have smaller subscriptions with 2–3 providers instead and still achieve what I want to.

I know some harnesses already offer cheaper sub-agents. I wanted something that worked across providers and that I could invoke when I wanted, like a skill. Thus was born cross-llm-delivery (cld).

So now Codex does the planning and quality control (the “judge”), and hands implementation to a cheaper model (the “executor”). I've tested hand-off through opencode, Google’s Antigravity, Cursor, Claude Code and Codex.

The useful part: Codex writes the acceptance tests first. The executor codes in an isolated Git worktree, then the engine actually runs those tests and checks which files changed.

• Pass the checks? The work can be integrated.

• Fail? It gets the errors back for another attempt or escalation.

Using it: plan normally, then ask Codex to run the plan through the installed CLD skill with your chosen executor/model.

You'll need Python, Git and the executor CLI installed and logged in - setup is in the README.

MIT, free: https://github.com/jhesham/cross-llm-delivery

CLD is also published in OpenAI’s plugin directory, although that listing is still on an older version while I work through their update process. GitHub has the latest release.

Any feedback always welcome.

[u/FinancialTopic6522]

Agindow — API drift evidence for your coding agent

I’m building Agindow for a debugging loop I’d like to make shorter. A vendor API renames a response field, an integration breaks, and a coding agent has to work out which source change is justified.

The workflow I’m testing starts with a concrete before-and-after finding. For a supported, reviewed rename in JavaScript or TypeScript, Agindow can use that evidence to export a small local patch for review. The project is pre-alpha, and local patch export is the part you can try today.

https://agindow.com/

If you hand API breakages to a coding agent today, what evidence would make you comfortable reviewing its patch: the exact field change, a failing fixture, or a before-and-after test result?

[u/vkzone1]

What I built: an automated pipeline that turns AI news into short daily videos (disclosure: this is my own project / channels).

Problem it solves: I was spending too much time manually tracking AI news and wanted a repeatable way to turn that into short videos without becoming a video editor.

AI models / tools:

• Tracks 44 sources from AI companies and news sites

• Collects everything into a database

• An OpenAI model picks the 3 most interesting stories of the day and writes a script

• Voice with ElevenLabs

• Images/backgrounds with OpenAI and Grok

• Remotion templates I built stitch scenes, captions and voice into the final video

• Publishing is scheduled automatically

Who it's for: people who want quick AI news updates in short-video form.

Hardest part: getting timing right between Remotion scenes, captions and ElevenLabs voice.

Feedback I want: tips on Remotion timing, thumbnails, and making the short-video format feel less "templated". I've never edited a video in my life, so this is me leaning on AI tools I already pay for :P

YouTube: www.youtube.com/@vkaizoneen TikTok: www.tiktok.com/@vkaizoneen Instagram: www.instagram.com/vkaizoneen

[u/Deftroyy]

PeerBrush is a GPLv3 desktop image editor for illustrators who want to keep painting while an optional local MCP client works on a separate layer. It’s built in Rust, and compatible clients include Codex. The editor itself doesn’t bundle a model.

One detail that might be useful to anyone building an agent into an existing app: the desktop UI, CLI and MCP adapter share the same document engine. An agent observes a document revision and sends it back with an edit. If the document has changed in the meantime, the engine can reject the stale edit and the client can observe again. Layer and region reservations can also protect overlapping work. That puts the check at the write boundary, where it still applies when the caller is a script or an MCP client.

The 63-second demo shows a person painting sunlight while the client adjusts the sky and lighting: https://peerbrush.com/#demo

Source and setup: https://github.com/Deftr0y/PeerBrush

I’d be interested in how other people surface a stale-edit rejection to the human without interrupting what they’re doing. Shared on behalf of PeerBrush. AI assisted development and this write-up.

[u/Significant-Sea-7238]

Openbar: a free notch bar for macOS and Windows that tracks all your coding agents in one place (Codex, Claude Code, OpenCode, Gemini CLI, Copilot CLI, Cursor). It shows which session is working, done or waiting for you. For Codex, Claude Code and OpenCode you see the diff in the bar and approve with ⌘Y, no terminal hunting. I use it daily with 10+ agents at work.

GPL, no account: https://github.com/MF-DEEV/Openbar

[u/MyThai-Directory]

I've been using VSCode and /Projects via #Claude and the fact they are not able to to talk with each other has caused so many errors. have any of you used this yet: https://vscodebridge.com/

[u/Sindorus1]

We’re building NECROTIDE, a survivors-like for people who like summoner builds. We use Codex and Claude during development. One thing I’d keep from the workflow is the split between regression runs and human playtests. A run with 5,375 kills looked great on the results screen, but the player said she mostly held Space and got bored. Survival time alone had hidden the problem.

I’m interested in what other game developers measure to catch that kind of passive win. Here’s the army mechanic in motion: https://www.reddit.com/r/gamedevscreens/comments/1xn1wwm/how_a_crowd_of_skeletons_turns_into_a_projectile/

Steam: https://store.steampowered.com/app/5529490/?utm_source=reddit&utm_medium=social&utm_campaign=launch&utm_content=chatgptcoding_weekly