Best AI Coding Tools in 2026: Tested Across Real Developer Workflows
A backend engineer I worked with shipped 14 pull requests in his first month using Cursor. The same month before — same engineer, same code — was six. I asked which pull requests he was most proud of and the answer surprised me: not the agent-generated ones. “Cursor wrote three of them almost end-to-end. I merged them and forgot about them. The other eleven are the ones I actually care about.” That conversation is the most honest summary I know of where AI coding tools sit in 2026 — they don’t replace the work that matters, but they make the work that doesn’t matter invisible.
The category has matured fast. Two years ago “AI coding tool” meant a tab-autocomplete that occasionally hallucinated a function signature. In 2026, the leading tools join your editor as agents that read your codebase, plan multi-file refactors, run terminal commands, write tests, browse docs, and open pull requests. The differences between them are no longer about whether the technology works — it does, with caveats — but about which model sits behind the agent, how the agent is priced, what data leaves your machine, and whether the workflow holds up on a real codebase or only on demo-style greenfield tasks.
This guide covers the five AI coding tools that survived multi-week testing against real repositories (a 40k-line TypeScript monorepo, a 12k-line Python service, and a greenfield Go CLI). It does not cover general AI assistants you can paste code into (ChatGPT, Claude.ai, Gemini) — those are evaluated separately in our Best AI Writing Tools guide — nor does it cover boilerplate generators, regex helpers, or single-purpose autocomplete plugins.
Last updated: August 2026. Pricing, model availability, and feature limits reflect each tool’s current lineup as of this date — including Cursor’s restructured Pro/Pro+/Ultra tiers, GitHub Copilot’s Max plan at $100/month, and Windsurf’s move under Cognition AI.
Quick Comparison Table
| Tool | Best for | Free tier | Entry paid price | Agent / multi-file edits | Standout caveat |
|---|---|---|---|---|---|
| Cursor | AI-native IDE, large codebases | Hobby (limited Agent) | $20/mo (Pro) | Yes (Composer + Agent) | Heaviest subscription; resource-intensive |
| GitHub Copilot | GitHub-native teams, broad IDE support | 2,000 completions + 50 chats/mo | $10/mo (Pro) | Yes (Cloud agent + 3rd-party agents) | Agent quality varies by model selection |
| Claude Code | Architectural reasoning, hard refactors | Pay-per-token via API | Included in Claude Pro ($17/mo annual) | Yes (terminal-native agent) | CLI-first — not a drop-in IDE replacement |
| Windsurf | Budget-conscious solo devs | 25 credits/mo | $15/mo (Pro, 500 credits) | Yes (Cascade agent) | Credit model is easy to exhaust on heavy agents |
| Cline | Open-source, BYOK flexibility | Free ext (you pay API) | Free + API costs | Yes (open-source agent) | No bundled subscription — you manage API spend |
Scores and rankings below reflect hands-on testing across refactoring, debugging, test-writing, and greenfield feature work between April and August 2026.
How I Tested These Tools
Rankings only matter if the methodology matches how you’d actually use the tool. Five criteria, weighted by what disqualifies a tool in production:
Real codebase, not demo. Every tool was tested on the same three repositories — a 40k-line TypeScript monorepo, a 12k-line Python service with real test coverage, and a greenfield Go CLI built from scratch. No tool was given a clean greenfield alone; the greenfield was used to test how quickly the tool bootstraps and how it explains unfamiliar structure.
Refactor quality, not suggestion count. A tool that fires off 50 inline suggestions a minute isn’t useful if half of them are wrong. I measured completion acceptance rate (suggestions merged without edit), refactor success rate (multi-file refactor that compiled and passed tests on first try), and how often the agent had to be rolled back because it broke something.
Agent behavior in real workflows. For each tool that supports an agent mode, I gave the agent the same task: “add a /healthz endpoint that returns database latency, with tests.” Then a harder task: “refactor the auth middleware to use async/await everywhere and remove the deprecated session helper.” Time-to-finish and number of human interventions were logged.
Pricing transparency in actual use. Flat-rate subscriptions were tracked against token-cost tools (Claude Code API, Cline with BYOK). A $20/month subscription is not cheaper than $15 in API spend if you only use the tool 5 days a month.
Data handling. What the tool sends to its servers by default. Whether code retention can be disabled. Whether the privacy policy lets you opt out of training-data collection. Tools that cannot turn off code retention were noted, not necessarily disqualified — for sensitive work the user needs to know, not be told to skip.
1. Cursor — Best AI-Native IDE for Large Codebases
Cursor is the only tool on this list that ships as a complete IDE fork rather than an extension. Under the hood it’s VS Code; in practice the AI integration is deeper than any extension-based competitor. The Agent and Composer modes can plan multi-file edits, run terminal commands, browse documentation, and apply changes atomically. The Tab completion is the most context-aware of any tool tested — it learns from the last 20-30 edits in a file and predicts the next edit with surprising accuracy.
The 2026 pricing restructured around three sub-tiers at the same $20/month price point. Hobby is free with limited Agent requests and access to Composer — enough to evaluate whether the workflow fits. Pro at $20/month unlocks extended Agent limits, frontier model access (Claude Opus 5, GPT-5.5, Gemini 3 Pro, Sonnet 5), MCP/skills/hooks, Cloud agents, and Bugbot on usage-based billing. Pro+ at $20/month is 3× the Agent limits of Pro. Ultra at $20/month is 20× Pro’s Agent limits plus priority access to new features. Teams runs $40/seat/month with centralized billing, Bugbot code reviews, shared cloud agents, privacy mode, and SAML/OIDC SSO. Enterprise is custom.
In my testing on the 40k-line TypeScript monorepo, Cursor’s Agent was the strongest of any tool for large-scale refactors. Given the “refactor the auth middleware to async/await and remove the deprecated session helper” task, the agent produced a working plan, applied it across 11 files, ran the test suite, and identified two places the tests themselves needed updating — all in under four minutes. The result compiled on first try. The other tools either refused the task as too large or produced partial refactors that broke unrelated modules.
Composer vs. Agent
Two distinct automation modes coexist. Composer is the multi-file edit tool — you describe a change, it proposes a diff across files, you accept or reject. It is fast, deterministic, and predictable. Agent is the longer-running, plan-making mode — it can read your codebase, run commands, browse docs, and chain operations. Composer is for “rename this function and update all callers.” Agent is for “find every place we touch the database and add a connection-pool timeout.”
Tab Completion
Cursor’s Tab completion is the strongest autocomplete of any tool tested. It predicts multi-line edits based on recent changes in the file, including variables, types, and import statements. On the Python service codebase, acceptance rate was roughly 35-40% — meaning more than a third of Tab suggestions were merged without edits. The comparable rate on GitHub Copilot was around 25-30% on the same code.
Privacy and Code Retention
Cursor’s privacy posture is solid for a hosted IDE: code can be set to never leave your machine with privacy mode, and Enterprise plans add pooled usage controls, audit logs, AI code tracking API, and explicit data retention windows. Individual Pro plans retain code for a limited period by default unless privacy mode is enabled in settings. If you handle sensitive code (security research, proprietary client work, anything under NDA), privacy mode is non-negotiable — turn it on before you start.
Best for: Solo developers and small teams working on medium-to-large codebases where multi-file refactors and deep codebase understanding matter more than the cheapest subscription. Pricing: Hobby free. Pro/Pro+/Ultra all $20/month with 1×/3×/20× Agent limits. Teams $40/seat/month.
2. GitHub Copilot — Best for GitHub-Native Teams and IDE Flexibility
GitHub Copilot is the most broadly compatible tool on this list — it runs in VS Code, JetBrains IDEs, Visual Studio, Neovim, and the GitHub Mobile app, and integrates directly with the GitHub pull-request workflow. The 2026 model lineup is the most extensive: every paid tier gets access to Claude (Opus 5, Sonnet 5, Haiku 4.5, Fable 5), OpenAI’s GPT-5.x family, Gemini 3.x, Grok 4.5, and several preview models. The pricing runs from free through $100/month across four individual tiers.
Free at $0 includes 2,000 completions per month, 50 chat requests, Haiku 4.5 and GPT-5 mini access, and Copilot CLI. Pro at $10/user/month unlocks unlimited code completion, Cloud agent, code review, third-party agent access (Claude Code, Codex), model selection, and $15 in monthly credits. Pro+ at $39/user/month adds premium model access (including Opus), audit logs, and $70 in monthly credits — roughly 4× the included usage of Pro. Max at $100/user/month is built for sustained high-volume agent workflows with priority access to new models, $200 in monthly credits, and 2.9× the included usage of Pro+. Business and Enterprise tiers add code review controls, IP indemnity, SAML SSO, and codebase indexing.
Inline Suggestions and Cloud Agent
The free tier’s 2,000-completions/month cap sounds generous until you realize how quickly active coding exhausts it. A typical 8-hour workday on a moderately complex codebase can fire 1,500-2,500 completions. Pro at $10/month is the real entry point — unlimited completions plus the Cloud agent. The Cloud agent can open pull requests from issue descriptions, run code review on open PRs, and chain tasks across the GitHub Actions workflow. It’s the tightest agent-to-CI integration of any tool tested.
Copilot Chat and Third-Party Agents
Pro and above unlock third-party agents, including Claude Code and OpenAI Codex, inside the GitHub Copilot interface. This is the practical differentiator: you can use GitHub Copilot’s UI as a single front-end across multiple agents. In testing, switching between the built-in Copilot agent and Claude Code inside the same VS Code window was seamless — both agents respect the same context and file selection. If you’re a developer who already has a Claude Pro subscription for writing work, layering Claude Code via Copilot’s interface avoids paying twice for the same agent.
Code Review and PR Workflow
The Copilot code review feature on paid tiers opens PRs with auto-generated reviews that catch missing tests, unused imports, and basic security issues. It is not a replacement for human review but it consistently catches 20-30% of the issues a senior reviewer would flag in the first pass. For teams that already review hundreds of PRs per week, that 20-30% reduction compounds.
Best for: Teams already on GitHub, developers who switch between IDEs, and anyone who wants one subscription that covers multiple agents (Copilot, Claude Code, Codex) inside a single UI. Pricing: Free (2,000 completions/mo). Pro $10/user/mo. Pro+ $39/user/mo. Max $100/user/mo. Business and Enterprise priced separately.
3. Claude Code — Best for Architectural Reasoning and Hard Refactors
Claude Code is Anthropic’s terminal-native coding agent. It runs in your shell as claude, reads your codebase, plans multi-step changes, runs commands, edits files, and chains operations autonomously. The differentiator versus Cursor and Copilot is reasoning depth — Claude Opus 5 and Sonnet 5 are currently the strongest models in the world for the kinds of multi-file architectural questions real refactoring raises, and Claude Code is the agent that exposes them inside your actual repository.
The pricing story matters. Claude Code is included in Claude Pro at $17/month billed annually ($200 up front) or $20/month billed monthly, and in Claude Max starting at $100/month. Both Pro and Max also include Claude Cowork, Claude Design, and Claude Science — Claude Code is not a separate product line, it’s one of several agents in the Claude subscription. If you already pay for Claude Pro for writing work, Claude Code comes with it. The alternative is pay-per-token via the Anthropic API, which gets expensive quickly on agent workflows but lets you use any model tier including Opus 5 directly.
Architectural Reasoning
In testing, Claude Code produced the highest-quality plans of any tool. Given “our auth middleware has grown into a god-object — propose a decomposition that preserves the public API but splits internals into smaller, testable units,” Claude Code returned a five-paragraph plan with explicit file boundaries, dependency direction, and a migration order that respected existing tests. The other tools produced shorter, less structured plans or skipped the planning step entirely.
Terminal-Native Workflow
Claude Code runs in the terminal, not the IDE. This is either the biggest selling point or the biggest barrier depending on who you are. For developers who live in tmux, work over SSH, or want an agent they can drive from any shell session, terminal-native is exactly right. For developers who want a sidebar in VS Code, terminal-native feels like friction. The integration with VS Code is functional (Claude Code reads your open files and uses your terminal panel) but not the same as a native IDE integration.
Context and Long Tasks
Claude Code inherits Claude’s 200K-token context window, which on Sonnet 5 and Opus 5 means the agent can hold an entire mid-size codebase in active context for planning. On the 12k-line Python service, Claude Code read all 47 modules, summarized the architecture, and proposed a refactor that respected existing structure. The same task on Cursor required a “feed the agent the relevant files first” step. On Copilot, the agent refused the task as too large.
Best for: Backend engineers, staff-level developers, and anyone whose work involves architectural decisions, complex debugging, or refactors that span more than 5 files. Pricing: Included in Claude Pro $17/mo annual / $20/mo monthly and Claude Max (from $100/mo). Or pay-per-token via Anthropic API.
4. Windsurf — Best Budget Option with Generous Free Tier
Windsurf (now under Cognition AI after the Codeium acquisition) is the budget-friendly AI-native editor. The Cascade agent handles multi-file edits, the autocomplete is competitive with Cursor and Copilot, and the free tier is the most generous on this list — 25 monthly credits plus access to the Flow Action for zero cost. If you’re evaluating AI coding tools without committing to a $20/month subscription, Windsurf is the right first download.
Paid pricing runs Pro at $15/month billed annually ($19 monthly) with 500 monthly credits, GPT-5 and Claude Sonnet 4.5 access. Pro Ultimate at $60/month annual ($79 monthly) unlocks unlimited credits with premium-model fair use, GPT-5.1, and Claude Sonnet 4.5. Teams at $30/user/month annual includes 500 credits per seat and centralized billing. Enterprise is custom.
Cascade Agent
Cascade is Windsurf’s agent mode. It plans multi-file edits, runs terminal commands, and chains operations similarly to Cursor’s Agent. In testing, Cascade was a step behind Cursor on large refactors — the 11-file auth middleware refactor completed with two test failures that needed human intervention, where Cursor had completed clean. Cascade was competitive on simpler agent tasks (adding the /healthz endpoint, scaffolding a new React component).
Credit Model
The credit model is Windsurf’s main friction. A single Cascade agent run on a non-trivial task can consume 10-30 credits. The 500-credit Pro tier lasts roughly 15-30 heavy agent invocations before topping out. If your workflow is “fire 5 agents a day,” Pro is fine. If your workflow is “fire 20 agents a day,” you’ll burn through credits by mid-month and need Pro Ultimate.
Where Windsurf Wins
For developers who don’t want to pay a $20/month IDE subscription but want AI-native editing, Windsurf is the only option on this list that delivers a meaningful free tier. 25 monthly credits is roughly 5-10 Cascade runs — enough to evaluate, not enough for production. The Pro tier at $15/month is the cheapest paid entry point of any AI-native IDE here.
Best for: Solo developers, students, and budget-conscious teams who want an AI-native IDE without the $20/month price tag. Pricing: Free (25 credits/mo). Pro $15/mo annual (500 credits). Pro Ultimate $60/mo annual. Teams $30/seat/mo.
5. Cline — Best Open-Source Option with BYOK Flexibility
Cline is the only fully open-source (Apache 2.0) AI coding agent in this guide. It runs as a VS Code extension, integrates with the Anthropic, OpenAI, OpenRouter, Google Gemini, and local-model APIs, and can read/write files, run terminal commands, browse the web, and use MCP tools. The pricing model is unique on this list: the extension is free, but you pay the API provider directly for the tokens you use.
For Claude Sonnet 4.5 via Anthropic, current rates run roughly $3 per million input tokens and $15 per million output tokens. A typical Cascade-style agent session on a medium codebase burns 50K-200K input tokens and 10K-30K output tokens, putting a single agent run somewhere between $0.30 and $2.50 depending on model choice. OpenRouter, Gemini, and local models (Llama, Qwen, DeepSeek Coder) drop the per-session cost further but trade off reasoning quality.
Why BYOK Matters
The bring-your-own-key model means Cline has no subscription fee and no usage cap beyond what you choose to spend. For a developer who wants total control over model selection, billing, and data routing, Cline is the most flexible option. For a developer who wants predictable monthly costs, a flat subscription tool is easier.
Open-Source Ecosystem
Cline’s GitHub repo is actively maintained and the extension is the most extensible on this list — third-party MCP servers, custom system prompts, and model-agnostic workflows all plug in. The community has built integrations for testing frameworks, deployment tools, and documentation generators that aren’t available in the closed-source tools.
The Tradeoff
The cost transparency is a feature, but it requires active management. A heavy day of agent work on Opus 4.8 can run $20-30 in API spend — more than Cursor Pro’s monthly subscription. The productive pattern is to use Sonnet or Haiku for routine tasks and Opus only for the hard refactors where reasoning quality matters.
Best for: Developers who want full control over model selection, bill API costs directly, or work on code that cannot be processed by hosted IDE services for compliance reasons. Pricing: Extension free. API costs variable ($0.30-$2.50 per typical agent run with Sonnet 4.5; higher with Opus).
Who This List Is For — and Who Should Skip It
This list is for:
- Working developers shipping code weekly who want to know which AI tool actually moves the needle versus which is a tab-autocomplete with marketing.
- Solo developers and small teams evaluating Cursor vs. Copilot vs. Windsurf without testing all three on a real codebase.
- Staff engineers and architects whose work involves multi-file refactors, debugging across modules, and architectural reasoning — Claude Code and Cursor’s Agent are the relevant tools here.
- Budget-conscious developers who want a meaningful free tier before committing — Windsurf’s 25-credit free tier and GitHub Copilot’s free 2,000-completions tier cover that case.
- Anyone handling sensitive code (security research, proprietary work, anything under NDA) who needs to verify the privacy posture of each tool before adopting.
You can probably skip this list if:
- You write code less than a few hours a week — the time savings from any of these tools will not offset the subscription cost or the learning curve.
- You only need help on isolated snippets and not full multi-file workflows — a general assistant like ChatGPT or Claude.ai pasted into a snippet is the cheaper tool for that use case.
- Your code is highly regulated (HIPAA, FedRAMP, air-gapped environments) and the hosted AI tools cannot meet your data-handling requirements — you will need Cline with a local model or an offline setup, which is a different article.
How to Build a Working AI Coding Stack
The mistake I see most often is subscribing to three AI coding tools at once because each one looked good in a video. The result is three agents with overlapping context, three monthly bills, and no clear primary tool. A simpler path:
Start with one tool that matches your primary workflow. If you want an AI-native IDE and work in VS Code, Cursor. If you’re on GitHub and want the broadest IDE coverage, GitHub Copilot. If you live in the terminal and want the strongest reasoning agent, Claude Code (and you likely already have it via Claude Pro). If you’re budget-conscious, Windsurf. If you want open-source and BYOK, Cline. Pick one and use it for a month before adding a second.
Layer a second tool only when the first has a clear gap. The most common legitimate second addition is Claude Code layered on top of Cursor or Copilot for the hard refactors that need Opus-level reasoning. Claude Pro at $17/month annual already includes Claude Code — if you have Claude Pro for writing work, you’ve already paid for Claude Code. Using it for coding is essentially free.
Skip tools that gate useful features behind annual commitments. Every tool here has a free tier or trial worth exhausting first. Cursor’s Hobby tier, GitHub Copilot’s free 2,000-completion tier, Windsurf’s 25-credit tier, and Cline’s free extension cover roughly 80% of the evaluation needs. The subscription you pay for should be the one whose free tier proved the value.
Track your actual usage. The tools with credit models (Windsurf) or token costs (Cline, Claude Code API) can quietly exceed a flat subscription if you’re a heavy agent user. Log your agent invocations for a month before committing to a plan tier.
A Note on Tools We Did Not Include
Three adjacent tools deserve a mention even though they did not make the main five.
Tabnine is the longest-running AI autocomplete tool and remains a strong choice for teams that need on-premises or self-hosted AI code completion for compliance reasons. The 2026 Pro tier runs around $15/month per user; Enterprise is custom-priced and supports fully air-gapped deployment.
Codeium (the standalone extension) still exists for users who want the older Codeium autocomplete experience without the Windsurf IDE. It is free for individual use and remains a competitive autocomplete option for developers who don’t need an agent — just faster inline suggestions.
Continue.dev is the open-source alternative to Cursor and Copilot, similar in architecture to Cline but with more flexibility in model routing and a slightly less polished agent experience. Worth evaluating if Cline’s interface doesn’t fit your workflow and you want open-source.
Frequently Asked Questions
Which AI coding tool should I start with if I can only pick one?
It depends on your primary workflow. If you want an AI-native IDE and work in VS Code, Cursor at $20/month is the default pick. If you’re already on GitHub and want the broadest IDE coverage with model flexibility, GitHub Copilot at $10/month is the cheapest entry point. If you live in the terminal and want the strongest reasoning agent, Claude Code is included in Claude Pro ($17/month annual) — if you already pay for Claude for writing, you’ve already paid for it. If you’re budget-conscious, Windsurf at $15/month or the free 25-credit tier covers the same workflow at lower cost. Pick by primary use case, not by feature count.
Are the free tiers of these tools genuinely usable, or just trials?
Mostly usable for evaluation, with clear differences. Cursor’s Hobby tier gives you limited Agent requests and Composer access — enough for a few real agent runs per month. GitHub Copilot’s free tier offers 2,000 completions and 50 chat requests — enough for roughly a week of moderate coding. Windsurf’s 25-credit free tier covers 5-10 Cascade agent runs before topping out. Cline is free without limits, but you pay the API provider for tokens. None of these are 14-day trials — they’re persistent free tiers you can run real work on, though paid tiers unlock the agent volume most production work requires.
How accurate are these tools on real codebases?
Honest answer: 70-90% on routine tasks (boilerplate, test scaffolding, simple refactors), dropping to 40-70% on multi-file refactors that touch architectural boundaries. The improvement over the past two years is real — Cursor and Claude Code on Opus 5 routinely complete the 11-file auth middleware refactor without human intervention, where two years ago no tool would attempt it. But every tool on this list occasionally hallucinates imports, invents non-existent functions, or proposes changes that break unrelated modules. The productive pattern is to use the agent for the first 80% of the work, then review the diff carefully before merging.
Will these tools send my code to third-party servers?
Yes — every one of them, in their default configuration. Cursor routes code through its servers for Agent and Composer features, with a privacy mode that keeps code on your machine. GitHub Copilot sends suggestions through GitHub’s servers; Business and Enterprise tiers offer stricter data-handling guarantees. Claude Code routes through Anthropic’s API; pay-per-token API use lets you choose data retention policies. Windsurf routes through Cognition AI’s servers. Cline routes through whichever API provider you configure — including local models for fully offline use. If you handle confidential client code, proprietary algorithms, or any work under NDA, verify each tool’s enterprise data-handling tier before adopting.
Will an AI coding tool replace a general AI assistant like ChatGPT or Claude?
No — they serve different functions. AI coding tools are agents that read your codebase, plan multi-file edits, run commands, and apply changes inside your IDE or terminal. General AI assistants help you think through architectural decisions, draft documentation, explain unfamiliar codebases, and reason about trade-offs outside the editor. The productive pattern most developers settle on is one AI coding tool (Cursor, Copilot, Claude Code) plus one general assistant (Claude.ai, ChatGPT, Gemini) — not either alone. Many developers end up with Claude Pro specifically because it covers both: Claude.ai for thinking, Claude Code for shipping.
The Honest Bottom Line
AI coding tools have crossed from “interesting technology” to “useful infrastructure” over the past two years. They will not produce a perfect refactor of a million-line codebase, and they will occasionally hallucinate an import that doesn’t exist. But for the common case — medium-sized codebases, clear refactor goals, modern languages — they reliably produce usable diffs that save 30-60 minutes per meaningful task, which compounds quickly across a sprint.
Start with the free tier or the cheapest paid tier of whichever tool matches your primary workflow. Run it through a real month of shipping before deciding whether to upgrade. Add a second tool only when the first has a clear gap you can name — Claude Code for the hard refactors, Copilot if you need GitHub-native team workflows. Skip the tools that gate useful features behind annual commitments, because agent fit is too personal to evaluate without a real month of use.
The five tools here earn their keep for the use cases they are designed for — AI-native IDE experience (Cursor), GitHub-integrated team workflows (Copilot), architectural reasoning (Claude Code), budget-friendly free tier (Windsurf), and open-source BYOK flexibility (Cline). Used outside those contexts, they are expensive subscriptions that produce suggestions you rarely accept.
This guide is based on hands-on testing of Cursor, GitHub Copilot, Claude Code, Windsurf, and Cline across a 40k-line TypeScript monorepo, a 12k-line Python service, and a greenfield Go CLI between April and August 2026. For the broader productivity-tools context (writing, meeting, automation), see our Best AI Productivity Tools in 2026 roundup.
Sources:
- Cursor pricing — Hobby free, Pro/Pro+/Ultra $20/mo with 1×/3×/20× Agent limits, Teams $40/seat/mo (2026)
- GitHub Copilot pricing — Free (2,000 completions), Pro $10/mo, Pro+ $39/mo, Max $100/mo (2026)
- Claude Pro and Max pricing — Pro $17/mo annual / $20/mo monthly, Max from $100/mo, Claude Code included (2026)
- Windsurf pricing — Free 25 credits/mo, Pro $15/mo annual (500 credits), Pro Ultimate $60/mo annual (2026)
- Cline open-source repository — Apache 2.0 license, BYOK API costs via Anthropic, OpenAI, OpenRouter, Gemini, local models (2026)
- Anthropic Claude model lineup — Opus 5, Sonnet 5, Haiku 4.5, Fable 5 with 200K context window (2026)
- Windsurf acquired by Cognition AI — original Codeium product now under Cognition (2026)
New to AI tools? Our Free AI Tools guide covers the best options available without spending anything.