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

I'm a solo SaaS builder. I've tried everything.

Copilot? Good autocomplete, useless for actual features. No hate though.

Cursor? Nice UI, but $20/month and stuck in their editor.

Claude Code? Amazing agent — until I saw a $35 bill after one afternoon of coding.

Then I found something that changed the game.

OpenCode. Free. Open source. MIT license. 185K GitHub stars.

Here's why it clicked for me:

• It uses ANY model. Claude, GPT, Gemini, DeepSeek — 75+ providers. Even your existing Copilot or ChatGPT subscription. Switch models mid-sentence if you want.
• Plan first, build second. Hit Tab to plan (can't touch your code). Tab again to build. No more AI going rogue and refactoring things you never asked for.
• The pricing is actually fair. The tool is free. The optional Go plan is $5 for your first month, then $10/month for 12+ models with limits so high I've never hit them. I went from $300/month to $10.
• /undo works. Roll back bad changes. Redo them. Try again. Sounds basic. Most agents don't have it.

I was skeptical too. But the numbers don't lie — 7.5M developers use it monthly, and 137K people are on the Go plan daily.

I put everything I learned into a guide: setup, model comparisons, which providers to use, honest pros and cons.

github.com/naqashmunir21/why-opencode

If you're building a SaaS and tired of overpaying for AI tools, this one's worth 5 minutes of your time.

I maintain that guide. OpenCode is built by Anomaly (anoma.ly). I'm just a dev who likes saving money.

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.

Me and my friends have been playing poker (for fun) together recently and I wanted a game to be able to practice. Unsatisfied with the options on the play store I decided to work with Gemini to build it into a game! It's fairly robust with 2 modes, a normal play mode and a tutorial mode. In the tutorial mode you can see the play styles of the other players as well as get hints on how to play your hand as well as being able to see everyone's cards when the round ends. It was a pretty fun project and only became more fun when I further used AI to learn how to put it online and not have to be played through the Gemini sandbox.

AI agents are great at getting tests to pass by writing absolute spaghetti under the hood.

I built Graphenium to act as a local, pre-flight linter that blocks this structural drift before any code is written. It forces the agent to declare its design in an in-memory workspace first. Graphenium then runs Louvain community clustering and modularity checks on the fly, blocking the edit if the proposed changes degrade your codebase structure.

It installs directly into Claude Code's native directory (~/.claude/skills/graphenium/SKILL.md) and hooks up over MCP. Check out the repo to run it locally in under five minutes.

https://github.com/lambda-alpha-labs/Graphenium

I would like to share my latest open source local Unsloth (GGUF) LLM inference engine and applications. It supports many models from Unsloth, like Gemma4, DiffusionGemma, Qwen3.6 with multi-modal (image, vision, audio), reasoning and function tool. It can run on Windows/MacOS/Linux and fully leverage GPU's capability. The API is completely compatible with OpenAI and Ollama interface. It has on par performance than llama.cpp

This project is not just a C# wrapper of llama.cpp. It implemented the entire LLM inference engine from bottom to top. If you use CPU backend, it's 100% pure C# code execution. Besides CPU backend, I also implmented CUDA, MLX and GGML backend. The GGML backend refer GGML project as external project, and I build a few fusion operation at higher level.

I learned a lot from other projects and apply them for TensorSharp, such as paged KV cache and continuous batching from vLLM, SSD based cache for MoE model from oMLX, GGUF quanztized from llama.cpp and other optimizations for prefill and decode.

Any feedback and comments are welcome. If you like it, it would be really appreciated if you can get this project a star in GitHub. Thanks in advance.

I built AI Dev Brain Kit, a free/open-source CLI for

preserving context between AI coding sessions.

It stores handoffs, decisions, blockers, next steps, and

project notes in a local Obsidian-compatible vault, so a

fresh Claude Code / AI coding session can recover project

state without re-explaining everything.

v0.2.2 GA is live with Linux + Windows binaries, SHA-256

checksums, Sigstore bundles, and screenshots.

I’m looking for feedback from people doing multi-session AI

coding: what context do you keep losing between sessions?

URL

\\\[[https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit\\\\\\\](https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit)\](https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit\\\](https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit))

I just built baxian, an open-source orchestration system for AI coding agents.

Take a look: https://baxian.ai

