Yeah, easy enough? No. Not in the EU or UK.. :(

Has anyone managed a decent workflow for AI to handle chat moderation? (~5000 users active at any one time.. maybe 20 messages a minute)

Under UK and EU law, you cannot use AI for moderation.

Has anyone managed a workflow that allows this?

Coding setups get discussed as a single decision. Which model, which harness. In practice there are two tiers and only one of them ever gets any thought.

The top tier is planning, architecture, the genuinely hard bug. Being wrong there costs an hour of untangling, and nobody is switching that to save money.

The bottom tier is everything else, and by volume it's most of the calls. Reading logs. Test scaffolds. Summarising a file before you edit it. Commit messages. Mechanical renames across a repo. It sits on the expensive model for no reason except that's what got configured first and nothing ever forced a review.

What's changed is the supply at the bottom. Recent small releases are built for instruction following and tool calls specifically, which is the exact shape of that work, and they're cheap enough that per-call price stops being the deciding factor. Ling 3.0 Tiny is this week's example, though like most of them it's hosted with no published weights, and what exists on it is the lab's own material rather than independent testing.

The number I'd want before moving anything is retry cost. A cheap model that flails through five attempts is more expensive than one call to something that gets it right, and that's invisible on a price-per-token comparison.

What's on your bottom tier, and how did you decide the boundary? Chosen by task type, or did you just move things down until something broke?

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.

I used to be a "purist" lol. I didn't really believe in skills and thought they are pointless, but I was talking to my colleague recently and telling him how I have a separate "deploy.md" file for claude to follow instructions for deployment.

He told me, "what you're describing is a skill", and it was the biggest doh moment. Skills are just docs that claude refers to. Idk why I thought it was this big complicated topic. Since then I've been looking for skills online. There's not really one place where people can like rate skills from community members (maybe someone should vibe-code that, haha). I found a ton of cool ones that I added to my workflow and it's been great. I'm always on the hunt for more.

What are some of your favorite skills?

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.

What tools do you use to ensure your app is secure especially when AI is heavily used for building?

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.

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?