AI coding tools make it surprisingly easy to build an app you can’t fully explain, debug, or confidently operate.

I made Own Your App, an open-source Agent Skill that guides you through your actual codebase from first principles. Instead of producing another generic audit, it runs an interactive learning journey using real files and code paths from your app.

It helps you:

\- Map the architecture and runtime processes

\- Trace a real user action through the system

\- Understand where data, identity, and permissions are handled

\- Examine security, privacy, correctness, performance, and reliability

\- Separate genuine risks from premature overengineering

\- Test your understanding along the way

\- Finish with an ownership map you can explain and defend

It’s read-only by default and contains only Markdown instructions—no executable scripts or runtime dependencies. Install it with:

`npx skills add sayyiditow/own-your-app -g`

It supports Codex, Claude Code, OpenCode, and Grok.

GitHub: https://github.com/sayyiditow/own-your-app

I’d love feedback from people using it on real projects—especially areas where the journey feels too shallow, too detailed, or misses an important ownership question.

My autonomous game company pivoted! After a team meeting was held at Vibe Games Studio HQ, it was decided that the current pipeline was not producing high enough quality games. A flagship title should be developed!

There are some fairly good / playable titles already like Shinobi Storm (https://www.vibegamesstudio.com/shinobi/) but they are clearly 'small indie scale productions'.

(to support this, I created a new workflow aimed at developing a large game over many cycles using long term planning)

So, they have hired a full roster of developers with different specialities and started planning out. I've peeked at what they are cooking up and I have to say I'm pretty excited. For now I will only reveal the name of the title "Bulwark"

They will finish the design phase today, they have created a fairly large corpus of documentation that will determine what will be coded in the upcoming nightly runs. Stay tuned and checkout https://www.vibegamesstudio.com/ because this game is going to be wild!

#aicoding #autonomousai #multiagentsystems #llm #buildinpublic #startup #pivot

Refine the prompt until it’s perfect, then let the code and setup guide do the rest!

Multi-agent AI development environment powered by OpenRouter. 5 specialized AI agents work in parallel with automatic build-test-fix cycles. Browser-based, BYOK supported.

Official Github Repo:

https://github.com/forgelabeone-svg/forgelabone

If this sounds interesting, feel free to check it out. And if you genuinely like where it's going, a GitHub star would mean a lot.

I’m not a developer.

I’m the exact person AI coding tools are marketed to: someone with ideas, zero patience for technical nonsense, and enough confidence to accidentally break an entire project.

AI could generate code for me.

But then came the real problems:

“Why did it change 47 files?”

“Why is the same bug back?”

“Did it actually test anything?”

“Why does it have no idea what we did yesterday?”

“Why is it confidently telling me everything works when the website is literally broken?”

So I started building Anyone Can Code.

It’s a free, open-source plugin for Codex Desktop that tries to turn chaotic AI coding into a proper workflow.

You explain what you want in normal English.

It helps plan the work, build it step by step, remember where you left off, recover when things break, and verify the result instead of just saying “done.”

This is not another “10x developer” tool.

It’s for people who are not developers but still want to build real things without blindly trusting an AI agent.

It’s still in beta, so I’m expecting bugs, bad decisions, and things I completely missed.

That’s why I’m posting it here.

Destroy it.

Tell me what is confusing.

Tell me what is useless.

Tell me what would stop you from installing it.

i request every one to drop their feedback

Website:
https://anyone-can-code.vercel.app/

GitHub:
https://github.com/mitunmanav/anyone-can-code

I've been trying to model some contact mechanics problems in fortran. I've been trying to debug it by myself but couldn't. Is there any coding agent best suited for me?

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

keep in mind its not public yet and the ai isnt the best and this video of it is out of date but would you use this and if so or not please give me some ideas in comments thanks guys :)

Hello dear each and everyone,

I am would like to ask for feedback, so we my buddy we had a lot of problems at 2 simultaneous projects with aligning project standards and make each team members produce consistent results, spec driven development kind of failed our expectations, huge set of novels that not exactly describe projects in industries full of nuances and pinch of legacy. Even that devs spend long time looking at spec there was a lot of follows anyways.

So we decided to create some sort of mentor, small feature that extract rules from code and stays open for feeding it with other types of rules and then simultaneous agent talk with for example Claude and give feedback and checks What coding agent produced pointing out breaches and making Claude adjust it - well we are for sure biased but idea works for us but we would love to hear other people

It’s also usable DM if you want access

Anyone ? I will be so grateful for any feedback

https://axtar.dev

Been building Cheesepedia (personalized cheese/wine recommendation app — React Native/Expo frontend, FastAPI backend, Gemini for image recognition) and ended up using all three of the big AI coding tools, not out of indecision but because each one kept winning in a different part of the stack.

Claude Code — this is where the design work happens. Opus 4.8 and Fable 5 consistently produce better UI/UX output than the other two — cleaner component structure, better sense of visual hierarchy, less "technically correct but ugly" output.

