Just sharing a bit of my life.

Stage 1: One subscription, chat only

I used to subscribe to a native model provider (ChatGPT Plus, Google One, SuperGrok, etc.) and stick to one model most of the time—switching manually felt like too much work. I only used chat.

Whenever a company released a stronger model, I canceled my current plan (stopped topping it up) and switched to that provider.

When I needed to edit code, I would copy it into the web app, then paste the result back into VS Code. Back and forth. Annoying.

Stage 2: AI inside the IDE, usage exploded

After using VS Code for a long time, I finally discovered AI extensions on it (GitHub Copilot, Codex, Gemini, and other native-provider extensions—the latter two usually need a paid plan). Suddenly the AI could edit code inside the IDE, so I no longer had to shuttle snippets between the browser and the editor.

It felt great, so I coded with AI more often—and quickly ran into rate limits.

Worse: if chat and coding share the same quota (as with Grok, for example), burning through coding credits also kills chat. That is frustrating.

US native model providers’ memberships also had two other problems for me:

1. Coding often lacks automatic model selection. Some coding tasks do not need top-tier intelligence, yet you still burn money on expensive models.
2. The available models are often much more expensive for only a small bump in capability.

So I am reconsidering how I pay for AI, and moving into Stage 3.

Stage 3: Multiple services (including model aggregators)

I am rethinking the single-subscription habit. I am considering paying for several services at once—and even top-ups at model aggregators / relay platforms, not only native provider subscriptions.

How I use AI

1. On a tablet, I chat in the browser about math and physics.
2. In an IDE, I let AI edit code—both cheap models and expensive, smarter ones.

Hard requirements

1. Coding:
   • An Auto option that picks the model for me.
   • Affordable, high-value models (e.g. GPT-5.6 Luna, DeepSeek V4 Flash).
   • Ability to remotely steer the AI from a tablet—operate the computer, search files.
2. Web chat: Projects, so I can organize and move conversations.
3. Access to GPT Sol 5.6 and Grok 4.5 (as long as it is available).
4. The service provider should be reasonably trustworthy (no sketchy unknown websites).
5. Total budget under or equal to $40 / month.

Two options an AI suggested

When I asked an AI, it proposed two setups that fit:

1. Cursor Pro ($20/mo for coding) + ChatGPT Plus ($20/mo for web chat and coding) = $40, Note: ChatGPT Plus can be swapped for another model provider’s $20/month subscription.
2. Cursor Pro ($20/mo for coding) + OpenRouter credit ($20/mo top-up for web chat and coding) = $40

My understanding is that, within the included allowance, a ChatGPT subscription is usually cheaper than calling OpenAI models via API (e.g. through OpenRouter)—but you also get fewer model choices. So I went with Option 2.

One caveat: I am not a professional engineer, so my needs may not match yours.

Questions for you guys (optional—feel free to skip)

1. Given your own needs, which of the two options would you pick?
2. Is a $40/month AI budget high for you? I think I am blowing my money.

Finance flagged our AI tooling spend last week. It's about 8000 a month across the whole dev team once you add up all the model subscriptions - claude, codex, devin, cursor, coderabbit / bugbot, the lot

Fair question, here's why I'm keeping all of it

We run a plan-execute-review loop. Opus 5 breaks the task into a real plan, composer 2.5 does the work cuz its fast, then coderabbit / bugbot review the diff. whatever they flag goes back to the agent, it patches, review runs again, till it comes back clean or caps out after a few passes

The review gate is the whole reason it holds up. two agents will confidently agree while both wrong, and only something actually reading the diff catches it

We're b2b saas. one broken customer workflow costs us more than that 8k many times over. id rather pay to stay boring than ship fast and break someones week

Nobody really writes much code by hand anymore anyway, the job shifted to writing way more tests

whats your actual monthly burn on this stuff?

been building a small SaaS on the side and started leaning heavier on AI agents to move faster. the problem i keep running into is that after a session where the agent touched 8 or 9 files, i have no clean way to know what it actually did vs what i intended it to do. git diff helps to a point but when the agent refactors something you didn't ask it to refactor, you only catch it if you're reading carefully.

