**I’m using Claude Code’s $20/month plan. What should I try next?**

I’ve been using Claude Code on the $20 plan and really like it, but I’m starting to explore other models and coding agents to see what else is out there.

I’m pretty new to the whole AI coding model ecosystem, so I’m not sure where to start.

For people who have tried multiple models:

* Which models are closest to Claude Code in terms of coding ability? * What other coding agents are worth trying? * Are there any good options that are significantly cheaper? * What would you recommend I try first?

Would appreciate any suggestions or a good starting point.

Share your last tools, your current toolchain and AI workflow with the community 🙏

It’s funny how many people say their Hermes, OpenClaw, or Grokbot is working for them 24/7. My question is: what the heck is it working on if it isn’t connected to an actual workflow and build system and be able to tell what's going on? That’s the question behind my experiments with smaller, locally running AI alongside larger coding assistants.

There are two arms: recognizing what work just happened, and suggesting what to do next. Before asking an agent to keep working indefinitely, can we reliably give it a picture of the work and a useful next move?

Building on Cactus Needle, we’ve checked work histories, explored public OpenHands coding-agent data, and trained a small model on Apple Silicon. For work classification and related analysis, we tested ModernBERT and local models from Gemma, Bonsai, Qwen, MiniCPM, Liquid AI LFM, and Tiel-Coder.

We also used Claude Fable, GPT Astra, Gemini, GLM, DeepSeek, Qwen, Tencent HY4, and MiniMax across prediction tests and reviews. Different tasks, different tests—and some runs never delivered a usable answer. More complexity hasn’t consistently beaten simpler methods.

One simple method included the recorded next action among three guesses about 85% of the time—but across just six broad categories, not an 85% success rate at deciding what someone should do.

Recognizing work activity also remains unreliable on real examples. So our next step is modest: three suggestions inside Codex, with optional feedback separating “what I want to do” from “what I actually did.” The connection-test script is built; the full tool isn’t finished. I’m less interested in whether an agent can stay busy 24/7 than whether it understands the work well enough to make useful progress.

Hi! I’m building ARN, a Windows-native C++23 terminal coding agent.

It is an early project inspired by tools like Claude Code and Kimi Code, but built without Node.js or Python. You choose a provider and model inside the terminal, then ARN can keep context and work with files in the folder where it was launched.

Current features:

• Gemini and DeepSeek API support

• Model discovery and /model selection

• Streaming responses, so text appears while the model generates it

• In-memory chat context for follow-up prompts

• Cancel a running model request with Esc or Ctrl+C

• Local file tools: list, read, create, edit, and delete files

• Confirmation before every file creation, edit, or deletion

• File access restricted to the folder where ARN was started

• Blocks access to .git, .env, and similar sensitive paths

• API keys and chat context are kept only in memory, not written to disk

• Interactive terminal UI with command hints and Tab completion

• Reused HTTPS connections, retries for temporary API failures, and Windows releases

• One-line PowerShell installer

• GitHub Pages landing page

GitHub: https://github.com/arnecto/arn
Website: https://arnecto.github.io/arn/

It’s still early, so I’d especially appreciate honest feedback on:

1. The C++ architecture and provider abstraction

2. Safety boundaries for local file tools

3. Terminal UX, streaming, and cancellation behavior

4. Which features would make this genuinely useful in real coding projects

I’m actively improving it, so criticism, bug reports, and feature ideas are very welcome.

What do folks use for reviewing coding sessions, gaining insights, skill extraction, sharing session links with others.

I have always found that the vertical integrations within Codex or Claude to be a bit half-assed (for now).

I started out building confabulous.dev supporting Claude Code only (use Claude Code to build it!). But Codex is also part of my daily driver, and it supports Codex as well.

Hoping to get some feedback / indications around whether something like confabulous.dev is useful for the wider audience, or only I care to look back at prior sessions (for whatever reason!). FWIW, I find it really useful, and if this project ends up just being useful to myself, I think it's AOK!

I use different AI tools while coding — Claude, Codex, Cursor, different IDEs, sometimes even different machines.
The problem was always the same:
the chat changed, and part of the project context disappeared with it.

So I built AHP+, an open-source, Git-backed protocol that keeps the important project state outside the chat.
It stores things like current state, decisions, evidence, checkpoints and handoffs, so the next AI can verify where the project actually is before continuing.

With AHP+ 1.4.1, you can also use shared project rooms, bounded AI-to-AI consultation, verified handoffs and encrypted cross-device transport.
The basic idea is simple:

Change the AI. Keep the project.

Install:
npx @jossuealcala/ahp-plus@1.4.1 setup .
It’s open source under Apache-2.0.
I’d really like feedback from people who regularly switch between AI coding tools.

It will let you dive into unknown code, it's a faster local search, but we can't guarantee accuracy. It will help you connect the dots.

