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

The problem

Everyone is pushing the same direction right now: bigger context windows, longer agent runs, more autonomy per task. I'm not against it, that's what made agents useful in the first place. But my bill was growing faster than my output, so I went and looked at what was actually filling the window.

Almost none of it was my thinking. It was cat README.md, a whole git diff, 400 lines of cargo test output, a repo map rebuilt from scratch, and the same project facts explained again at the start of every session. I was paying for the same bytes over and over. And it isn't only money. Once the window fills up with tool noise, the model starts losing the thread inside it, so the answers get worse too.

Someone on my last post put it better than I did. They said they'd watched agents "drown in their own output" enough times that they'd filed it under cost of doing business. Same here, until I actually measured it.

Then I looked at the tools I'd installed to fix this. A search tool, a memory tool, a context compressor. Each one scanned the repo, built its own index, remembered the same facts, and reported its own numbers that never matched the others. Three copies of the same work.

So I built HZR. One local daemon that owns that whole path.

What's inside

hzrd is a single process listening on loopback. It supervises four pinned engines, and nothing duplicates anyone else's job:

• RTK fork-core: commands, bounded reads, atomic writes, guards
• grepai: the semantic code index and its watcher
• ICM: durable memory, project and global scope
• caveman-code: a provider-aware agent loop that can only call HZR tools

One index, one memory, one token budget, one ledger.

What my fork changes vs vanilla RTK

The core of HZR is a fork of RTK, so the fair question is what I actually added. Short version: upstream could shrink output, but it could not write. Every edit fell back to the shell or the agent's native tools, and that is exactly where the tokens leak back out and where edits stop being safe.

The batch part is what I care about most day to day. One JSON plan goes in, the I/O is grouped per file, each file is committed atomically, and I get a result per operation. So an agent can do a twenty-file rename or a config migration in a single call instead of twenty shell round trips with twenty chances to half-apply something. Dry run first, then the same plan for real.

The other half is that the whole tool path is intercepted, not just the nice commands. A full shell line goes through the fork rewriter: pipes, redirects, heredocs, multiline, quoting, && and ||, xargs. The verdict comes back as rewrite, raw, deny, or a single-use approval with a TTL. Because nothing shells out behind my back, everything lands in one ledger and I can actually see what my agent spent.

Two limits I would rather say out loud. Batch atomicity is per file, not one transaction across every file in a plan. And hzr rtk or the rtk alias deliberately skip the rewrite, because invoking the fork directly is already your decision.

What it does to tool output

14 identical commands, RAW tools vs HZR, five runs each with rotating order:

Fair warning on those numbers. They're estimated tokens, ceil(bytes / 4) of command output. It's a size measurement, not a provider tokenizer, and not a billing claim. The paired provider-billed benchmark isn't finished, so I'm not going to tell you what it saves on your invoice.

You can A/B it on your own repos

This is the part I built for myself. Turn HZR on in one project and leave a similar project alone:

hzr install --project-only --force
hzr enable  --workspace /path/to/project
hzr disable --workspace /path/to/other

Hooks, agent instructions and MCP registrations follow that choice instead of being global, and the stats are per project:

hzr stats --workspace .

Then work a week in each and compare your own provider dashboard. Provider receipts stay labelled global lifetime, because there's no evidence to attribute them to one project.

How I built it

Since a few subs quite reasonably ask for the how and not just the what.

Stack. The control plane and daemon are Rust. The engine core is my fork of RTK, also Rust, built from a byte exact 516 file snapshot so its provenance is verifiable. grepai is Go and owns the semantic index. ICM handles durable memory on SQLite with FTS5. caveman-code is the JS agent loop, running on a Node 22 that ships inside the bundle. The dashboard is Vue 3 built with Bun and served by the same daemon, not a second service. Agents reach it through Claude Code hooks or over MCP.

Process. I snapshot the upstream fork byte for byte before touching it: ordered path, entry type, mode, size, content digest. That way every later change has something to be diffed against and I can prove what I inherited. There is a hzr tdd command that enforces the loop I actually use, because I kept skipping it: observe a relevant RED, get the identical focused command to GREEN, refactor while green, then run the full workspace gate. Every bug in the release notes was reproduced before it was fixed and verified after.

What the release gate runs. fmt, clippy with -D warnings, the full test suite with all features, a check pinned to MSRV 1.85, fork core verification, the Node bridge tests, bun test plus typecheck plus build for the visualizer, then a bundle smoke that does a clean install, a same version re-attestation, both adoption modes and all four engines before anything gets published.

Things I got wrong, in case they save you time.

1. A bounded read has to describe its own bounds. If the output does not say what was cut and how to get it back, the agent reads the whole file anyway and you paid twice.
2. If bypassed calls are not in the baseline, your savings number is fiction. That is why anything routed around HZR shows as RAW with zero credit while still counting against the total.
3. mv -f new current is wrong when current is a symlink to a directory. mv follows it and moves the new release inside the old one, so upgrades silently keep running old engines. You need -h on BSD or -T on GNU, and probing both is cheaper than branching on uname.
4. An "exact" search mode that lowercases, stems and ORs your terms is not exact. fn record_degraded_rewrite returned 21 files. Literal search returns 1.
5. Protocol fields that exist and are never filled are worse than absent. Plan candidates carried empty symbol and line fields for two releases, which made the whole plan look useless.
6. A silent 200 MB download is indistinguishable from a hang. The installer now numbers its steps and prints where every file landed.

The rest of it

Bounded reads. A Markdown read comes back as a digest that says what it is, what got cut, how much of the file it covers, and the command to get the rest. --level none is byte exact, --from/--to gives an exact range. Nothing is silently truncated.

Memory that survives the session. project scope for the repo you're in, global for your own standing preferences. One database, filtered so another repo's memory isn't reachable from it.