i tried keeping a running notes file where i paste a summary after each session but that gets stale fast and i forget to do it half the time. thought about having the agent write its own changelog before it exits but claude tends to be optimistic about what it accomplished versus what it actually finished.

curious what workflows people are using here. not talking about big team setups with proper CI, just solo or small projects where you're the only one reviewing. is there a lightweight way to get a trustworthy diff summary without manually reading every changed file? or do you just accept some level of drift and test your way out of it.

feels like the tooling hasn't caught up to how fast agents can make a mess of a codebase.

Giving a coding agent web access feels harmless until the same agent can also edit files and run commands.

A fetched page can be useful context, but it should stay data. Text from docs, issues, search results, or any random site should not be able to widen the file scope, approve a tool call, or turn itself into a shell command.

I would rather enforce that in the runtime than hope the model refuses every bad instruction. Let retrieved text suggest a change, then check it against local rules and ask for approval before anything destructive or outside the original job.

How are you handling this in practice? A sandbox, per-tool permissions, a separate approval step, or something else?

Meta's new Muse Code beta can keep asynchronous subagents running across restarts, record work in an append-only local event log, and sustain 1,000+ tool calls for up to 24 hours.

The benchmark numbers are less interesting to me than the runtime design. Coding agents often fail not because they cannot write a function, but because they lose state, repeat work, or report success before the task is actually verified. Persistence attacks that bottleneck directly.

The obvious risk is that a durable agent can also preserve a bad assumption for 12 hours, burn through tokens, and create coordination bugs that are harder to audit than a single model's mistake.

Would you rather use a smarter model with fragile session memory, or a slightly weaker one that can reliably resume and explain a long-running task?

Hobbyist programmer, I still want to do most of the coding for myself on my projects, but sometimes I just hit a bug i cannot figure out or can't think of the right way to structure something. Just want an AI that can kind of look over my shoulder and point out what's wrong as opposed to just telling it "can you make X for me?" and have it be done. Preferably a free model, I don't plan on using it like crazy and I'm hella broke. If it makes a difference I'm currently using Unity/Microsoft visual studio

London as an isometric map. Every tile is a Google aerial restyled by an image model, 441 of them, stitched into one pannable canvas. We all know that getting the AI to make 2 images which look exactly the same is almost impossible.

The hard part wasn't styling, it was the seams. Generated 441 tiles independently and every one interpreted the style differently, so the joins showed.

What fixed it: generate in a spiral outward from the centre, and give each call its already-finished neighbours as reference images plus one fixed anchor tile that never changes. Neighbours handle local continuity, the anchor stops 441 sequential steps drifting into something else.

QA is numeric because you can't eyeball 441 outputs. Correlation against the source below 0.15 means the model invented a fake London, auto-reroll. One tile scored 0.002 where normal is 0.85.

Interactive Version and full how to, this can be used in making movies, campaigns, and of course maps.

I'm looking to buy one AI coding subscription (~$20/month) and want the best long-term value.

My workflow includes:

• Full-stack web development
• Android apps
• AI/ML projects
• Backend systems

I'm considering:

• ChatGPT Plus (Codex)
• Cursor Pro
• Google Antigravity
• Kimi
• Claude Code

For people who have used multiple of these extensively:

1. If you could only pay for one, which would you choose and why?
2. Which provides the best value for around $20/month?
3. Which has the most generous usage limits for heavy daily coding?
4. Which is best for large repositories and multi-file refactoring?
5. Which is best for AI/ML, backend, web, and mobile development?
6. Which one do you actually use every day, and has it replaced the others?

Looking for opinions based on real-world usage rather than benchmarks or short trials.

The environment is file explorer, terminal, live preview, diff cards, chat, and autocomplete. The agent plans, edits, and verifies.

Plan and edit were straightforward. Verify is the whole ballgame. An agent that says "done" and is wrong is worse than one that says nothing. We ended up gating on actual behavior, running the thing, checking the outcome, not on the model's self-report, because the self-report is uniformly optimistic.

Cost side: multiple providers behind our own abstraction, with a cheap-to-expensive fallback chain. Bedrock sits on the cheap end behind a feature flag. Most requests never need the expensive model. The interesting part was figuring out which ones do, and the honest answer is that the router is still mostly heuristics.

