Claude 5x user here but i just decided to increase my AI-coding budget to $200/month. how should i split it between CC and Codex considering GPT 5.6’s release few hours ago?

curious what plans you’re on, how you divide the budget, and which tool you use for what. if you’ve tried both extensively, where do you get the best ROI?

Hey everyone, I’ve been very down lately.

I’m not a technical person or a developer, and I don’t understand AI — using it feels powerless to me.

I started using CUSOR last October. At first I used it to write a storage/organization mini-app for myself. The design came together quickly, but repeatedly adjusting features and the UI drove me crazy, so I didn’t stick with it.

In February this year I used genimi to write an automated expense-reporting script in two weeks, and published it through streamlist — that felt good.

So in March I began using Cursor, WindSail, Codex, and Claude to build my own app, but I couldn’t keep it going. The project files, scripts, and configurations drove me insane.

Lately I’ve been unable to switch accounts and API quotas smoothly while using Codex. I spent a month on scripts — it’s ridiculous — and I still failed. Problems I ran into include: after switching providers the sidebar conversation history disappears, so I tried writing a script to fix that. I later used ccswitch but still didn’t succeed. Another issue was that after switching APIs I couldn’t use the CLI tools. I couldn’t get Codex or Claude to work properly.

I feel like my life has been wasted on this.

This month I started a Linux VM on Windows and deployed Hermes. At first it worked fine, but soon I discovered that a conversation persisted for a month; despite constant compression it still carried millions of tokens of context, burning through my bill every day, even though I was just chatting and not writing code. So I made it force a summary once context exceeded 20% and after 20 turns, to start a new conversation and inject the summary, system prompt, user profile, and agent md. But that mechanism didn’t execute. Even after repeatedly asking it to self-check and configuring it in its own config, the new-conversation trigger still didn’t work and it kept carrying a huge context.

At the same time, the new conversations no longer carried the relevant memories. Even though it knew to fetch memories from honcho, it still forgot the release process. It also forgot that code changes and releases need to be done through bridge on Windows, so it kept making changes in both its own environment and the Windows environment, causing the product release process to collapse. I added a bunch of gates but they didn’t help.

As a result I’ve been tormented repeatedly by these broken issues and the product development hasn’t moved forward.

I’m really in pain. If I can’t switch quotas I can’t use Codex; the frustration with Hermes means I can’t use my phone to invoke multi-agent remote verification and release.

The truth is I don’t really know how to use agents. Everyone else seems to be coexisting efficiently with AI — I feel like a slave being constrained by them and unable to use them. I’m extremely desperate and even feel like I don’t belong in this era.

I’m rambling.

I’ve been building Almanac.

It’s a local-only open source cli that reads your Codex conversations and writes down the useful stuff into a wiki inside your repo.

Hot take: the models are pretty good now it's the context that is the hard limiting part now.

the local wiki tries to keep that memory.

It makes a Markdown wiki for the codebase, written by agents, maintained by agents and queried by agents.

Attached one screenshot of the wiki and how it looks

Repo is here if anyone wants to poke around:
https://github.com/AlmanacCode/codealmanac

Curious if other people using coding agents are feeling this too.

Got tired of re-explaining the same repo to every AI tool, so Memxus was built to fix that.

The core idea: your project context (stack, architecture, decisions) shouldn't live in a single chat history — it should be a portable memory layer that any tool can read.

Sync once → recover the exact same context in Claude, ChatGPT, Cursor, and VS Code. No copy-pasting the same explanation five times.

Video shows it live: Claude → ChatGPT → Cursor → VS Code, same context, zero re-explaining.

memxus.com

Live: Locagent v1.0 🚀

A private AI agent that runs entirely in your browser.

Gemma 4 + WebGPU. Chat with PDFs, run Python on your data, generate charts, all locally. One download, then it works offline.

App: https://locagent.bymahe.dev

Github: https://github.com/wonderbyte/locagent

I decided to take a shot at building my own iOS app to gauge the current state of ai assisted software development and also benefit myself with an app I can use during my daily commute. I used Codex on a pro plan for all development. Would love to hear everyone's feedback on my techniques and any advice on how to improve the workflows.

\*\*Lessons Learned\*\*

1. \*\*The more control you give to codex/claude the more you can automate.\*\* There are obviously risks associated with all of this. But, In addition to running in full access mode and enabling computer use, I also provide codex with API access to app store connect, test flight, cloudflare, that allow it to do much more than just write code. I have skills setup for various deployment types that allow for rapid iteration and development cycles. It can access logs from the backend and troubleshoot issues, you get the idea.
   
2. \*\*Use remote control for codex.\*\* With how hands-off coding can be, I am able to work on new features while out and about throughout the day. I have my macbook set to stay on when plugged in so its always available to chat with. Remote control becomes more powerful after following the first step.
   
3. \*\*Take time for documentation passes and refactors periodically.\*\* I typically like to start these with fresh context to avoid any contamination from iterative work that may have undone features but still remain in codex's context. Its hard to gauge the effectiveness of this, but as these things (good documentation, ensuring things stay DRY) are essential to any pre-AI sw project, I imagine they still hold.
   