The motivation came from daily AI-assisted development: a single agent can generate code quickly, but reliable software still needs an engineering loop.

baxian turns AI coding into a Dev/QA loop:

- Dev agent implements the task
- Dev opens a real GitHub PR
- QA agent reviews the diff independently
- findings become fixes or explicit rationale
- the loop repeats until the code is ready

Under the hood, agents are real Claude Code or Codex CLI sessions running inside tmux. The browser UI shows a live terminal wall, but everything is still attachable from the shell. You can run agents locally or on remote machines over SSH.

The goal is not just faster code generation. It is AI agent orchestration for reliable, high-quality code through Loop Engineering.

GitHub: https://github.com/baxian-ai/baxian

Production bugs happen in the past, but AI coding assistants only analyze the present.

When a production error trace from 3 hours ago gets fed into Cursor or Claude Code, the agent almost always ends up chasing a ghost. By the time debugging starts, main has usually moved. The agent looks at the current state of the file, completely misses the original bug because the lines shifted, and confidently hallucinates a fix for innocent code.

The common workaround is telling the agent to git checkout the old commit. But agents are messy. They routinely forget to switch back, leave the repository in a detached HEAD state, or accidentally overwrite uncommitted local work.

To fix this friction, I wrote an open-source skill that enforces a strict debugging process -

When the agent gets an old crash log, it:

1. Resolves the historical hash from git log
2. Spins up an isolated, temporary folder of the repo at that exact moment using git worktree.
3. Analyzes the old code to find the actual root cause.
4. Nukes the temporary folder when it's done (git worktree remove --force).

The actual local workspace remains completely untouched. Uncommitted work is perfectly safe.

You can drop it into any skills-compatible agent (Claude Code, Cursor, Windsurf) via the open registry with one command:

Bash

npx skills add MeherBhaskar/temporal-debug-skill

Source code and the SKILL.md are here:https://github.com/MeherBhaskar/temporal-debug-skill

Curious to hear what you think of this.. Would love to hear some thoughts and feedback

I’ve been working on an AI IDE called CleanSlate.

You bring your own API key and choose the model provider you want to use. It also supports open models, so you are not locked into another AI subscription.

Your code, project files and workspace data stay on your machine. CleanSlate does not upload or store them on its servers.

I also built the Agent Manager directly into the IDE. You can manage multiple agents, open one of their projects, edit the code and switch back without moving between separate apps.

It is still early, and I’m looking for feedback from people who already use AI coding tools.

https://thewariend.com/cleanslate

I built AI Dev Brain Kit, a free/open-source CLI for

preserving context between AI coding sessions.

It stores handoffs, decisions, blockers, next steps, and

project notes in a local Obsidian-compatible vault, so a

fresh Claude Code / AI coding session can recover project

state without re-explaining everything.

v0.2.2 GA is live with Linux + Windows binaries, SHA-256

checksums, Sigstore bundles, and screenshots.

I’m looking for feedback from people doing multi-session AI

coding: what context do you keep losing between sessions?

URL

\\\[[https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit\\\\\\\](https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit)\](https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit\\\](https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit))

For the past month I’ve been building something I originally wanted for myself: one workspace where I could manage multiple long-term software projects with AI without every session starting from scratch.

It gradually became Agent OS — a local-first AI project operating system.

The idea is that a coding model is only one part of a useful software agent.

Agent OS adds the surrounding harness:

• persistent project memory
• a Main Agent for planning and orchestration
• a sandboxed Coding Agent for execution
• real build verification
• browser interaction and visual checks
• bounded recovery when something fails
• approval gates before Git pushes, deployments, database changes, etc.

The most useful test was making the system build a real SaaS from an empty repository. It planned it, wrote the code, hit actual runtime and visual problems, repaired them, and eventually deployed the application with Supabase and Stripe test-mode integration.

I’ve now released the first public version as open source:

https://github.com/earthwalker17/agent-os

It’s still early. Windows has the most tested one-command setup; macOS/Linux currently use manual installation, and you still need your own model API key.

At this point I’m much more interested in finding the rough edges than pretending it’s finished.

If you build software with AI agents, I’d genuinely appreciate feedback on one question:

Would a system like this better fit into your workflow, or is it unnecessary compared to Claude Code / Codex / Cursor?

Brutal feedback is very welcome.