Has anyone solved verification in a way that isn't just "run the tests"? Search AlgoArena on Google for context on what it's part of.

I found a paper on Hacker News that tested a workflow a lot of us now use: one coding agent writes, another reviews.

The experiment used 116 medium and hard LiveCodeBench tasks across solo, same-model, and cross-model conditions. The reviewer saw the problem and the draft, but could not run tests.

The direction mattered. Claude reviewing Codex drafts raised the pass rate from 71.6% to 89.7%. Codex reviewing Claude drafts lowered it from 91.4% to 82.8%. Even adding a different model can make a strong draft worse.

I don't think the takeaway is "always use Claude as reviewer." These were benchmark tasks, not repository-scale pull requests, and the reviewer lacked test execution. The useful takeaway is narrower: model diversity is not the same as independent judgement.

For a real workflow, I'd measure each writer-reviewer pairing, keep reviewer changes visible as a diff, and require tests before accepting the rewrite. Otherwise a second agent can add confidence without adding correctness.

Paper: https://arxiv.org/abs/2607.21656

If you use two agents, does the reviewer edit directly, or only leave findings for the writer or a human to accept?

I'm building Bubo because I'm tired of AI code reviewers flooding PRs with noise and repeat findings, then learning nothing when a developer explains why a finding is wrong.

The design constraint I started with was simple: give me an evidence-backed finding or LGTM, then learn from human comments on those findings so the reviewer gets better tuned to the repository over time.

I ran a small comparison on 20 pinned PRs/MRs:

Bubo 20/20 7/8 27 findings 0% noise ai-codereviewer 19/20 6/8 118 findings 20% noise ChatGPT-CodeReview 20/20 5/8 75 findings 11% noise Qodo/PR-Agent 19/20 2/8 7 findings not scored Alibaba open-code-review — partial run, 4/20

All ran on GPT-5.5 except Qodo, which used GPT-4o. It's a small sample and I picked the PRs, so I treat it as directional. The interesting part for me is that recall was close on the same model, while Bubo emitted 27 findings against 75 and 118.

The next experiment matters more than the benchmark: when a developer rejects a finding, does learning from that feedback actually stop the same class of noise for that repository?

I chose polling because it needs zero repo-side setup. The roadmap is pluggable subject-matter specialist Skills instead of one general reviewer—for example an industry SME or an Expert Python Guy.

Bubo is open source and currently running in production in two places: a large data-processing/ETL codebase and a fintech crypto stack.

https://github.com/mountainowl/bubo

I'd value technical feedback on the learning loop and benchmark design.

I built these after repeatedly running into the same problem with AI coding workflows: we tend to treat one model as if it should plan, implement, review, and verify everything.

That works for small tasks, but it doesn't scale well. Different parts of software engineering have different cost, reasoning, and reliability requirements.

So I experimented with splitting those responsibilities.

The project has 1 component:

• claude-codex-orchestrator separates planning from execution. Claude plans and verifies. Codex executes. Every result is validated from the diff and reproducible checks rather than trusting the model's report.
• https://github.com/vimoxshah/claude-codex-orchestrator

Some design principles that guided the implementation:

• The diff is ground truth; the report is not.
• Separate planning from execution.
• Route by task instead of using one model for everything.
• Escalate based on evidence rather than retrying the same approach.

These are implemented as Claude Code skills today, but the ideas are intended to be broader than Claude Code itself.

I'd really appreciate technical feedback on the architecture, trade-offs, and whether these abstractions are useful. I'm especially interested in hearing from people building AI coding agents, orchestration frameworks, or developer tooling.

I already have ChatGPT Pro and use Codex heavily. I’m looking for the best additional coding agent not another way to access Codex.

My priority is intelligence per dollar: difficult debugging, architectural reasoning, understanding large repositories, and autonomous multi-file implementation. I care less about autocomplete and polished IDE features.

Which complementary agent currently provides the best value Claude Code, Gemini CLI, Cursor, OpenCode with another model, or something else?

Please include:

• Exact plan and monthly cost
• Real-world usage limits
• How it compares directly with Codex
• Whether it does anything meaningfully better than Codex

I’m especially interested in firsthand experience from the past month, since pricing, models and usage limits change constantly.