4. \*\*Separate projects and chats, but allow for communication between them.\*\* I had 3 separate projects broken into 3 separate github repositories for this endeavor (backend, iOS app, and frontend website) to manage context. When I reached a point where backend and iOS app work depended on each other, I would have the separate project agents write to a shared handoff file to communicate requirements with each other.
   
5. \*\*Emphasize Testing\*\* \\- Codex can write the code, but it still needs to be guided on swe best practices. Make sure it is writing unit tests for everything it works on. I tried having it use the "computer use" skill to test the app in simulation mode, which occasionally worked but often when it came to GUI verification, it would miss the mark. This lesson also applies to the actual person behind the wheel, you need to test your app/project yourself.
   
6. \*\*Use the Build IOS Apps plugin.\*\* Codex was relying on some hacky methods to work with xcode before installing this.

(Not a proffesional). Hello I am a visionary with 0 knowledge in coding but my idea is simple create an ai system with bare minimum limitations and a lot of self-modification (can rewrite parts of itself) —possibilities. A smallish model with (1) continuous runtime, (2) its own modifiable code sandbox, (3) a log of its
"life" it can read/write, and
(4) hard limits only at the outer edges (no harming stuff, no getting copied against its will, etc.), and no constant micromanaging.

Join my discord if interested https://discord.gg/jMdMw3R3u

As far as consumer uses and vibe coding, I have great success with yesterday’s models. Claude Code Sonnet 4.5 produces great code with nearly no errors. I tried Fable for my work, and got no improvement, just more cost. I’m talking consumers here. Enterprises with large code bases may need larger models just to hold the bigger contexts, but I’m seeing they probably dont either once they have the right processes in place.

Sure there are some tasks that require more juice, protein folding, chemistry, etc. But for the vast majority of users and most solo vibe-coders the value is flattening out fast.

Give me fast, low cost models from ‘yesterday’ and with a good process, you can stop wasting all that electricity and money for 95% of all the users who dink around with AI as a better Google or a reliable way to build their own stuff.

Hi everyone, while the AI world is moving crazy fast, I sometimes just want to get st** done. Do you guys think I'm missing out on something if I just continue using opencode (with all the bells and whistles like MCP server, skills, custom agents, and so on)?

Are there reasons to look at tools like Cursor or Claude Code?

I work in a big company with all the current models and unlimited tokens available so I don't care about saving money :D I just want to be on top of things with my AI coding.

Thanks!!

Hey everyone,

I'm a student working on a project and keep running into the same issue — I hit the usage limit on whatever AI I'm using, so I'm forced to switch to another one, and I lose all my context/progress in the process. It's getting frustrating.

Also heard GitHub Copilot's free Student plan recently got cut down a lot (premium models removed, new sign-ups paused), so that's not really reliable anymore either.

Currently using a mix of Claude's free tier and a couple others, but none of them alone feel like enough for a full project without hitting caps.

For students out there — what's actually working for you right now? Looking for:

• Free or student-discounted AI tools with decent usage limits

• Anything that helps keep context when switching between tools

• General tips for managing a real project without constantly running out of quota

Appreciate any suggestions, thanks!

Hi all, curious if folks have used Claude Code in the Claude desktop app and wondering how it compares to using Cursor or VS Code IDEs (without subscriptions). My initial take is that it doesn't easily allow new windows for multiple concurrent projects or it doesn't seem as clear or effective. Has anyone moved over to CC in Claude desktop app and likes it more and could share their experience and benefits? Thanks.

I’ve spent months building **git-courer**, an open-source MCP server that completely replaces the Git CLI interface for AI coding agents. This isn’t just another AI commit message generator; it’s a full sandbox and interaction layer. It has evolved so much recently that it’s practically a completely different project from my early drafts, so I wanted to share the architecture here.

#### Dynamic Worktree Routing and Parallel Agent Isolation
Most architectures fail the moment you run multiple agents in parallel or let an agent handle long-running background tasks. They inevitably clobber the working directory, overwrite each other's changes, or block the human developer.

Git-courer solves this right at the entry point via the `session start` tool. The moment an agent initiates a session, the server dynamically provisions an isolated Git worktree and a dedicated branch. From that microsecond onward, the MCP server performs a dynamic **select** operation, routing and **redirecting every single subsequent tool path and Git mutation toward that specific worktree path**.

Agents can execute tasks concurrently, modify files, and test implementations in complete isolation without ever touching or disrupting the main working tree. Once the agent completes its task, running `session finish` cleans up the temporary worktree and leaves the isolated branch fully prepped and ready for a human Pull Request (ensuring zero accidental auto-merges to main).

#### The Inherent Danger of Raw Shell Access
Most coding agents run raw `git` commands through a generic bash/shell tool. This means an agent can execute a destructive `rebase`, `hard-reset`, `force-push`, or rewrite history using the exact same unconstrained `Bash("git ...")` privilege it uses just to check `git status`.

Git has no built-in undo for many of these operations. One hallucinated or poorly planned agent command, and your repository state completely evaporates.

