AI Coding

cline64.0k★

Cline is an AI coding agent that lives inside VS Code and actually does things. Not autocomplete. Not suggestions in a ghost text overlay. It reads your project, edits files, runs terminal commands, launches a browser, and debugs runtime errors, all with your approval at every step. The human-in-the-loop design means nothing happens without your explicit sign-off. You bring your own API key from Anthropic, OpenAI, or a dozen other providers, point it at the model you want, and let it loose. It supports MCP, so you can extend its capabilities with custom tools. Basically a junior dev pair programmer that never gets tired and never pushes code without asking. GitHub Copilot is the obvious comparison, but Cline goes deeper: it does not just suggest lines, it executes multi-step tasks end to end. Cursor offers similar agentic features but locks you into their editor. The catch: you are paying for every API call yourself, and on complex tasks those tokens add up fast.

aider46.8k★

Aider is a terminal-based AI pair programmer that edits your actual codebase. Not a chatbot that spits out snippets you copy-paste. You point it at your repo, tell it what to build or fix, and it writes the code directly into your files with proper git commits. It builds a map of your entire codebase so it understands how everything connects, even in large projects. Works with Claude, GPT-4o, DeepSeek, o3-mini, local models, basically anything. Supports 100+ languages. Has voice input, image context, linting integration, and IDE watch mode. Alternatives like Continue and Cursor offer similar AI coding but lock you into their editor. GitHub Copilot stays in VS Code's world. Aider stays in the terminal and works with whatever editor you already use. The catch: you bring your own API keys and pay for tokens directly. Heavy usage with frontier models gets expensive fast, and the terminal-first UX has a learning curve if you are not already living in the command line.

CodeWhale39.2k★

CodeWhale is an AI coding agent that lives in your terminal. You talk to it, and it reads, writes, and runs code in your project, with approval gates so it can't run wild. The twist that sets it apart: it's built first around open models like DeepSeek V4 and Xiaomi's MiMo rather than Claude or GPT, which makes it the budget-conscious option in a category dominated by frontier-model tools. The agent itself is MIT licensed and free, and it's one of the fastest-moving projects in this space right now. It's a serious piece of engineering, not a wrapper. Three modes (Plan is read-only, Agent gates every action, YOLO auto-approves), approval-gated access to files, shell, git, web, and MCP servers, side-git snapshots so you can roll back anything it changed without touching your real history, live diagnostics after edits, and parallel sub-agents. You install it with a single npm, Homebrew, or Docker command, no Rust toolchain needed. The one real setup step is getting an API key from DeepSeek, or another supported provider, and funding it. That last point is the whole pricing story. The tool is free; the model usage is not. You bring your own key and pay the provider per token, and the entire pitch is that DeepSeek's pricing sits among the cheapest of the major providers, so the same agentic workflow costs a fraction of what it would on premium models. Solo developers who want a Claude Code style agent without the premium bill: this is the move. Small teams get visibility into what the agent changed before it lands. The closest comparisons are Claude Code, Aider, and OpenAI's Codex CLI, all of which lean on pricier models. The catch is that you're betting on a young, blazing-fast-moving project tied closely to the open-model ecosystem. It ships releases almost daily, which means new features and occasional churn, and its best economics assume DeepSeek's API stays cheap and available. If you want the absolute strongest coding model regardless of cost, the frontier tools still win. If you want most of that quality for a fraction of the price, this is the bet.

DeepSeek-Reasonix25.3k★

DeepSeek-Reasonix is a coding agent that lives in your terminal and runs on DeepSeek's models. It edits files, runs shell commands, plans multi-step changes, and plugs into MCP servers and custom skills, the same shape as Aider or Claude Code but built specifically around DeepSeek. The agent itself is free and MIT licensed; you bring your own DeepSeek API key. The whole point is cost control through prefix caching. The project is engineered to keep your conversation prefix stable so DeepSeek's cache keeps hitting, and the numbers are real: one documented session ran about twelve dollars instead of sixty-one without caching. Install is a single npm install with Node 22 or newer. A Tauri desktop client exists but it is still a prerelease, so the command line is where the stable experience lives. Solo developers already paying for DeepSeek API access get a capable agent for nothing extra. Small teams that want AI coding without per-seat Copilot or Cursor bills can run this and pay only for tokens. Larger teams will weigh the lack of polish and support against the savings, and many will still want an IDE-integrated tool instead. The catch is that you are tied to one model family. DeepSeek is cheap and capable, but it is not the strongest coding model out there, and the project says so itself. If you need the best results regardless of cost, this is not it.

