plandex

https://github.com/plandex-ai/plandex/blob/9017ba33a627c518a... Well your perfectionism needs to be pointed towards this line. If you get truly large numbers of users this will either slow down token checking directly or your process for removing ancient expired tokens (I'm assuming there is such a process...) much slower and more problematic.

I’ll throw out a mention for my project Plandex[1], which predates Claude Code and combines models from multiple providers (Anthropic, Google, and OpenAI by default). It can also use open source and local models. It focuses especially on large context and longer tasks with many steps. 1 - https://github.com/plandex-ai/plandex

Hey, you might be interested in my project Plandex[1] which uses a shadow git repo approach to keep changes separate until you approve them. It solves the same problem as worktrees. 1 - https://github.com/plandex-ai/plandex

I built Plandex[1] (open source CLI coding agent focused on large projects and tasks) in Go and I’ve been very happy with that decision. Beneath all the jargon, it’s good to remember that an “agent” is ultimately just a bunch of http requests and streams that need to be coordinated—some serially and some concurrently. And while that sounds pretty simple at a high level, there are many subtle details to pay attention to if you want to make this kind of system robust and scalable. Timeouts, retries, cancellation, error handling, thread pools, thread safety, and so on. This stuff is Go’s bread and butter. It’s exactly what it was designed for. It’s not going to get you an MVP quite as fast as node or python, but as the codebase grows and edge cases accumulate, the advantages of Go become more and more noticeable. 1 - https://github.com/pland

You can try my project Plandex[1] to use Gemini in a way that's comparable to Claude Code without copy-pasting. By default, it combines models from the major providers—Anthropic, OpenAI, and Google. The default planning/coding models are still Sonnet 3.7 for context size under 200k, but you can switch to Gemini with `\set-model gemini-preview`. 1 - https://github.com/plandex-ai/plandex

My tool Plandex[1] allows you to switch between automatic and manual context management. It can be useful to begin a task with automatic context while scoping it out and making the high level plan, then switch to the more 'aider-style' manual context management once the relevant files are clearly established. 1 - https://github.com/plandex-ai/plandex Also, a bit more on auto vs. manual context management in the docs: https://docs.plandex.ai/core-concepts/context-management

There's aider (https://aider.chat) or Claude Code (https://docs.anthropic.com/en/docs/claude-code/overview) or Codex (https://github.com/openai/codex) or plandex (https://github.com/plandex-ai/plandex) or kwaak (https://github.com/bosun-ai/kwaak) I'd venture to say there's more of these than there are UI Editors tbh.

> Is there a good CLI like Claude Code but for Gemini / other models I built an open source CLI coding agent that is essentially this[1]. It combines Claude/Gemini/OpenAI models in a single agent, using the best/most cost effective model for different steps in the workflow and different context sizes. The models are configurable so you can try out different combinations. It uses OpenRouter for the API layer to simplify use of APIs from multiple providers, though I'm also working on direct integration of model provider API keys. It doesn't have a Neovim plugin, but I'd imagine it would be one of the easier IDEs to integrate with given that it's also terminal-based. I will look into it—also would be happy to accept a PR if someone wants to take a crack at it. 1 - https://github.com/plandex-ai/plandex

If you're open to something CLI-based, my project Plandex[1] offers git-based branching (and granular versioning) for AI coding. It also has a sandbox (also built on git) that keeps cumulative changes separate from project files until they're ready to apply. 1 - https://github.com/plandex-ai/plandex

Haven't tried it yet, but I've heard good things about Plandex. https://github.com/plandex-ai/plandex

I built an open source CLI coding agent for this purpose[1]. It combines Claude/Gemini/OpenAI models in a single agent, using the best/most cost effective model for different steps in the workflow and different context sizes. You might find it interesting. It uses OpenRouter for the API layer to simplify use of APIs from multiple providers, though I'm also working on direct integration of model provider API keys—should release it this week. 1 - https://github.com/plandex-ai/plandex

You can read all of the prompts in Plandex (open source CLI coding agent focusing on larger projects): https://github.com/plandex-ai/plandex/tree/main/app/server/m... They're pretty long and extensive, and honestly could use some cleaning up and refactoring at this point, but they are being used heavily in production and work quite well, which took a fairly extreme amount of trial-and-error to achieve.

If you're using Cursor (as I do), but find it tends to struggle once your project reaches a certain size, and you're ok with something CLI-based, you might find the open source CLI coding agent I've built interesting: https://github.com/plandex-ai/plandex - It can handle up to 2M tokens of context directly, and can index/work with/chat with projects up to 20M tokens (1M+ lines). Here's an example of chatting with with SQLite codebase to learn about how transactions are implemented: https://plandex.ai/_next/static/media/plandex-sqlite.0ee6cb2... - All changes are committed to a version-controlled sandbox by default, preventing the problem of stray changes that you don't notice being left behind in the project. - Being terminal-based allows for more seamless and powerful execution control and automated debugging. Here's an example of automa

You could try my project Plandex (https://github.com/plandex-ai/plandex) — you can use it to explore/understand/chat with just about any codebase, including massive ones up to 20M tokens. Here's an example, chatting with the SQLite codebase to understand how transactions are implemented: https://plandex.ai/_next/static/media/plandex-sqlite.0ee6cb2...

If you’re open to a terminal-based approach, this is exactly what my project Plandex[1] focuses on—breaking up and completing large tasks step by step. 1 - https://github.com/plandex-ai/plandex