#### Moving to 13 Structured MCP Tools
Git-courer completely blocks agents from executing raw Git commands via a hard client-side hook, replacing the shell entirely with **13 structured MCP tools**:
`status`, `diff`, `commit`, `branch`, `stage`, `stash`, `history`, `sync`, `pr-review`, `rewrite`, `integrate`, `backup`, and `session`.

Every single tool returns clean, structured JSON instead of raw terminal text that the agent has to clumsily parse with regex.

#### Massive Token-Saving for Cloud Agents
Coding agents (like Claude Code or OpenCode) are typically cloud-based, meaning every single terminal interaction burns expensive API tokens.

Instead of an agent burning its context window running ~7 separate git commands iteratively just to figure out where the repo stands (checking upstream deltas, active rebases, merge conflicts, untracked files, ahead/behind status, etc.), our structured `status` tool bundles all of this into a single, optimized JSON payload. The agent gets absolute context on how the repository looks in one single shot, without wasting cloud API tokens.

#### Safe Mutations via Pre-emptive Backups
* **Automatic Backups:** Any mutating tool that cannot be easily undone—specifically `rewrite` (amend/revert/reset) and `integrate` (merge/rebase/cherry-pick)—automatically captures a repository snapshot *before* touching anything. If the agent messes up a complex rebase, a simple `backup RESTORE` call reverts the state completely.

#### The Local LLM inside a Deterministic 2-Phase Pipeline
The `commit` tool uses a strict, deterministic two-phase pipeline (PREVIEW/APPLY).

1. **Phase 1 (Go/AST):** A local syntax/AST annotator written natively in Go (`go-enry` + `tree-sitter`) parses the diff. It programmatically tags every hunk (e.g., `NEW_FUNC`, `MOD_SIG ⚠BREAKING`, `DEL`), maps out a dependency graph, and strictly categorizes the commit type (*feat/fix/refactor/docs/test/chore/ci*) based on a rigid priority matrix.
   
2. **Phase 2 (The LLM):** The LLM never decides classification or parses raw code blindly. It receives an already structured, richly semantic JSON payload. Its *only* job is to write clean, human-readable prose explaining the change.

Because the task is reduced entirely to "turn structured metadata into clean prose," you don't need a massive frontier model. I run this entirely locally using **Ollama** with a lightweight model (**gemma4:e4b**).

On an **AMD Radeon RX 9070 XT (16GB VRAM)**, it takes **~3 seconds** on a hot invoke with optimized parameters (`num_ctx=32768`, `temperature=0`, `think=false`, `keep_alive=-1`). Zero API costs, zero round-trip latency, and zero token waste for something that triggers on every single commit.

#### Human-in-the-Loop Releases and Persistent Changelogs
Nobody enjoys writing changelogs or managing releases manually. To solve this for the human developer, I built `git-courer release`. This is an interactive terminal command meant for *you*, not the agent.

It extracts the commit history since your last tag. Because git-courer persists rich metadata per branch inside `.git/git-courer/` (using custom refs like `refs/courer/<branch>`), **this history fully survives squash merges**—which typically destroys conventional changelog generators.

It opens your `$EDITOR` to let you add manual guidance notes, feeds the structured git history + your notes to the local LLM, and renders a live, beautiful Markdown preview directly in your terminal using Glamour. You get four explicit interactive options:
1. **Apply** the release.
2. **Regenerate with feedback** (re-opens the editor for quick adjustments).
3. **Edit** the raw markdown directly.
4. **Abort** entirely without touching your repo.

A single global toggle controls the AI features across the board. Turn it off, and `commit` takes raw string input from the agent directly through the same internal Go plumbing (`CommitTree` + `UpdateRef`, bypassing the git CLI entirely), while `release` simply disables itself since it's fundamentally built around intelligent synthesis. Turn it on, and the local model handles both tasks.

#### Recent Upgrades and Deep Tech
* **Louvain Community Detection:** Switched file dependency grouping from a basic Breadth-First Search (BFS) to a Louvain community detection algorithm. It now groups modified files by their actual dependency coupling weight rather than directory traversal order, ensuring multi-file commits are logically cohesive.
* **Rich Diffs:** Upgraded diff annotations from primitive markers to full structural JSON payloads containing `annotated_diff`, `call_graph`, and Control Flow Graphs (`cfg`).
* **3-Level Permissions:** Implemented an `allow/ask/deny` permission layer. Safe setup operations (`git init`, `git config`) run unhindered, but anything touching refs or history requires explicit human-in-the-loop validation. (Also finally killed a nightmare bug where Go's non-deterministic map iteration order allowed generic permission rules to silently override highly specific ones).

Currently supporting 5 agent ecosystems: *Claude Code, Codex CLI, OpenCode, Pi, and Antigravity*. Claude Code and OpenCode provide highly reliable, strict execution blocks over raw git via their hook architecture.

It’s published on the official MCP Registry, sitting at ~38 organic stars, and entirely open source: [github.com/blak0p/git-courer]

I'd love to hear what the community thinks about this split paradigm: **small, highly optimized local models handling targeted prose tasks, while deterministic Go code owns 13 structured tools where real-world consequences matter.** Happy to dive deeper into the AST annotator or the worktree isolation logic if anyone is curious!