From GitHub Copilot to Claude Code, Codex, Cursor, and OpenCode: how AI agents became real software developers, why users love and hate them, and what they actually cost.
October 28, 2026
A few years ago, artificial intelligence in software development meant asking ChatGPT to write a Python function, copying the result into your editor, discovering it didn’t work, and repeating the process until you either fixed the problem yourself or gave up. Today, we have AI agents that can inspect an entire repository, modify dozens of files, execute tests, diagnose errors, operate remote development environments, and coordinate other AI agents.
That software is called an AI harness, and it’s becoming almost as important as the model itself. Unfortunately, while the technology has improved dramatically, so has the complexity of paying for it. Free plans are getting more restrictive, subscription allowances can disappear surprisingly quickly, and even people paying $100 or $200 a month sometimes discover their AI coding assistant has effectively gone on strike until the next quota reset.
We’ve spent considerable time using OpenCode with commercial and locally hosted language models, building web applications, testing deployment systems, developing scientific software, and creating automated manuscript-review pipelines. The experience has been impressive, frustrating, occasionally expensive, and highly educational. It closely resembles what developers are reporting on Reddit and GitHub.
1. How We Got Here: A Short History of AI Coding Harnesses
The evolution happened in roughly four stages.
2021–2022: The autocomplete era
GitHub introduced Copilot in June 2021 and made it generally available in June 2022. Initially, it was something like an extraordinarily sophisticated autocomplete system. You wrote code and Copilot predicted what came next. It could generate entire functions, but the human developer still handled the architecture, files, testing, deployment, and most debugging. This was useful, but it wasn’t autonomous software engineering. GitHub’s original Copilot announcement
2023: AI starts editing actual projects
Tools like Aider and Cursor advanced beyond copying suggestions from a chat window. Aider, developed by Paul Gauthier, made it possible to work with an LLM directly inside a Git repository. Its repository mapping, editing, testing, and Git integration were important steps toward practical AI-assisted development. Cursor brought similar concepts into a familiar graphical editor. The key development was contextual awareness. Instead of treating every question as an isolated interaction, these tools began understanding and changing the codebase itself.
2024: Agents acquire tools
Cline, originally known as Claude Dev, and Windsurf’s Cascade pushed toward agents that could inspect files, execute commands, and iteratively work toward a goal. The AI was no longer simply suggesting code. It was taking actions, observing the consequences, and trying again. This brought substantial productivity improvements but also introduced new failure modes. An AI that writes an incorrect function is annoying but can be fixed the next iteration but an AI that repeatedly executes an incorrect command against a live server can be considerably more destructive. We witnessed this a few times with server and software crashes until they got smarter about guardrails.
2025–2026: The harness wars
Anthropic introduced Claude Code in February 2025. OpenAI launched Codex CLI in April and its cloud Codex agent in May. Google introduced Gemini CLI in June. OpenCode emerged as a prominent open-source, model-independent alternative. By 2026, the competition was no longer just about which model could write code without crashing and transitioned to which system could manage complicated tasks, recover from failures, control costs, remember context, and deliver finished work. Developers began switching harnesses almost as frequently as they switched models. Flexibility became a key tool in the AI Dev toolbox.
2. What Exactly Does a Harness Do?
An LLM, by itself, is essentially a reasoning and text-generation engine, it doesn’t inherently know where your application’s configuration files live, how to connect to your test server, which tests must pass, or what happened before an interrupted development session. A harness supplies those capabilities. A capable coding harness generally handles:
- Tools: Reading files, editing code, executing commands, searching repositories, and interacting with external services.
- Context: Deciding what information the model receives and what gets discarded or summarized.
- Agent orchestration: Assigning work to subagents, coordinating tasks, and collecting results.
- Persistence: Saving sessions, checkpoints, and previous decisions.
- Permissions: Restricting access to files, shells, networks, and production systems.
- Verification: Running tests and deciding whether an implementation actually satisfies its requirements.
- Model routing: Choosing which model to use for particular tasks.
Two harnesses using the exact same model can produce different results, one might maintain the relevant context and successfully repair a problem, the other loses an important requirement during context compression, repeats an already completed task, and confidently announce success. Selenium tests that I can watch run become particularly important here as a lot of the tests that a harness writes can be misleading at best.
3. The Market: Who’s Actually Winning?
The market has changed remarkably quickly. JetBrains’ 2026 Developer Ecosystem Survey, covering more than 15,000 professional developers, found that approximately 90% used AI coding agents at work at least weekly during May–July 2026, with 68% using them daily. And the distribution of tools has changed even more.
Developer adoption, 2026
| AI coding tool | Developers using it at work |
|---|---|
| Claude Code | 39% |
| GitHub Copilot | 21% |
| OpenAI Codex | 16% |
| Cursor | 12% |
| OpenCode | 7% |
Source: JetBrains Developer Ecosystem Survey 2026. Multiple tool usage is possible; percentages do not sum to 100%.
Claude Code climbed from approximately 18% adoption in January 2026 to 39% by midyear. Codex jumped from 3% to 16%. Meanwhile, Copilot declined from 29% a year earlier to 21%, and Cursor fell from 18% in January to 12%. The October Stack Overflow Developer Survey 2026 provides another perspective. Among 12,255 respondents to its coding-agent question, 65.5% reported using Claude Code in the preceding year, followed by Copilot at 58.7%, Codex at 29.5%, Cursor at 25.5%, and OpenCode at 13.6%. These figures aren’t contradictory. The surveys use different populations, time windows, and definitions.
Nor are they literal revenue market shares. They’re developer-adoption measurements, which are arguably more informative about where the industry is heading than corporate marketing claims. The overall trend is unmistakable: developers are moving away from simple AI autocomplete toward increasingly autonomous agents. But which harnesses deserve their growing popularity?
4. Comparing the Major Harnesses
Claude Code: The Powerful, Expensive Favorite
Claude Code has developed a reputation for strong codebase reasoning, sophisticated tool use, and handling complicated engineering instructions. Its greatest strength is not necessarily that Claude always writes better code. It’s the combination of model capability, context management, integrated tools, and a reasonably coherent agent workflow. The system has continued evolving, including its extensibility features. In an October discussion on r/ClaudeCode, developers praised the ability to modify harness behavior from within a session instead of relying entirely on external scripts. Other users report substantial improvements in coding quality, including fewer missed instructions and better reviews with newer models.
The problem is price and predictability. Claude’s individual plans have included Pro at $20 per month, Max 5x at $100, and Max 20x at $200. Those numbers sound generous until you begin running complicated multi-agent workflows: a five-hour usage allowance is not a promise of five hours of uninterrupted coding. A sufficiently intensive job can exhaust its allowance before the window ends which is a frequent occurrence around here.
Community experiences vary considerably. One October 2026 Reddit user reported finding it difficult to exhaust the $20 plan’s weekly usage, but this doesn’t last long once you start gaining experience with the harness. Then you start hitting limits during complex tasks. Task complexity, model choice, reasoning effort, context size, caching, and subagent activity can make the same subscription behave very differently.
Verdict: Among the strongest choices for difficult autonomous engineering, but its subscription economics are less attractive when workloads become intensive or unpredictable.
OpenAI Codex: Serious Engineering Capability, Similar Quota Frustrations
Codex has improved enormously since the original command-line agent, its strength is structured software development: investigating repositories, making controlled changes, running tests, and working across multiple tasks. Its terminal, IDE, and cloud workflows offer different ways to supervise that work. For developers already paying for ChatGPT, Codex is attractive because access is integrated into existing plans. Limited local Codex access is even available on Free and Go, although cloud capabilities and usage allowances depend on the plan.
There are weaknesses, however. Heavy reasoning tasks can consume allowances rapidly, and developers have reported changes in effective usage capacity. A particularly interesting August 2026 r/codex report described an independently logged decline from approximately 323 million to 173 million effective tokens per week following a change in usage windows. That’s a 6% reduction. Its not an independently established service-wide change but it illustrates why some users no longer trust the simplicity of subscription advertising. Another September report described a substantial decline in effective allowance using the author’s own telemetry. This complaint is something we’ve had to deal with often, the latest problem was with OpenCode changing model limits happened this week and it’s not is easy to plan work when the capacity constantly changes.
Verdict: A strong general-purpose coding agent, especially for structured engineering and people already in the OpenAI ecosystem. But quota visibility and predictability remain consequential concerns.
Cursor: Excellent Editor, Increasingly Complicated Billing
Cursor’s principal advantage has always been usability. An AI-native coding editor makes it convenient to inspect changes, navigate files, review diffs, and collaborate with an agent without constantly switching between terminal windows. We use that setup, but with VSCode and it’s terminal window. An agent that performs sophisticated reasoning but makes its work difficult to inspect wastes a lot of time. Cursor has historically been particularly appealing for developers who want integrated editing, autocomplete, and autonomous changes in one environment. Its weakness is the growing complexity of the commercial arrangement.
By late October 2026, Cursor’s published new-customer pricing had moved toward The X Subscription, with Free, $8 Plus, $30 Premium, $100 Super, and $200 Ultra tiers. Legacy Cursor Pro accounts at $20 remain supported, but that doesn’t mean new subscribers receive the same product economics. Under the newer arrangement, the included usage pool focuses on Cursor models, while third-party models such as Claude or GPT are billed separately on eligible plans. This makes comparing Cursor with competing subscriptions considerably harder. A February discussion on r/cursor described developer expenses reaching hundreds of dollars per month. Other users have praised promotional credits and generous usage experiences. Neither experience establishes the typical cost, but together they illustrate the uncertainty.
Verdict: Excellent developer experience, particularly for interactive coding and reviewing AI edits. Less appealing if you want simple, predictable, model-independent costs.
OpenCode: The Open-Source Contender We Know Best
OpenCode has one major advantage: freedom. It operates with different model providers, including locally hosted language models. You aren’t necessarily bound to one vendor’s models or subscription. We’ve used it extensively with commercial services and locally deployed models through llama.cpp. Our environment includes a 24 GB AMD graphics card running a quantized Qwen-family model, with OpenCode communicating through an OpenAI-compatible endpoint. We’ve used this arrangement for projects involving Django web applications, Linux installation and administration, scientific computation, and an automated novel-editing system. More importantly, it allows a small operation to perform substantial engineering work without maintaining an enormous commercial inference budget.
But OpenCode also demonstrates how a good idea can suffer from difficult implementation problems. In our environment, the OpenCode SQLite database grew to approximately 47 GB. And it wasn’t unique to us. One OpenCode GitHub issue documented a 73 GB database, approximately 64.4 GB of which was event history. Other reports described excessive memory consumption and databases that continued growing without effective retention controls. Those are serious engineering defects for software intended to run unattended or manage complex development sessions. We also encountered limitations involving context accounting, interrupted runs, tool execution, and recovery from model failures.
One particularly important lesson was that requesting a large context window doesn’t mean the local inference server can actually deliver it. A configuration might advertise more than 100,000 tokens while the deployed model is effectively operating with a substantially smaller usable context. The harness, server, tokenizer, and model must agree about those limits. In the manuscript-review system, for example, we eventually moved toward a tightly controlled process with one inference in flight, persistent checkpoints, explicit failed-job states, and resumable execution. It took substantial debugging to reach that point. OpenCode’s advantages are real, its flexibility is valuable, but flexibility is not the same as production reliability. Reddit reflects this dual character. A June r/opencode discussion praised the ability to leave an expensive Claude subscription and mix commercial and local models. An October comparison praised the value of OpenCode Go. Other posts complain about rate limits, service congestion, confusing allowances, and instability.
Verdict: My preferred architecture for experimentation, custom agents, model independence, and local inference. But long-running autonomous operations need safeguards beyond those supplied by the harness alone.
Cline and Aider: Smaller, More Transparent Alternatives
Cline and Aider deserve attention because not every development task requires an elaborate multi-agent platform. Cline integrates with development environments and supports file operations, terminal execution, planning, and provider choice. Aider emphasizes repository editing, Git integration, and relatively straightforward workflows. Both offer an important economic distinction: their open-source software can be free even when the LLM inference is not. Cline explicitly describes its individual harness as free, with users paying for model inference or bringing their own API keys. These tools won’t magically eliminate expensive token consumption. An inefficient workflow generates an impressive API bill regardless of whether the harness costs anything.
Verdict: Strong alternatives for developers who prioritize transparency, control, and focused work over an all-in-one AI ecosystem.
Gemini CLI and the Google Problem
Google provided an especially revealing experiment in free AI coding. When Gemini CLI launched in June 2025, Google advertised up to 1,000 free model requests per day and 60 per minute through personal Google accounts which was exceptionally generous. It didn’t last of course, on June 18, 2026, Google discontinued the consumer-account authentication path for Gemini Code Assist IDE extensions and Gemini CLI and directed users toward its Antigravity products. This did not eliminate every free Gemini API option, but it did end that particular consumer access arrangement. A hosted free tier is rarely a permanent technical capability. We dumped Antigravity over here, just figuring out your billing in Google’s interface ended up being more complicated than the Hubble tension cosmology problem we’re working on.
Verdict: Google remains a contender, but developers should treat even exceptionally generous free access as temporary unless contractual guarantees say otherwise, their billing interface is clunky, and Antigravity was cool when it first came out, but now seems like a dinosaur looking up at the inbound asteroid of modern TUI interfaces.
5. The Dirty Secret About “Free” AI Coding
Here’s where the marketing gets particularly interesting. Advertising a free AI coding solution, they may mean three entirely different things.
Free software: The harness itself doesn’t cost money. You still pay for the model, or supply the hardware to run it.
Free inference: A company is temporarily paying the cost of your model requests.
Free subscription tier: You receive a limited allowance before paying, waiting for a reset, or switching to a cheaper model.
OpenCode’s free-tier controversy
In August and September, r/opencode users discussed free allowances commonly described as approximately 200 requests per day. By October, some began reporting far shorter effective usage. An October 9 thread included users saying free service stopped after only minutes. On October 23, users noticed changes in the displayed free-tier language. On October 26, others reported limits that appeared not to reset properly. And an October 27 discussion described a user receiving another 24-hour restriction after a single new request. Some commenters blamed abuse of anonymous access. Others suspected technical defects or deliberate tightening. There isn’t good evidence to definitively attribute every incident to one cause. But the user experience is clear: “Free” can mean many hours of productive development one week and barely enough time to start a task the next.
OpenCode Go: Better Value, But Still Limited
OpenCode’s paid Go service currently advertises a $10 monthly plan and a $40 Go Plus tier. Go uses model-specific allowances denominated in usage value. For a model with a $60 monthly allowance, the documented limits are:
| Usage period | Allowance |
|---|---|
| Five-hour window | $12 |
| Weekly | $30 |
| Monthly | $60 |
Some higher-cost models receive substantially smaller monthly allowances, such as $15, meaning a $3 five-hour allowance and $7.50 weekly allowance. These are internal metered usage allowances, not cash credits that can simply be withdrawn or assumed interchangeable with every other model. The nominal economics are attractive. Under favorable conditions, a $10 subscription can provide usage valued well above the subscription price. But we run into a short-term limits quickly. Our strategy is to use cheaper models for routine implementation and reserve expensive models for architecture, difficult debugging, and independent review. The problem is that not every development task divides neatly along those lines.
6. What Do AI Coding Agents Really Cost?
Consider a moderately intensive engineering workload consuming:
- 20 million input tokens
- 2 million output tokens
- No prompt caching discounts
Using published standard API prices as of October 2026:
| Model | Input / 1M | Output / 1M | Estimated workload cost |
|---|---|---|---|
| GPT-6 Luna | $0.10 | $0.50 | $3 |
| GPT-6.1 Sol | $2 | $10 | $60 |
| Claude Sonnet 5.5 | $2 | $10 | $60 |
| Claude Opus 5.5 | $4 | $20 | $120 |
Sources: OpenAI API pricing and Anthropic API pricing.
These calculations are illustrative direct API costs, not subscription consumption guarantees. They exclude cache writes, tools, special processing rates, infrastructure costs, taxes, and model-specific context surcharges. The same nominal token workload can cost $3 or $120, a 40-to-1 difference before accounting for whether the cheaper model actually completes the task correctly.
The hidden multiplier: agent overhead
An AI harness doesn’t send only your original question to the model, it repeatedly transmits project instructions, code excerpts, tool outputs, conversation history, and summarized context. Subagents multiply that workload, retries multiply it further. Failed runs consume substantial amounts of inference without delivering a usable result. For long-running projects, this overhead becomes a much larger cost than the initial code-generation request. Prompt caching reduces some of that burden, but it isn’t a universal solution, particularly when prompts change frequently or previously cached material expires.
7. Our Experience: The Harness Is Only Half the Engineering System
Our projects have exposed a distinction that doesn’t get enough attention in the AI coding industry. There’s a difference between an agent successfully producing code and a system reliably completing an engineering mission. We’ve used OpenCode-driven agents to work on a Django-based server administration application, a local-model manuscript editor, and computational cosmology research. These involve substantial existing repositories, interacting components, deployment environments, formal tests, scientific requirements, and long execution times. There are the recurring problems that emerged:
First, the agent can declare success before the result is acceptable.
A patch passes its unit tests while breaking the production installation process, a scientific routine produces a mathematically consistent result while violating an independent physical constraint, and a manuscript editor completes several chunks while silently leaving part of the novel unreviewed. In all three cases, success was reported by the agent in the harness.
Second, the agent can lose the mission while pursuing the implementation.
Long contexts are vulnerable to compression, dropped requirements, stale assumptions, and contradictory instructions. When an agent’s working memory becomes unreliable, it solves a different problem from the one originally assigned. I have to constantly focus the agent back into project goals.
Third, failure recovery is often surprisingly primitive.
A network interruption, model timeout, database problem, or exhausted allowance leaves incomplete work in an ambiguous state. Without durable checkpoints and explicit recovery rules, restarting the job may duplicate previous work or overwrite valid artifacts.
Fourth, autonomous systems require independent verification.
For our server administration application, that means headed Selenium browser tests, backend log inspection, and a final human-controlled production installation. For our scientific software, it means independent numerical checks, immutable evidence, and hard stop conditions when a hypothesis fails. For the manuscript editor, it means tracking every expected section, recovering interrupted jobs, and checking the actual delivered document. These procedures are not glamorous, but they’re what separates an impressive demonstration from a trustworthy production workflow. We eventually formalized this approach around explicit acceptance conditions, bounded implementation, real execution, evidence collection, adversarial review, and human approval.
8. Are Local LLMs the Answer?
Running a language model locally changes the economics: it removes recurring per-token API charges for the locally executed inference. It also offers greater control over model versions, data handling, scheduling, and access. For our OpenCode setup, this is a major advantage. Using a quantized 27-billion-parameter Qwen-family model on a 24 GB GPU has allowed us to perform significant automated work without depending entirely on commercial subscriptions. But local inference isn’t free.
There’s hardware depreciation, electricity, maintenance, and the opportunity cost of slower execution. MUCH SLOWER. There’s also a substantial difference between operating a model successfully and getting reliable agentic behavior from it. Smaller models struggle with large repositories, complicated tool calls, long-horizon planning, and adherence to complex instructions. In our experience, local models become substantially more useful when work is broken into bounded tasks with explicit interfaces and machine-checkable outcomes. So we use a hybrid strategy: Use local or inexpensive models for routine implementation, repeated analysis, and well-bounded tasks. Stronger cloud models when difficult reasoning materially improves the probability of success. and independent tests to decide whether either model has done the job.
9. Reddit’s Verdict: Developers Love the Capability and Hate the Uncertainty
Across r/opencode, r/ClaudeCode, r/codex, and r/cursor, three themes keep appearing. Developers are genuinely impressed with what coding agents can accomplish. Many report completing tasks that would previously have required far more time or expertise. They also complain that limits and pricing are difficult to understand, can change, and sometimes interfere with work at inconvenient moments. Finally, they complain about inconsistent behavior: forgotten instructions, context-compaction errors, unproductive loops, incomplete changes, and agents that seem more confident than competent. These discussions are not representative surveys. People with problems are often more motivated to post, and enthusiastic users sometimes overstate how dramatically their productivity has improved. But the complaints shouldn’t be dismissed. In October 2026, a Claude Code user described building an external display to monitor five-hour and weekly usage limits using Claude Code itself to build the monitoring system.
That’s a almost perfect metaphor for the industry. The technology is sophisticated enough to write the software that monitors its own restrictions, yet those restrictions have become intrusive enough that people want dedicated hardware to keep track of them.
See the discussion on r/ClaudeCode.
10. What the Industry Needs to Fix
The next competitive advantage will come from systems that improve the reliability and economics of actual development. We need transparent accounting of effective usage, including caching, reasoning, subagents, and retries, eliable checkpoints, bounded session storage, and recoverable agent execution. Better separation between planning, implementation, testing, and acceptance. We need harnesses that can explain what was actually verified instead of merely announcing that the work is complete.
We need better visibility into the real cost of completed tasks. A useful metric would be: Cost per independently accepted engineering task. Not cost per million tokens, cost per prompt, benchmark performance in isolation. How much does it cost to get a correct, tested, maintainable result that a human can actually use?
Sources and methodology
Developer adoption figures come from the JetBrains Developer Ecosystem Survey 2026 and the Stack Overflow Developer Survey 2026. Pricing and limits were checked against the Claude plans, OpenAI Codex documentation, Cursor pricing, OpenCode Go documentation, GitHub Copilot pricing, and Cline pricing.
Community observations draw on publicly available threads from r/opencode, r/ClaudeCode, r/codex, and r/cursor, together with OpenCode’s public GitHub issue tracker. These are illustrative experiences, not statistically representative samples. The firsthand project experience concerns our OpenCode and local-model engineering work; comments about competing harnesses are based on public documentation and community reporting rather than a controlled comparative trial.
All prices and offerings are subject to change. API cost comparisons are calculated illustrations, not quotations for completed engineering projects.