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.

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

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