superset12.1k★

Superset is a desktop app for running a swarm of coding agents at once. Instead of babysitting one Claude Code or Codex session in a terminal, you point it at your repo and it launches ten or more agents in parallel, each isolated in its own Git worktree so they do not step on each other. It bundles a terminal, a diff viewer, and open-in-editor workflows so you can review what each agent did without juggling a dozen windows. The model is simple: every task gets a clean worktree, the agent works, and you review the diff before you merge. It works with any CLI agent, so you are not locked to one vendor's tool. For someone already trying to run several agents by hand, this is the orchestration layer that makes it manageable instead of chaotic. It is free to download, but read the license before you build on it. Superset ships under the Elastic License 2.0, which is source-available, not open source. You can see the code and use the app, but the license restricts offering it as a competing service. It is macOS only right now, with no Windows or Linux builds yet. Solo developers and small teams running agent-heavy workflows are the audience. Running a single agent at a time? You do not need this. The catch is the license and the platform limits. Source-available is not the same as open source, so do not treat it like an MIT project when you plan around it. And until Windows and Linux builds land, this is a Mac-only tool.

claurst9.9k★

claurst is an open source terminal coding agent written in Rust, built to replicate the behavior of Claude Code. It reads files, runs commands, searches codebases, and handles git operations from your terminal. The project was built from behavioral specs, not copied source code. The appeal is obvious: Claude Code is a proprietary tool that costs money. claurst gives you a similar workflow for free (assuming you bring your own API key for whatever model you point it at). Being written in Rust means it starts fast and uses less memory than Node.js-based alternatives. The project grew quickly after the Claude Code source leak sparked interest in how these agents work under the hood. For developers who want a terminal coding agent but do not want to pay for Claude Code, this is the most direct alternative. Aider and Continue are more established options with broader model support and larger communities. claurst is newer and less battle-tested, but the Rust foundation and active development are promising. The catch: this is early-stage software riding a wave of hype. The feature set is thinner than Claude Code, the plugin ecosystem does not exist yet, and you are depending on a solo maintainer. If you need reliability today, the established tools are safer bets.

codeburn8.3k★

Codeburn shows you where your AI coding tokens go. Install it, run it, and get a TUI dashboard breaking down cost by project, model, and session across Claude Code, Codex, Cursor, Copilot, and others. No API keys needed: it reads the session files these tools already store on your machine. Setup is one command: npx codeburn. Pricing data pulls from LiteLLM and caches for 24 hours. Beyond raw cost, it classifies your sessions into task types (debugging, testing, coding) and calculates one-shot success rates so you can see which tasks burn tokens on retries. Anyone paying for AI coding tools should run this once just to see the numbers. The macOS menubar app gives passive cost awareness without opening a terminal. The optimize command flags waste patterns like repeated failures on the same task. The catch: it only knows about tools that store session data locally. If your AI tool does not write to disk (or you have not used it on this machine), codeburn cannot see it.

html-anything7.3k★