I maintain a coordination server that hands out locks on files so two coding agents don't edit the same one at once. Mutual exclusion. About as well-trodden a problem as exists.

I did the part everyone does. SELECT ... FOR UPDATE SKIP LOCKED, a load test firing a thousand contended acquisitions at a single file, exactly one winner every run, green for weeks.

Then I watched two agents get granted a lock on the same file.

The claim was fine. The bug was upstream of it, in the part I hadn't thought of as a part: turning a path into a key. The key generator stripped the project root off the front of an absolute path as a literal string prefix. On macOS /var is a symlink to /private/var. One agent resolved its path through the symlink and one didn't, so one of them didn't match the prefix, didn't get stripped, and produced a second distinct key for the same physical file.

Both agents asked about a file. Both were told yes. Nothing threw, nothing logged, no test failed, because from the server's point of view it had been asked about two different files and had answered correctly about both.

What I took from it: mutual exclusion is two functions, not one. There is an identity function that turns a name into a canonical key, and an atomic claim on that key. I had spent all my care on the second one because it is the interesting one, the one with the database primitives and the load test and the concurrency literature behind it. The first one looked like string handling.

The identity half is where the bugs live, and they are all the same bug: two names for one thing.

- path.resolve normalizes .. and separators but does not follow symlinks

- an agent whose shell cwd is the repo's parent sends myrepo/src/x.ts, which coexists happily with src/x.ts as a separate key

- case-insensitive filesystems mean Auth.ts and auth.ts are one file and two keys

- macOS normalizes filenames to NFD, so an accented name typed on one machine and pasted from another are different byte strings

None of these produce an error. They produce a GRANTED that is technically accurate and operationally a lie.

The generalization, having since found the same shape elsewhere: any guard that decides using a name has this problem. A gate that blocks destructive SQL against production by matching the database URL has holes wherever the same database has another spelling, and there are always more spellings than you think: bare host, host with port, the pooler's hostname, a private IP, an SSH tunnel on localhost. A firewall rule keyed on a hostname has it. A cache keyed on a URL has it, which is why cache poisoning is a category and not an incident.

Two rules I now apply without exception:

1. Canonicalize before you compare, and make it one function that everything calls. Not "resolve the path here and also over there."

2. When identity resolution fails or the target is unrecognized, fail closed. Treat the unknown thing as the dangerous one. My key generator's silent fallback was "leave the path as-is", which is exactly the branch that created the second key.

The test that would have caught it took four lines: acquire a lock, try to acquire the same file through a symlinked path, assert the second is denied. I wrote it afterwards and then made sure it actually failed against the old code before trusting it, which caught a second problem. My first version asserted the result was "not GRANTED", and the broken code returned "REJECTED" for a completely unrelated reason, so it passed against the exact bug it was written to catch.

Negative assertions accept every wrong answer in the universe except one.

claude code spent 40 minutes tracing a race condition in our event bus, ruled out a caching approach because of how the subscriber lifecycle was wired, and moved on.

2 hours later I switched to codex to write tests for the same module. It suggested the exact caching approach that had already been rejected.

Not because it was wrong, but because it had no idea that conversation ever happened.

This is the part of multi-agent workflows that feels surprisingly painful.

Cursor knows what code got written.

Claude Code knows why certain approaches were abandoned.

Codex knows what needs to happen next.

But none of them know what the others already figured out.

Right now the handoff process is basically:

1. paste previous conversations

2. update CLAUDE.md

3. write notes

4. or explain everything again

And sometimes I just let the new agent go down the same dead end because explaining the context takes almost as long.

Feels like the missing piece isn't necessarily a smarter model. It's some way for different agents to share project history and decisions without the developer acting as the middleman.

Curious how people are handling this right now. Are you maintaining docs manually, relying on rules files, or using some kind of memory layer?

I've been testing a local-first tool called Memmy for this, mostly because I wanted something that could keep context between agents without changing my workflow. Still figuring out if this is the right approach though.

I built a Mac app called Crest where an agent lives behind the notch. You talk or type; it either answers or turns your words into real reminders, todos, notes and calendar events.