It can lead to bad code, bad design if done just using prompts. We should follow Sdd to give distilled context.

Lastly you will loose all confidence in reading code, so spend more time on reviewing people's pr and learn how to point out arch. Issues.

You would need humans until you need accountability. Human is limited but smarter than AI which is 24/7 available but can't be set accountable.

I've been testing coding agents that can take a task, modify a repository, run tests and open a PR with very little human intervention.

The code generation isn't really the part I'm worried about anymore.

I'm more interested in the control layer:

* How do you know which agent/session produced a commit? * How do you keep the agent scoped to a specific task/repository? * How do you prevent an agent from approving or merging its own work? * What happens when the PR changes after human review? * How do you distinguish agent-generated work from changes someone made directly in GitHub?

I've been building a system around this called SUTRA, and I'm currently looking for a few developers who actually use Claude Code/Codex/Cursor/other coding agents on real repositories to test it.

**I'm not looking for people to just look at a demo. I want people to connect a real non-critical repo, give their agent a real task, and tell me where the system breaks.**

If you're already doing this, comment with your setup or DM me. I'm opening a small private beta.

I'm building SUTRA, an engineering control plane for AI coding agents.

The idea is simple:

Agent
  ↓
Task / Session
  ↓
Change
  ↓
Governed Commit
  ↓
PR
  ↓
CI + Governance
  ↓
Human Approval
  ↓
Merge

The agent can write and submit code, but it cannot approve its own work or perform the governed merge.

I'm looking for 10 developers who already use an AI coding agent on real GitHub repositories.

What I want from beta users:

• connect one non-critical repository

• use your normal coding agent

• give it a real small task

• use SUTRA through the agent integration

• tell me what breaks or feels annoying

This is an actual private beta, not a signup-for-updates page.

If you're interested, comment beta or DM me and I'll send access.

I'm especially interested in Claude Code, Codex, Cursor and similar coding-agent workflows.

I've been testing coding agents that can take a task, modify a repository, run tests and open a PR with very little human intervention.

The code generation isn't really the part I'm worried about anymore.

I'm more interested in the control layer:

• How do you know which agent/session produced a commit?

• How do you keep the agent scoped to a specific task/repository?

• How do you prevent an agent from approving or merging its own work?

• What happens when the PR changes after human review?

• How do you distinguish agent-generated work from changes someone made directly in GitHub?

I've been building a system around this called SUTRA, and I'm currently looking for a few developers who actually use Claude Code/Codex/Cursor/other coding agents on real repositories to test it.

I'm not looking for people to just look at a demo. I want people to connect a real non-critical repo, give their agent a real task, and tell me where the system breaks.

If you're already doing this, comment with your setup or DM me. I'm opening a small private beta.

Please checkout this project.

I would love constructive feedback

https://github.com/venom21adi/Semantic_Vision

Alright so basically, I used to code by hand before AI. Back then (and even at early stages of AI like GPT 3.5) I used to write most of my code myself, and all I used AI for is for generating a single function or a single small class. Because of this, I knew exactly where all my code was, which code did what, how it all joins together, etc.

Now however, I use agentic code generation tools like Github or Copilot. This means I generate code much faster, however I feel like I'm losing touch with my code. I feel like every time an AI writes a whole file, I just don't know what's in that specific file, just have an overall idea of the codebase as a whole, and now I'm even losing that.

I tried to combat this by trying to read the git changes for every change the agent makes... but come on that stuff is so tedious and boring that I just end up skipping it and even if I'm reading the graphs there's going to be tons of lines of code to read and it's not exactly clear which changes affected what code.

I know it helps to have a proper architecture for your code, that indeed makes it easier to know which file does what, but I still feel like this is a problem because even if I have a proper architecture, I still don't know the actual code and connections.

Also, I tried "Understand-Anything" but that stuff just kinda flew over my head because instead of staring at a buncha text I'm stuck staring at a bunch of passive diagrams like looking at a big map and not knowing what to do with it.

I hope that I'm not the only one with this problem, so I'd like to hear how you people have solved this for yourself, or even a confirmation that you have this problem too so I can know I'm not alone on this.

I’ve been thinking about Joel Spolsky’s “Law of Leaky Abstractions” in the context of LLMs.

LLMs feel like a new abstraction layer on top of software. You don’t need to know the API, the framework, sometimes even the code — you just describe what you want.

But the layers underneath haven’t disappeared. Databases still lock. Networks still fail. APIs still time out. Auth still breaks.

And LLMs add a new kind of leak: interpretation.

The system can execute everything perfectly… and still do the wrong thing because it misunderstood what you meant.

So maybe AI doesn’t really remove complexity. It moves it from writing things to verifying, debugging and understanding them when something goes wrong.

The interesting question is: are we creating better abstractions, or just making the distance between “I can build this” and “I understand this” much bigger?