HTML Anything is a desktop editor that takes Markdown, CSV, or notes and asks your existing coding agent (Claude Code, Cursor, Codex, Gemini, others) to render them as styled HTML: keynote decks, magazine articles, resumes, posters, social cards. Apache 2.0. Reuses whatever agent sessions you're already logged into, so the marginal cost is zero. Self-hosted by design. There's no cloud tier. Run it locally, it scans your PATH for installed agent CLIs, you pick one and a template. The 75 templates ship as SKILL files (Anthropic's skill format) and produce single-file HTML you can paste into WeChat, Zhihu, X, or just download as PNG. Setup is install dependencies, run `pnpm dev`. For anyone who already pays for Claude Code, Cursor, or similar and wants polished HTML output without sending more tokens through paid APIs: this is the angle. For people without an agent CLI installed: skip it, the value disappears. It's downstream of someone else's project (`nexu-io/open-design`) and the README leans hard on showcase shots. The template library is the actual product. If the templates don't fit your output, you're writing your own SKILL files in custom HTML and CSS, which is the work the tool claims to spare you.

DeepSeek-GUI4.9k★

DeepSeek-GUI wraps DeepSeek's AI coding agent in a desktop workspace instead of a terminal. You point it at a real project and it edits files, shows you the diffs, and waits for your approval before changing anything, with permission levels from read-only to full access. MIT-licensed and free to install. It's for people who want DeepSeek working on actual code with a review step, not just a chat window. It ships three modes. Code mode is the project workspace with file monitoring and task cards for jobs like debugging. Write mode is a Markdown editor with inline AI and export to HTML, PDF, or DOC. Claw mode runs background automation, hooking into Lark/Feishu, webhooks, and scheduled tasks. It also manages MCP servers and skills. Prebuilt installers cover macOS and Windows; Linux builds from source and needs Node 20 or newer. The app is free, but it's a front end, not a model. You bring your own DeepSeek API key, and that usage costs money, though DeepSeek's pricing sits among the lowest of the major providers. Solo developers already using DeepSeek who want a GUI with approval controls: worth a look. Teams get visibility into what the agent changed before it lands. The catch is that this is one developer's project tied to one model provider. You're betting on both the maintainer keeping pace and DeepSeek's API staying available and cheap. If you want a model-agnostic agent workspace, look at cmux or the broader AI coding tools that aren't locked to a single provider. Outside the DeepSeek ecosystem, this does nothing for you.

hapi4.4k★

Hapi runs a Claude Code, Codex, Gemini, or OpenCode session on your laptop and lets you control it from a phone or browser. The agent stays where it works best (your machine, your file system) and a web/PWA/Telegram app gives you remote eyes and a remote keyboard. End-to-end encrypted via WireGuard plus TLS. AGPL. Setup is one npx command. You get a URL and QR code, scan it, and you are looking at the active session from anywhere. Workspace browsing is opt-in. Voice control works through a built-in assistant, and Telegram approvals let you sign off on agent actions while away from the keyboard. The relay is provided, but you can self-host with Cloudflare Tunnel or Tailscale. Solo developers running long agent loops: this is the most polished way to monitor them away from the desk. Small teams: same value, but pair-sharing across teammates is not the use case. Large teams: stick to internal devloop tools. The AGPL license adds friction for enterprise legal reviews. The catch: it is built around a relay you do not own. Self-hosting is supported, but the easy path uses someone else's WireGuard hub. Read the security model before you point it at production credentials.

gptme4.3k★

gptme is a coding agent that runs in your terminal and works with whatever model you point it at. It executes shell commands, writes and patches files, runs Python, browses the web through Playwright, and reads images, all from a single CLI. The model is your choice: Anthropic, OpenAI, Google, DeepSeek, or a local llama.cpp model when you want zero API cost. There's nothing to host. You pip install it, drop in an API key, and you're working. It also exposes a web UI and a REST API if you want to drive it from somewhere other than the terminal, and it speaks MCP, so you can plug in external tool servers. For something this capable, the setup is refreshingly light. Solo developers and tinkerers who live in the terminal and want a model-agnostic agent get the most here. It's a direct open-source answer to Claude Code, Copilot CLI, and Cursor, with the advantage that you're not locked to one vendor's model. Teams standardizing on a single coding agent may prefer something with more polish and support. The catch: the software is free, but the models aren't. Point it at a frontier API and you'll pay per token like any agent, run it on a local model and you trade that bill for slower, weaker output. And model-agnostic means you're the one tuning which model handles which job, that flexibility is also homework.

codex-plusplus3.4k★

Codex++ is a tweak system for OpenAI's Codex desktop app. Inject custom features, fix UI bugs, and run a tweak manager without rebuilding the app. It's userscripts for your AI coding assistant. MIT licensed, available on macOS, Linux, and Windows. Install via Bun, a bash script, or PowerShell. The installer patches your local Codex app, backs it up, manages signatures, and installs a watcher that re-applies tweaks after Codex updates. Hot-reload means save a tweak file and it's live. Two default tweaks ship: custom keyboard shortcuts and UI improvements. Pick this if you use Codex daily and have a list of "I wish it just did X" complaints. Solo: free, the watcher handles updates. Small teams: works fine but each user installs separately. Large orgs running managed Codex deployments: don't, this voids code signatures and your security team will not love it. The catch: it's unofficial. Modifying Codex.app voids code signatures. Updates from the official app overwrite patches; the watcher re-applies them, but a structural change by OpenAI breaks your tweaks until the maintainer catches up. This is a power-user toy, not production tooling.

kimi-code2.9k★

kimi-code is a coding agent that runs in your terminal, built by Moonshot AI around their Kimi models. It reads and edits code, runs shell commands, searches files, fetches web pages, and decides its next move from the results, the same agent loop as Claude Code or Aider. It ships as a single binary with no Node install required, and supports subagents for parallel work, MCP servers, and lifecycle hooks. MIT licensed and free; you authenticate with a Moonshot API key or OAuth. Install is a one-line script on macOS, Linux, or Windows, and the single-binary design means there is nothing else to set up. This is early software, though, sitting at version 0.2.0. The agent works and the feature list is ambitious, with video input, subagents, and hooks, but expect the rough edges of a tool that shipped weeks ago, not one hardened over years. Solo developers already in the Kimi ecosystem get a capable terminal agent for the price of API tokens. Small teams curious about Moonshot's models can try it without committing to a subscription tool. Larger teams should wait for it to mature, or stick with a more established agent. The tool is free; your cost is Moonshot API usage. The catch is that you are betting on one vendor's models and a very young project. Kimi is capable, but if Moonshot changes pricing or the project stalls, you are stuck. Treat it as worth watching, not yet worth standardizing on.

deepclaude2.2k★

deepclaude swaps the model behind Claude Code without changing the interface. You keep the autonomous agent loop, file editing, and bash execution, and route calls to DeepSeek V4 Pro, OpenRouter, Fireworks, or any Anthropic-compatible backend. Free, MIT. Setup is two minutes. npm install, set environment variables for your chosen provider, and the CLI behaves like Claude Code with a different brain inside. Multiple providers can be configured at once, and you switch between them at the env-var level. Solo: real money. DeepSeek V4 Pro at $0.87 per million output tokens versus Anthropic's $15 means a hobby project can stop bleeding cash. Small teams: depends entirely on whether your model of choice handles your codebase as well as Sonnet does. Larger teams: probably stay on Anthropic. A productivity hit on a senior engineer costs more than the API bill ever will. The catch: Claude Code is good because of Sonnet and Opus, not because of the loop around them. DeepSeek is solid but it is a different model with different blind spots. Test it on your real code before committing.

smallcode2.0k★

smallcode is a terminal coding agent built for small, local language models, the 8B to 35B range you can run on your own hardware, not frontier models like Claude or GPT. Most agents assume a huge, reliable model behind them. smallcode assumes the opposite and engineers around it. MIT-licensed and free. The adaptations are practical: a managed context budget instead of dumping everything at the model, forgiving parsing for messy tool calls, TODO-file planning, and search-and-replace patches instead of full-file rewrites. It's actively maintained, with real releases and a benchmark harness. The project claims 87% on a benchmark with a 4B-active model, though it doesn't spell out the suite or baseline, so take the number as a signal, not proof. The catch: a coding agent is only as good as the model driving it, and small local models still make mistakes a frontier model wouldn't. If you want to keep code on your own machine or avoid API bills, this is a serious attempt at making that work. If you just want the best results, a frontier model with a mature agent like aider will still beat it.

claude-usage1.9k★

Claude Usage reads the JSONL session logs that Claude Code writes to your machine and turns them into charts. Per-model token breakdowns, cache hit rates, cost estimates, and session history, all in a local browser dashboard. Anthropic's own UI gives you a progress bar. This gives you the full picture. Zero dependencies. Standard library Python only, no pip install. Clone the repo, run the dashboard command, and it serves a Chart.js UI at localhost:8080 that auto-refreshes every 30 seconds. A SQLite database at ~/.claude/usage.db caches the parsed data for fast incremental re-scans. CLI commands cover scan, today, stats, and dashboard. Pro and Max subscribers who want to understand their actual token consumption per session and per model need this. The cost estimates use current API pricing, which is useful even for subscription users as a proxy for understanding usage patterns. The catch: only captures local Claude Code sessions. Cowork sessions (server-side) are not included. Cost estimates reflect API pricing, not what you actually pay on a Pro/Max subscription. Single-maintainer project, so pricing tables need manual updates when Anthropic changes models.

keep-codex-fast1.4k★

keep-codex-fast is a maintenance script for OpenAI's Codex CLI. It walks through accumulated chat history, terminal logs, and worktrees, then archives or prunes them safely. MIT. The flow is conservative on purpose. Inspect first, write a handoff doc, back up state, then optionally apply changes. Read-only by default, archive instead of delete, and you opt in with --apply when you actually want it to do something. Solo: useful if your Codex sessions feel sluggish from months of chat history, terminal logs, and stale worktrees piling up. Teams: skip, this is personal-machine maintenance with nothing to centralize. The catch is the scope. This is for OpenAI's Codex, not Anthropic's Claude Code. The names sound similar, the tools are different, and the state directories do not overlap. If you run Claude Code, this script will not help you.

codex-shim1.0k★

codex-shim is a local proxy that lets Codex Desktop talk to models it was never built to support. OpenAI's Codex app normally locks you into a short list of models. This shim sits between the app and whatever provider you want, translating Codex's Responses API format into calls to Anthropic, DeepSeek, or any generic chat-completion endpoint, with an optional ChatGPT passthrough that reuses your existing subscription. MIT licensed and completely free. Running it means Python 3.11 or newer, a pip install, and editing a JSON config to point Codex at localhost. On macOS you may also patch the app so your custom models show up in the picker. None of this is hard for someone comfortable in a terminal, but it is fiddly, and it can break when Codex ships an update that changes its internal API. This is a workaround, not a product. Solo developers who want Claude or DeepSeek inside Codex without paying for a second tool get real value here. Small teams might standardize on it to route through a cheaper model. Larger teams should think hard before depending on an unofficial shim that lives or dies by one maintainer. The catch is fragility. You are patching around a closed app's limits, so every Codex release is a chance for this to stop working. Use it knowing that.

fablize659★

Fablize is a plugin for Claude Code that forces the agent to slow down and prove its work. Instead of letting the model declare a task done, it makes it reproduce the bug first, break the work into steps, and verify the result before claiming success. The pitch is procedural discipline: give a weaker model the working habits of a careful engineer without swapping the model. MIT, free, installs into Claude Code. There is nothing to host and no key to manage beyond the Claude subscription or API you already pay for. The whole thing is a discipline layer, not the intelligence. By the author's own admission it cannot make a model smarter, it can only make it more rigorous, which for agentic coding is often the part that actually fails. It is an early project, a handful of commits in, so treat it as promising rather than battle-tested. This is for developers already running Claude Code who keep getting confidently-wrong 'done' from their agent and want guardrails. Solo or team, the cost is the same: free. If you do not use Claude Code, or you do not run agentic coding workflows, there is nothing here for you yet. The catch is dependency. Fablize is only as useful as the agent it rides on, and its value is entirely in process, not capability. If your model is already disciplined, you will notice less. If it cuts corners, this is the leash.