Living dossier

AI Coding

Back to topics•Blog
Mehran Mozaffari·
9 resources0 related posts

AI coding is four products wearing one label

The phrase "AI coding" covers at least four distinct products, and the conflation is why most tool discussions go in circles. Inline completion — the Copilot-shaped ghost text that suggests the next line — is a latency product measured in milliseconds and accepted-or-dismissed keystrokes. Chat-in-IDE is a context product measured by how much of your repository the assistant can see. The agentic terminal and IDE loop — read the repo, plan, edit files, run commands, check results, repeat — is an execution product measured by resolved tasks and review burden. And autonomous delegation — agents that run on schedules or in the background while you do something else — is an operations product measured by trust accumulated over hundreds of runs. Copilot's own plans page now lists all four shapes in one product: agent mode across five IDEs, a CLI, code review, and a cloud agent, billed through a credits ledger.

What gets miscategorised most often: benchmarks and tools. SWE-bench Verified is a benchmark of agentic issue-solving on Python repositories — 500 human-validated instances — and it says nothing meaningful about inline completion quality or about your JavaScript monorepo. Conversely, a completion engine is not an agent: it has no loop and takes no actions. The other recurring confusion is between the harness and the model. Every tool in this dossier is, at bottom, a context-packaging and permission layer in front of a small set of frontier models; choosing a tool is choosing a workflow, a trust model, and a bill, not choosing intelligence.

I have used several of these tools daily and read the primary documentation — repositories, licence files, pricing pages, and the SWE-bench site — for all of them before writing this. The positions are mine; the facts are theirs.

The agentic loop is table stakes; the permission policy is the product

Strip the branding and the terminal and IDE agents all implement the same skeleton: maintain a conversation with a model, expose tools (read files, write files, run shell commands, search the web), gate those tools against a permission policy, and let the model iterate until it declares completion. What separates products is where they place the human in that loop and how they bound it.

The spectrum runs from Aider's diff-first discipline — every change lands as a reviewable git commit with a sensible message — through Cline's explicit approval gates, where "every file edit and terminal command requires your approval" until you deliberately toggle auto-approve, to headless modes that remove the human entirely: Cline's CLI pipes input and emits JSON for CI pipelines, and Gemini CLI runs non-interactively with structured JSON output for scripts. The interesting design question each product answers differently is what happens when the model is wrong: Aider answers with git (undo is native), Cline with checkpoints and diffs, Cursor with its own checkpoint system, and the credits-billed incumbents mostly answer with your patience.

flowchart TD
    PROMPT["Task from developer"] --> CTX["Context assembly: repo map, rules files, attached files"]
    CTX --> MODEL["Model proposes edits or commands"]
    MODEL --> GATE{"Permission policy"}
    GATE -->|"approve each action"| HUMAN["Developer reviews every diff and command"]
    GATE -->|"auto-approve within bounds"| RUN["Agent executes and monitors linters and tests"]
    RUN --> VERIFY{"Checks pass"}
    VERIFY -->|yes| COMMIT["Commit or checkpoint"]
    VERIFY -->|no| MODEL
    HUMAN --> COMMIT
    COMMIT --> PR["Pull request and human review"]

The same skeleton extends past the interactive session into delegation, and the delegated path is where the tooling differences become operational. Cline's Kanban gives each task card its own git worktree so parallel agents cannot trample each other's edits; its scheduled agents run prompts on cron against a named workspace; its headless mode accepts piped input and emits JSON events that a pipeline can filter. Gemini CLI's GitHub Action does the review side — pull-request comments, issue triage, on-demand @gemini-cli mentions — from inside the forge rather than the terminal. The shape of a delegated run:

sequenceDiagram
    participant Dev as Developer
    participant Board as Task board or scheduler
    participant A as Agent in worktree
    participant R as Repository
    participant H as Human reviewer

    Dev->>Board: File task with scope and checks
    Board->>A: Spawn agent in isolated worktree
    A->>R: Edit files, run tests, iterate
    A->>R: Commit to branch
    A-->>Board: Result and evidence
    Board->>H: Open pull request for review
    alt review passes
        H->>R: Merge
    else review fails
        H->>Board: Reopen task with findings
    end

Two properties of that flow deserve attention before you adopt it. The worktree is the safety mechanism — without per-task isolation, parallel agents edit the same working tree and the merge is where the run actually fails. And the human review at the end is not a formality: it is the only step in the diagram that cannot be delegated back to the agent without giving up the property that makes delegation trustworthy in the first place. Teams that ship delegated-agent output straight to main exist; I would not be one of them.

The open-source terminal cohort is where the ideas ship first