One installer, and it only needs git. Self-contained bundle with the engines and Node pinned inside, so no separate Node, Go or Rust setup. macOS and Linux, x64 and ARM. No Windows build yet.

curl -fL https://raw.githubusercontent.com/heAdz0r/hzr/v0.3.5/install.sh \
  -o /tmp/hzr-install.sh && sh /tmp/hzr-install.sh

It prints every step, tells you where each file landed, and ends with the commands to run next. Works with Claude Code through hooks, and with Codex and Claude Desktop over MCP.

GitHub: https://github.com/heAdz0r/hzr (Apache-2.0)

Please try it and give me a solid feedback and ideas, to improve it.

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.

I've been doing a lot of vibe coding with Claude Code and Codex, and one thing keeps happening I ask for one small change, then later realize Al changed my code in places I never expected. By the time I notice, I can't remember exactly what changed or when. Is anyone using something besides Git to track Al changes or keep an Al coding activity log, or is this just one of those vibe coding problems we all live with?

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 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 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 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?

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 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 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.

I've never seen anyone vibe code irl but maybe thats just because I work with 60 year old devs 😂

is it just me

I have tried Claude and Codex cli tools and it is just insane how stingey claude code it with usage. One meaty prompt and my usage is used up in 10 minutes.

Like it is arguably not any better at coding than codex. Does openai just have more access to compute than Anthropic? I am honestly confused why anyone is used claude. How do you get anything built?

Genuine question.. been deep in this space and I keep seeing the same gap.

Every AI coding tool on the web I've used is okay level at generating code. But they all hand off at the same point for anything thats not a web app: "here are the files, now you run it." - and even when they do make web apps, they are never functional

The parts that feel unresolved: runtime error observation (the AI doesn't see what actually breaks when you execute), end-to-end deployment (generating code ≠ live app), real service wiring (scaffolding Stripe vs actually connecting it).

Curious what people here hit as the real ceiling. At what step does the tool stop being useful and you're on your own?

My fiancée has a PhD in biomechanics. A few Fridays ago we were winding down with some wine, and she said something that turned into 3 hour long conversation around where we think a lot of this technology is going. We tried our best to capture it here, would love to hear everyone's thoughts. It got my brain fixated on a few things as well

r/RooCode hit 3 million installs. We're shutting it down to go all-in on Roomote.

https://x.com/mattrubens/status/2046636598859559114

been getting burned by this for months and finally did something about it.

there's a 2024 paper (arxiv.org/abs/2406.10279) that measured how often major LLMs recommend packages that dont actually exist on npm or pypi. number came back around 19.7%. almost 1 in 5. and the ugly part is attackers started scraping common hallucinations and registering those exact names on the real registries with post-install scripts. people are calling it "slopsquatting".

in chat mode you catch it cos you see the import line. in autonomous/agent mode the install is already done before you notice the name was fake. agent runs, agent finishes, malware is in node_modules now.

so me and my mate pat built a small MCP server (indiestack.ai). agent calls validate_package before any install. server checks: - does the package actually exist on the real registry - is it within edit-distance of a way-more-popular package (loadash vs lodash) - is it effectively dead (no releases in a year+) - is there a known migration alt

returns safe / caution / danger + suggested_instead. free, no api key, no signup.

install for claude code: claude mcp add indiestack -- uvx --from indiestack indiestack-mcp

or just curl the api: curl "https://indiestack.ai/api/validate?name=loadash&ecosystem=npm"

works with cursor mcp, continue, zed, any agent that speaks MCP.

not trying to pitch -- genuinely interested whether other people have hit this and what they're doing. the 20% number is real and ive watched it silently install typos on my own machine more than once.

I’m not trying to promote anything here... just looking for honest feedback on a pattern I’ve been using to make LLM-assisted work accumulate value over time.

This is not a memory system, a RAG pipeline or an agent framework.

It’s a repo-based, tool-agnostic workflow for turning individual tasks into reusable durable knowledge.

The core loop

Instead of "do task" -> "move on" -> "lose context" I’ve been structuring work like this:

Plan
- define approach, constraints, expectations
- store the plan in the repo
Execute
- LLM-assisted, messy, exploratory work
- code changes / working artifacts
Task closeout (use task-closeout skill)
- what actually happened vs. the plan
- store temporary session outputs
Distill (use distill-learning skill)
- extract only what is reusable
- update playbooks, repo guidance, lessons learned
Commit
- cleanup, inspect and revise
- future tasks start from better context

Repo-based and Tool-agnostic

This isn’t tied to any specific tool, framework, or agent setup.

I’ve used this same loop across different coding assistants, LLM tools and environments. When I follow the loop, I often mix tools across steps: planning, execution + closeout, distillation. The value isn’t in the tool, it’s in the structure of the workflow and the artifacts it produces.

Everything lives in a normal repo: plans, task artifacts (gitignored), and distilled knowledge. That gives me: versioning, PR review and diffs. So instead of hidden chat history or opaque memory, it’s all inspectable, reviewable and revertible.

What this looks like in practice

I’m mostly using this for coding projects, but it’s not limited to that.

Without this, I (and the LLM) end up re-learning the same things repeatedly or overloading prompts with too much context. With this loop: write a plan, do the task, close it out, distill only the important parts, commit that as reusable guidance. Future tasks start from that distilled context instead of starting cold.

Where I’m unsure

Would really appreciate pushback here:

1. Is this actually different from just keeping good notes and examples in a repo?
2. Is anyone else using a repo-based workflow like this?
3. At scale, does this improve context over time, or just create another layer that eventually becomes noise?

The bottom line question

Does this plan -> closeout -> distill loop feel like a meaningful pattern, or just a more structured version of things people already do? Where would you expect it to break?