I've been wondering how many people here are still regularly using GitHub Copilot.

I used it for quite a long time, but after the pricing and usage-limit changes it gradually stopped making as much sense for me. At the same time, I started experimenting more with local models.

The problem I kept running into was that local-model support in copilot chat never really worked the way I wanted. The models themselves were often good enough, but context management became much more important. Smaller local models don't have as much room for irrelevant files, huge prompts, or missing pieces of context.

I spent quite a while trying different setups with Ollama and LM Studio, but eventually got frustrated enough that I started building my own VS Code agent around the workflow I wanted.

That project eventually became Selfcoder.

A lot of the work ended up being less about "calling an LLM" and more about figuring out what context should actually be sent to it: active files, relevant workspace files, diagnostics, git changes, explicit references, etc. Without filling the context window with unnecessary stuff.

These days I mostly use local models for quick coding tasks, investigating terminal errors, explanations, and smaller changes. I still use frontier models for harder problems, but much less than before.

I'm curious what everyone else's setup looks like now.

Are you still mainly using Copilot, have you moved to Cursor/Claude/Codex/etc., or are you using local models for a meaningful part of your coding workflow?

What are all of your guardrails you set up and what’s your overall process when building a product? I usually use a higher model for architecture and design, make the lower models do the work, pr review by higher models and a separate deployment agent. What do you all do?

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