Five open-source tools define the terminal cohort, and each is a distinct bet about what matters.

Aider is the elder statesman: Apache-2.0 licensed (verified against the repository's licence file), 6.8 million installs, and a self-reported fifteen billion tokens processed weekly by its users. Its signature idea is the repository map — a compressed representation of the whole codebase's structure so the model can work in large projects without reading every file — plus automatic git commits, a lint-and-test loop after every change, and a leaderboard culture that made aider's own benchmarks a reference point for the field. The README's badge I find most telling: 88 percent of the code in aider's last release was written by aider itself. My position: still the precision tool for working inside an existing, messy codebase where you want every change reviewable and reversible, and the best-architected codebase in the cohort to read.

Codex CLI is OpenAI's local agent, Apache-2.0, installed by a piped shell script, npm, or Homebrew. The strategic content is the auth split: sign in with a ChatGPT Plus, Pro, Business, Edu, or Enterprise plan and Codex rides your subscription, or use an API key for metered usage. The family around it matters as much as the CLI — Codex Web as a cloud agent, IDE extensions for VS Code, Cursor, and Windsurf, and a desktop app — making OpenAI's play a multi-surface agent brand rather than a terminal tool. My position: the default choice if you are already paying for ChatGPT at the right tier; the closed-model coupling is the trade.

Gemini CLI is Google's Apache-2.0 answer, and its README leads with the number that reset the market's price expectations: a free tier of 60 requests per minute and 1,000 requests per day with a personal Google account, on Gemini 3 models with a one-million-token context window. Add Google Search grounding, MCP support, GEMINI.md context files, conversation checkpointing, weekly preview and stable release channels, and a GitHub Action that does automated pull-request review and issue triage with an @gemini-cli mention. My position: the zero-cost entry point that makes it the right first agent for students, hobbyists, and anyone evaluating the category — and good enough that paying for anything else now requires justification.

Cline has quietly become a platform rather than an extension. Apache-2.0 (© 2026 Cline Bot Inc.), with a VS Code extension, a JetBrains plugin, a headless CLI, a Kanban board that runs many agents in parallel with one git worktree per card, an SDK for building your own agents, cron-scheduled agents, and chat bridges into Slack, Telegram, Discord, WhatsApp, and Linear. Its Plan-and-Act toggle — explore and clarify in Plan mode, execute in Act mode — is the cleanest human-in-the-loop idiom in the cohort, and its provider table runs from frontier APIs down to Ollama and LM Studio for local models. My position: the widest surface area in open source, and the right pick when AI coding needs to become team infrastructure — scheduled agents and messaging bridges are operations features, not demos. The breadth is also the risk: every surface is a place for the product to thin out.

OpenCode is the newest, moved to the anomalyco organization, installable through an unusual number of package managers, with a desktop app in beta. Its documented design idea is the built-in agent pair: a full-access build agent and a read-only plan agent that denies file edits and asks before running commands — permissions as a mode switch rather than a settings page, plus a general subagent for searches. One honest gap: the README I read does not state a licence, which matters if you plan to embed it; verify before building on it. My position: the most interesting permission UX experiment in the cohort and worth watching, but the youngest — I would not standardize a team on it yet.

The cohort and the incumbents side by side, on the axes that decide adoption:

Tool Licence Shape Model access Cost shape My position
Aider Apache-2.0 Terminal pair-programmer Nearly any LLM, plus local BYO-key (metered) Precision tool for existing repos; read its source
Codex CLI Apache-2.0 Terminal agent + Web + IDE + desktop OpenAI models ChatGPT plan or BYO-key Default if ChatGPT subscription already fits
Gemini CLI Apache-2.0 Terminal agent + GitHub Action Gemini 3 Free tier (1,000 req/day), API key, or Vertex Zero-cost entry point; makes paid tools justify themselves
Cline Apache-2.0 IDE extensions, headless CLI, Kanban, SDK Multi-provider down to local BYO-key; platform surfaces Widest open surface; team-infrastructure pick
OpenCode Not stated on README Terminal + desktop beta Multi-provider BYO-key Permission-mode experiment; verify licence before embedding
Cursor Proprietary AI-native IDE Frontier models + in-house Composer Free / $20 / tiers / Teams $40; Bugbot metered Best-integrated IDE experience; aggressive tiering
GitHub Copilot Proprietary IDE agent mode, CLI, code review, cloud agent Multi-model behind credits Free / $10 / $39 / $100 with credit allotments Distribution winner; credits are a forecasting hazard
mini-SWE-agent Open source (SWE-bench team) Minimal harness reference Any model it is run with Research artefact The 100-line control experiment every pitch must beat

The IDE incumbents answer with subscriptions, credits, and distribution

GitHub Copilot is the incumbent converting distribution into an agent business. Its plans page now reads like a cloud product: Free at zero with limited chat and agent usage, Pro at ten dollars a month including fifteen dollars of GitHub AI Credits, Pro+ at thirty-nine including thirty-nine of credits, and Max at one hundred including one hundred — with "flex allotments" on top that the page notes "may change over time." Agent mode runs in VS Code, Visual Studio, JetBrains, Eclipse, and Xcode; there is a CLI, code review, a cloud agent, and pooled org-wide credits on team tiers. My position: Copilot's advantage is that it is already where the commits are, and the credits model is a rational answer to wildly variable agent workloads — but a billing page where the credit allotments are a moving target is a budgeting hazard, and the Free tier is now generous enough to change what "trying AI coding" means.

Cursor is the independent IDE that turned AI-native editing into a tiers business: Hobby free with limited agent requests, Pro at twenty dollars, Pro+ above it, Ultra at twenty times Pro limits, Teams at forty dollars per user, and Enterprise with pooled usage, SCIM, audit logs, repository and model access controls, and — the feature that tells you where enterprise buyers' anxiety sits — an "AI code tracking API." Bugbot, its review agent, bills on usage. My position: the best-integrated AI IDE for people who want the whole experience in one window, with the field's most aggressive tiering; read the Ultra tier as an admission that heavy agent use at a flat price is not sustainable, which is the same lesson the credits model teaches from the other direction.

The pattern across both incumbents is identical and worth naming: the flat subscription is the acquisition surface, agent workloads are metered, and the meter's unit — credits — is vendor-defined. The open-source terminal cohort, where you bring your own API keys, is the only part of this market where the cost model is fully legible.

SWE-bench Verified measures issue-solving, and its most honest result is a hundred-line harness

SWE-bench is how the field grades agentic coding, and its own site is worth reading rather than summarizing from secondary coverage. Verified is a 500-instance, human-filtered subset of the original benchmark — real GitHub issues from twelve Python repositories — created with OpenAI in 2024. The original benchmark holds 2,294 instances; Lite is a 300-instance cheap subset; Multimodal and Multilingual extend coverage to 480 visual and 300 cross-language instances across 42 repositories. The leaderboard tooling now plots resolved rate against cost, against cost limits, and against step limits — an admission that cost-per-resolution is the metric buyers actually feel.

The result I consider the most consequential in the field ran in July 2025: mini-SWE-agent scored 65 percent on SWE-bench Verified in one hundred lines of Python. A minimal harness matching elaborate agent frameworks within sight of the leaderboard's top tells you where the value actually lives — in the model, with the harness as a thin permission-and-context layer — and it is the standing rebuttal to every pitch that treats the scaffold as the moat. The benchmark maintainers are also pushing past saturation: ProgramBench, released in May 2026, tests building meaningful software artefacts from scratch, and CodeClash, from November 2025, reframes evaluation as goal-oriented development rather than task completion. My position: cite Verified numbers with their cost axis attached or not at all, and treat a benchmark harness's simplicity as a feature of the measurement, not a limitation of the tool.

Licences are permissive where the market is competitive; closed where distribution is the moat

The licence audit is quick because the open cohort converges: Aider Apache-2.0 (verified from the licence file), Codex CLI Apache-2.0 (stated in its README), Gemini CLI Apache-2.0 (badge and README), Cline Apache-2.0 with a named copyright (© 2026 Cline Bot Inc.). OpenCode's README, notably, states no licence on the page I read — an omission that matters for anyone embedding it. The closed tier is Cursor and Copilot: proprietary applications with proprietary terms, free of licence obligations but full of billing obligations instead.

The real cost ledger therefore has three columns, and the field's pricing pages have converged on all three within the year. Subscription: Cursor at twenty dollars, Copilot Pro at ten, both with agent usage limits that convert heavy use into an upsell conversation. Credits: Copilot's AI Credits (fifteen, thirty-nine, and one hundred dollars of base value by tier, plus flex allotments explicitly subject to change) and Cursor's usage-based Bugbot are the honest admission that agent workloads have unbounded variance and flat pricing cannot hold. Bring-your-own-key: Aider, Cline, OpenCode, and the API-key modes of Codex and Gemini, where you pay providers directly and a runaway loop is a bill rather than a quota wall. The Gemini CLI free tier sits outside all three as a market-making subsidy. My position: BYO-key is the only cost model where you can compute your own break-even, subscriptions are the right shape for predictable interactive use, and credits are the right shape for vendors and the wrong shape for anyone who has to forecast spend.

Where AI coding breaks

Quota exhaustion mid-task. Trigger: a subscription-billed agent in the middle of a long autonomous run when the allowance runs out. The failure is a half-finished change and a session that stops accepting tool calls at the worst moment. The free tiers make this worse in a specific way: Gemini CLI's thousand requests a day is ample for interactive chat and insufficient for delegation, and the distinction is only discoverable by burning through it.

Approval fatigue and the auto-approve cliff. Trigger: per-action approval prompts on a long task, and the human who starts mashing accept. Every tool in the cohort documents an auto-approve mode — Cline's toggle is the explicit example — and the failure mode is identical across all of them: the permission gate exists to catch the one destructive command in a hundred, and fatigue is how that command ships. Budget attention for review or set bounds; do not do both badly.

Context starvation on large repositories. Trigger: an agent working a codebase too large for its context assembly to represent. The model edits plausibly but misses the module two directories over that owns the behavior it just reimplemented. Aider's repository map is the documented mitigation in the open cohort; every tool has an equivalent, and none of them make the failure impossible. The trigger to watch is repository size plus cross-module change requests.

Benchmark transfer failure. Trigger: choosing a tool from its SWE-bench Verified percentage. Verified is 500 Python issues, resolved rates are vendor-submitted, and the site's own resolved-versus-cost plots exist because a high resolution rate at an absurd cost-per-instance is a losing deployment. The failure is procurement by leaderboard. Run your own tasks on your own repositories before standardizing.

Headless automation without blast-radius control. Trigger: scheduled or CI-triggered agents with write access. Cline's scheduled agents and Kanban worktrees, and Gemini CLI's GitHub Action, all make delegation trivially easy — and an agent that auto-commits to the wrong branch on a cron is an incident generator. The mitigations are the same ones from any automation discipline: scoped credentials, worktree isolation, and review gates on anything that leaves the sandbox.

Billing opacity on credit-based plans. Trigger: forecasting monthly spend when agent workloads are metered in vendor-defined credits whose allotments are documented as subject to change. The failure is not overage charges — it is the inability to answer "what did AI coding cost us last quarter" with a number a finance team accepts. Export usage, or move the workload to BYO-key where the meter is the provider's public price list.

Three questions the field has not settled

First, does the harness have durable value, or is it a two-hundred-line configuration file away from irrelevance? Mini-SWE-agent's 65 percent with a hundred lines of Python is the strongest evidence yet that models are eating the scaffold; the counterargument — that production needs permissions, checkpoints, and team features no minimal harness provides — is exactly what Cline and Cursor sell. Both cannot be fully right. Second, what is the stable unit of billing for agent work? Subscriptions underprice heavy users, credits are opaque, BYO-key shifts variance to the buyer, and every vendor is currently hedging across all three; the market has not found its utility-price analogy. Third, who is accountable when an autonomous agent's merged change causes an incident — and does the answer differ for a Copilot cloud agent, a Cline cron job, and a developer-driven Codex run? The audit-log and AI-code-tracking features now appearing in enterprise tiers exist because someone is asking, and no vendor has answered convincingly yet.

Resources

Tool repositories and licence files

  • Aider README — repository map, auto-commit and lint-test loop, 6.8M installs and 15B weekly tokens, self-written-release badge.
  • Aider licence — Apache-2.0, verified from the file.
  • Codex CLI README — Apache-2.0 statement, ChatGPT-plan and API-key auth, Codex Web and IDE extensions, installer mechanics.
  • Gemini CLI README — free tier of 60 requests per minute and 1,000 per day, Apache-2.0 badge, Gemini 3 with 1M context, GitHub Action, release channels.
  • Cline README — VS Code, JetBrains, headless CLI, Kanban with per-card worktrees, SDK, scheduled agents, messaging bridges, Plan-and-Act, Apache-2.0 notice.
  • OpenCode README — build and plan agent pair, desktop beta, package-manager spread, licence not stated on the page.

Pricing and evaluation pages

  • Cursor pricing — Hobby, Pro, Pro+, Ultra, Teams, and Enterprise tiers; Bugbot usage billing; enterprise audit and AI-code-tracking features.
  • GitHub Copilot plans — Free, Pro, Pro+, and Max tiers with AI Credit allotments, flex allowances, agent-mode IDE coverage, CLI, and cloud agent.
  • SWE-bench leaderboards — Verified, Lite, Multimodal, and Multilingual benchmark definitions, resolved-versus-cost analysis, mini-SWE-agent result, ProgramBench and CodeClash announcements.