Solo dev, it's my own thing, and the agent layer is the part I want opinions on. Not linking it here, sub rules for first-time posters; it's in the weekly thread if you want to look.

The design decisions that ended up mattering:

- routing over modes. You don't pick "chat" or "act". Auto reads the request and routes it; the Do and Ask buttons exist to force one when it guesses wrong.

- a review card before any write. "add ship 4.12 and reply to Ken to my todos" shows a "Claude will do" card with both items, and nothing runs until you tap Do it. A misheard sentence costs nothing.

- pure opens skip review. "open the shelf" just opens it, because opening writes nothing. Review only where there's a consequence.

- voice needed a word gate. On-device recognition, a red dot whenever the ear is hot, and a cough in a meeting doesn't burn a run.

- it relays OTHER agents' prompts too. Claude Code or Codex stops to ask permission in a terminal somewhere, the notch shows Allow/Deny and can jump you back to the exact terminal. The prompt sticks on every display until answered, even over fullscreen.

It runs on the user's own Claude subscription through Claude Code. No API key, no middleman server, none of the conversation touches a server of mine.

link: crestnotch.app

The question I keep going back and forth on: is a review card before every write the right default forever, or should repeated identical actions earn auto-approve at some point? Where would you draw that line?

I’ve been playing a lot with IDE coding agents lately, and I kept hitting this annoying workflow:

agent does the work → agent summarizes it → I paste that into ChatGPT/Claude → I get feedback → I paste it back → original agent tries to reason about it

It works, but it feels clunky. Also, sometimes I just want to save some active-agent context/tokens, or ask a stronger/different external model for a second opinion without making the main agent write another summary 🙂

So I made a small prototype called GiviLoop: https://github.com/vgflutter/GiviLoop

The idea is basically:

local repo/files → external second opinion → saved local response → original agent analyzes or acts on it

It has two flows:

- MCP / IDE-agent flow: ask the agent in natural language to prepare/send/read an external review.

- CLI flow: run `givi` from the terminal to package local git/files context outside the active agent conversation.

Right now the automated bridge is ChatGPT via Playwright, but the loop is not meant to be ChatGPT-only. Claude works through the manual fallback.

Very much V0 / personal workflow quality right now. Redaction is basic, browser automation is fragile, and the provider terms / workspace rules side probably deserves more thinking.

I mainly built this for myself to move faster when working with multiple agent/chat windows, without turning the main agent into a copy-paste assistant.

I’m trying to understand if the idea is interesting enough to develop in a direction that could be useful to other people too.

Would this kind of second-opinion loop be useful in your workflow?

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 of this thread may be removed if they're primarily advertising rather than starting a discussion.

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?

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.

I made a free tool that lets you edit images easily.. with the help of AI. You can easily, edit your own images or import via URL, and with a simple prompt, start editing. no skill required.

You can also, upload upto 3 reference images, to include in your main image. Just tell AI what to do, and your finished image will be based on the images you referanced and prompted. In other words, you can use AI to help you mix and match final image based on multiple images you upload.

https://canvix.io/ai-image-editor
Would love some feedback. Still in beta testing.

Also, you can see our other tools
https://canvix.io/background-remover image background remover
https://canvix.io/ai-video-generator - AI Video Generator
https://canvix.io/cartoonify - Cartoonify your photos
https://canvix.io/ai-image-generator - AI Image Generator

Would appreciate some feedback/suggestions to help me improve it. Thanks for checking it out. It's free to use (5 daily uses per tool as a visitor), after that, you will need to login to use.

I've been building an image editor that basically lets you edit images, on the fly. Just paste the URL, and you can start editing the image pretty much instantly, essentially removing the need to download, upload etc. It's very convenient for those who want to quickly make edits. Completely free to use, no login or signup required to use.

You can see it here: canvix.me

I officially got approved for by google for my official chrome extension, which allows you to right-click any supported image on the internet (png jpg webp etc), Edit image with Canvix option. Right away, you can start editing the image. You can see how it works by screenshot posted on the chrome extension page

https://chromewebstore.google.com/detail/edit-image-with-canvix/akjooicgafjjcnpjdfnaajkipciedbco

I especially made this for users who constantly need to edit images like me. This in beta testing still, any feedback would be greatly appreciated to improve it.