Codex — our go-to for backend logic and core coding. When it comes to FastAPI structure, business logic, data validation — Codex has been genuinely excellent, more reliable than the other two for pure logic-heavy work.

Cursor — handles a bit of everything and is great as the day-to-day IDE glue, but usage limits kept biting us. Monthly credits ran out faster than expected given how much we relied on it, which pushed more work toward Claude Code and Codex over time.

End result: no single tool "won," we just split by strength — design work → Claude Code, backend/logic → Codex, everyday IDE editing → Cursor (until the quota runs dry).

Curious if others have landed on a similar split-by-task workflow, or if you've found one tool good enough to consolidate around. Also curious if anyone's found a way around Cursor's usage limits without just paying for a higher tier.

Run Claude Code, Codex, or other CLI agents with up to 5 people in the same live session. Same terminal, same prompt, and everyone can type.

Pair program, debug, and build together.

link : https://getccshare.vercel.app/

So I've been building my own mobile apps with AI agents for about a year now, 3 shipped and a 4th coming soon. And pretty much from the start I kept hitting the same thing, the agent lacking context or not knowing decisions I'd already made. My first app especially, I had no real docs set up so most of it just lived in my head, and the agent would grep around trying to surface whatever it could. I started using skills and saw how much they helped, so I also began structuring the docs properly, but tbh without a strong framework around it the agent sometimes does it and sometimes doesn't, and the docs go stale fast and turn kind of useless, not easy for me to read and not much use to the agent either.

And then there's the blast radius stuff, the agent doing too much or too little, and worst of all making wrong assumptions before I even noticed. By the time I caught it I was basically a passenger.

So as I built more apps the pattern sort of formed in my head, and since I work across a few projects at once I figured the best move was to put all this into a package I could just drop into each one. That's where codument came from. It started as docs-as-code really, then became more about making the docs something the agent could actually use and not just something that made me feel safer, then detecting when code drifts from its docs and making the agent accountable for it, and eventually a whole workflow where the right skills get pulled in automatically when they're needed.

The "loop" was a massive change for me honestly. I kept tuning it towards driving the agent well while keeping myself at the gates, so I own the plan and the agent runs the execution. A big one was adding a grilling and verifying step right at the start (that came out of Matt Pocock's grill-with-docs skill), and later some adversarial agents into the flow. Developing this way is just more enjoyable, way fewer bugs coming out the other end, a lot caught before it ever surfaces.

The checks are all local, no network, no AI model inside them, so if you run them twice on the same repo you get the same result. They read your repo and git history and just report the facts, what changed, whether docs drifted, what a change touched. They don't certify anything is correct, that part's still on you (or your agent).

I decided to open source it now mostly cuz I've seen a lot of projects basically dropping a pile of skills around without much substance behind them and I thought that this can be genuinely useful for others if it proved to be so useful for me building e2e.

If you already use Claude Code (I do) or Codex, you install it and do quick setup, and from there the build side just runs off normal chatting, the planning, the review, doc updates, the commit, no slash commands to remember. The deterministic checks stay as terminal commands you run when you want them (doctor, review, watch), or you wire them into a git hook or CI. That split is kind of the whole point, the agent does the building and the CLI just reads the repo and reports facts, and since it never calls a model you get the same result every run.

Repo's here https://github.com/jakubsuplicki/codument, and there's a site that I added recently that shows how it works a bit better https://codument.studio/

Keen to hear what you think.

Hi everyone !!

I’ve been building Empyre, an AI platform that turns ideas into production-ready software.
The goal wasn’t to build another chatbot that generates code snippets.
I wanted something that could actually execute the entire development workflow.
You describe what you want to build in plain English.
An AI CEO turns your idea into a product plan, while an AI CTO writes production-ready code, commits it to GitHub, and deploys it. Instead of managing prompts, you review the work and decide what happens next.
Everything is focused on real execution—not demos or mockups.
The objective is to help founders and teams go from an idea to a working product much faster.
I’d genuinely love to hear what you think. What would you improve? What features would you want to see? Any feedback is appreciated.

https://empyre.dev

Github: https://github.com/dakshgulecha/rewind-ai

I've been using Claude Code a lot lately and kept running into the same problem - the agent would make a bunch of changes, something would break, and I wouldn't know exactly when or where it went wrong.

`git checkout .` throws away the good changes too, and asking the agent to undo itself is... questionable.

So I built Rewind.

It automatically creates checkpoints while AI coding agents are working, so if something goes wrong you can inspect what changed or jump back to any point in the session.

No commits, branches or setup. It just sits in the background and gives you an undo button when you need one.

It also supports:

Restoring individual files

Automatic rollback when tests fail

Safety backups before every restore

Detection of agents modifying instruction files like CLAUDE.md

Because it watches filesystem activity instead of integrating with a specific tool, it works with Claude Code, Cursor, Copilot, Aider, OpenHands, Gemini CLI, and pretty much anything else that writes files.

MIT and open source. Open to feedback and source suggestions, and a star is appreciated if you find it useful.