Engineers Pay For Overlap

AI coding is not a category

An engineer pays for Cursor, GitHub Copilot, and Windsurf at the same time. Each one lives in the autocomplete bar, none of them are wrong, and the team cannot tell which suggestions came from which tool. By the end of the quarter the bill is real and the routing is a guess.

A second engineer fires up Claude Code to fix a typo in a config file. The terminal agent reads the codebase, plans a small change, and asks for permission to run a command. By the time the approval lands, the engineer could have typed the fix in the editor and moved on.

A third team owns a 4,000-file monorepo and is paying for an IDE assistant that does not index it. The engineer searches by hand through controllers, hunting for the call site. Sourcegraph sits unsold in the procurement queue, two weeks from a meeting that will not happen.

Three engineers, three failures, one category mistake. AI coding has not become one tool; it has become a stack of single-work-shape tools that share a marketing label.

The same tool that nails terminal-agentic execution is wasteful on inline autocomplete. The same editor that ships a perfect small refactor is the wrong place to delegate a backlog ticket overnight. The cloud agent that closes a clean PR on a small task creates a giant review burden the moment the spec turns vague. The mistake is not the tool. The mistake is the absence of a work-shape map.

The right question is not which AI coding tool is best. The market answers that with a different tool every quarter, and the answer keeps changing. The right question is sharper: what kind of work do I do today, what tool earns each work shape, and where does the engineer step back in regardless of which tool is in the chair?

Seven work shapes matter for a working engineer: in-IDE flow editing, terminal-agentic execution, repo-wide reasoning, multi-file refactor, spec-to-PR autonomy, test generation, and codebase onboarding. Each has a different tool that earns the slot today, a different ceiling on what ships clean, and a different return-point for the engineer.

The seven work shapes

The work shape decides the tool. Below, each shape gets the same treatment: the tool that earns the slot today, what ships clean, where the ceiling sits, and the action plan for week one. The action plans assume you are starting from scratch on that shape; if a tool is already in daily use and working, the answer is to keep it and skip the section.

In-IDE flow editing

Inline completions, local edits, small component changes, boilerplate, in-file refactors. The slot belongs to AI-native or AI-assisted IDE assistants, split by intent: Cursor for teams willing to adopt an AI-native editor and pay for daily agent use, GitHub Copilot for teams that need to support existing IDE variety or stay GitHub-native. Cursor Pro lists at $20 per month, Pro+ at $60, with team and enterprise tiers above. Copilot Pro is $10 per month, Pro+ $39, Business $19 per seat, Enterprise $39 per seat, with usage-based billing changes landing June 1, 2026.

What ships clean: inline suggestions, local edits, boilerplate, next-step suggestions inside the working file. Cursor's Tab predicts next actions, makes multi-line changes, and jumps across files based on session context. Copilot remains hard to dislodge in larger teams because it is distributed across the IDEs developers already use. The ceiling appears when the task touches authentication, authorization, billing, migrations, concurrency, security, or anything with production blast radius. Autocomplete makes wrong code feel frictionless. The engineer must slow down at the diff boundary regardless of how confident the suggestion looks.

If you start this week, pick one. The choice resolves on the three-ticket trial: when Cursor wins, cancel Copilot for engineers who do not need other IDEs; when Copilot wins, do not keep Cursor for a few impressive demos. Keep the loser only for engineers actually switching into it for daily work, and write down the IDE surface that justifies the second subscription.

Terminal-agentic execution

Failing-test repair, CLI-heavy bugfixes, dependency updates, migration scripts, build or lint failures, multi-step local tasks. The slot belongs to Claude Code. Anthropic describes it as an agentic coding system that reads the codebase, edits across files, runs tests, and delivers committed code, with permission modes and plan modes as first-class controls. Claude Pro at $17 per month bundles Claude Code; Max plans start at $100; Team is $20 per seat annually with usage at API rates above quota.

What ships clean: a terminal agent inspects, edits, runs commands, patches, and reruns until the diff is review-ready. The ceiling appears at command persuasion. A terminal agent can be too convincing because it looks busy. The engineer has to inspect the command log, review changed files, and reject work that passes a weak test while violating architecture. Anthropic's own auto-mode work is the warning sign: default permissioning creates approval fatigue, but relaxing approvals introduces risk. Before any terminal agent runs destructive commands, touches secrets, changes infrastructure, or writes migrations, a human has to constrain the scope.

If you start this week, run Claude Code on one failing test and one build break. Cline and Aider are the credible alternatives if BYOK, local-first behavior, or open source is a real requirement, not a preference. Plan, approve, execute in a branch, run tests, review the diff, then merge through normal review. Skip the comparison if Claude Code already produces a mergeable PR; you are paying for polish you have.

Repo-wide reasoning

Codebase maps, call-path explanations, dependency questions, ownership clues, migration impact estimates, multi-repo discovery. The slot belongs to Sourcegraph Cody and Sourcegraph Enterprise for any team with a large or multi-repo codebase. Cursor earns the slot for individual and small-team single-repo reasoning, helped by recent indexing improvements that drop large-repo time-to-first-query from hours to seconds for shared indexes. Sourcegraph Enterprise lists from $16,000 annually and is not a casual individual purchase.

What ships clean: dependency maps, callsite reports, onboarding packets, migration-impact analyses, refactor scoping across many repos. The ceiling appears at runtime context. Code search finds code. It does not know why a team chose a design, what outage shaped it, what feature flag controls the path, or which business rule is undocumented. Cursor and Copilot can carry single-repo reasoning a long way, but the moment the codebase is multi-repo, remote, ownership-fuzzy, or refactor-fleet-scale, Sourcegraph earns its slot for a different buying reason than another chat sidebar.

If you start this week, pick one unfamiliar service and produce an onboarding packet: service purpose, entry points, data dependencies, test commands, risky modules, known unknowns, and a first safe PR. If the candidate tool cannot produce this reliably, it is not earning repo-wide reasoning. Move to Sourcegraph only when single-repo tools have failed on a real onboarding or refactor task, not when developers like AI chat.

Multi-file refactor

Renames, extraction, interface cleanup, repetitive transformations, framework cleanups, tests that move with implementation. The slot belongs to Cursor for editor-first refactors, Claude Code for terminal-first refactors, and Sourcegraph Batch Changes for fleet-scale refactors that span many repos. Cursor wins when the diff lives in the same workflow as Tab, agent mode, and codebase context. Claude Code wins when the right loop is inspect, edit, run commands, read failures, patch, rerun.

What ships clean: medium-size refactors where the diff is reviewable inside a single PR, framework-version migrations with a clear before-and-after test surface, repetitive renames that the tool can apply with visible diffs. The ceiling appears at semantic boundaries. A refactor tool can move code but miss business invariants, performance regressions, stale documentation, hidden integration contracts, or migration ordering. The danger increases when the diff becomes too large for a human to review. Windsurf, Cline, and Aider are credible adjacent fits for local refactors but do not displace the primary winners.

If you start this week, run one medium refactor twice: once in Cursor and once in Claude Code. Compare correctness and reviewability. The better tool is the one whose diff your team would actually merge. If neither produces a reviewable diff, the refactor was scoped wrong, not the tool.

Spec-to-PR autonomy

Backlog tickets with crisp acceptance criteria, test coverage additions, low-risk bugfixes, documentation changes, repeatable migrations. The slot belongs to Devin for delegated cloud software-engineer sessions and to GitHub Copilot cloud agent for GitHub-native straightforward backlog work. Devin is now more accessible than its earlier enterprise-only posture, with Free, Pro at $20, Max at $200, Teams at $80, and Enterprise tiers. Copilot's cloud agent draws on the same Business and Enterprise subscriptions an org may already have.

What ships clean: small, scoped, well-specified backlog tasks that the agent can plan, branch, code, test, and return as a draft PR. GitHub describes Copilot cloud agent as researching the repo, creating a plan, making changes on a branch, and letting the user review and create a PR. Devin's docs claim the same shape for autonomous sessions across tickets, features, bugs, internal tools, migrations, and refactors. The ceiling appears at spec quality. Spec-to-PR autonomy fails when the spec is vague, the acceptance criteria are not testable, or the work requires product judgment. It also fails economically if review burden exceeds saved engineering time.

If you start this week, give the chosen delegated agent three tickets: one docs task, one low-risk test-coverage task, one small bugfix. If it cannot return reviewable PRs on these, it will not be reliable on harder work. Devin's own enterprise security docs say to code-review every output, enforce branch protections, and follow standard review processes because the agent may hallucinate, introduce bugs, or suggest insecure practices. Treat that caveat as the norm.

Test generation

Unit-test skeletons, edge-case enumeration, snapshot updates, regression tests for known bugs, coverage PRs. The slot belongs to GitHub Copilot for low-friction test scaffolding in org-default IDEs and Claude Code for run-fix-test loops where the agent has to read failures and patch code. Both lean on the underlying model; the difference is workflow.

What ships clean: skeleton tests near stable source code, edge-case enumeration the engineer reviews and prunes, regression tests pinned to specific bug fixes. The ceiling is the false-positive problem. A tool can write tests that assert the current bug, mock away the important behavior, or create brittle snapshots. It can also improve coverage numbers while reducing signal. Human review is not optional. Devin, Windsurf, Cline, and Aider all have terminal or linter loops that make them credible adjacent fits, but the cleanest path is the team's existing IDE or terminal agent rather than another tool.

If you start this week, pick one historical bug. Ask the tool to write a regression test first, confirm it fails, then patch the bug. Reject tests that merely encode generated behavior, and ask the tool to explain what risk each test covers. If the answers are weak, the coverage is theater.

Codebase onboarding

First-day maps, code walkthroughs, entry-point discovery, dependency explanations, test-command discovery, first safe PR suggestions. The slot belongs to Cursor for individual onboarding to a single repo and Sourcegraph Cody or Sourcegraph Enterprise for onboarding across a large, remote, or multi-repo codebase. Copilot's repository indexing helps inside GitHub and VS Code; Windsurf's context engine indexes local and remote repos for Teams and Enterprise.

What ships clean: an onboarding packet that names the service purpose, entry points, data dependencies, test commands, risky modules, and known unknowns. The ceiling is tribal knowledge. A repo can tell you what exists, but not always which team owns the production failure, why a migration stalled, which customer edge case matters, or what deploy rule is undocumented. Aider warns against dumping entire repos into chat and notes that very large repos are not optimized for fast response.

If you start this week, force the tool to produce an onboarding packet, then compare it with a senior engineer's corrections. The delta tells you whether the tool earns onboarding for this codebase. If the corrections rewrite half the packet, the tool is not yet a reliable onboarding surface and a human walkthrough still pays.

Where the engineer steps back in regardless of tool

The boundary is not "when the diff looks bad." The boundary is when the work carries system risk. AI coding tools produce default-plausible diffs across every work shape. Default-plausible is fine for inline edits and scaffolding tests. It fails at the surfaces where security, architecture, regulation, or production behavior is the differentiator.

The engineer owns security-sensitive code. Authentication, authorization, secrets handling, input validation, cryptography, and anything that touches identity. A tool can generate a plausible token-refresh routine; a human has to verify it does not leak credentials, mishandle expiry, or open replay windows.

Architecture is not delegable. Service boundaries, data models, schema migrations, queue topologies, retry semantics, idempotency. A tool can suggest a pattern that worked for someone else; the engineer must decide whether it fits this system's constraints. Architecture is not search.

Regulated logic stays with the engineer. Anything that affects compliance, audit, billing, regulated content, or customer commitments belongs to a human. The agent has no awareness of the contract behind the code. Devin's own security docs say to code-review every output before deployment. That caveat applies to every tool in this stack.

Performance is a runtime contract. Hot loops, query plans, allocation patterns, cache behavior, concurrency primitives. A tool can write code that passes tests and is twice as slow as the version it replaced. The engineer is accountable for the runtime, not the diff.

Cost calculus and coexistence

Free tiers are useful for evaluation, not for running the team's work. Premium request quotas, code retention defaults, training-data opt-outs, repo indexing, and team controls sit on paid plans across the stack. The first paid stack that earns its keep for a working engineer is small: one primary IDE assistant (Cursor Pro at $20 per month or Copilot Pro at $10 per month) and one terminal agent (Claude Pro at $17 per month annually, which bundles Claude Code). That is two subscriptions totaling around $27 to $37 per month, and it covers in-IDE flow, terminal-agentic, multi-file refactor, and most test generation for a single engineer.

The mid-paid tier sits between $40 and $120 per user per month: Cursor Pro+ at $60 for daily agent use, Copilot Pro+ at $39 for premium request headroom, Claude Max at $100 for heavier Claude Code usage, or a Copilot Business seat at $19 alongside Claude Team at $20 to $25. It earns its keep when terminal agency, cloud agent quotas, or team-mode controls become the bottleneck. It does not earn its keep when the lower tier already covers the work and the team is paying for fashionable headroom.

The enterprise tier above $200 per month is the one to slow down on. Cursor Ultra at $200, Windsurf Max at $200, Devin Max at $200, and Sourcegraph Enterprise from $16,000 annually all live here. At that spend, compare the stack against actual engineering hours saved. Sourcegraph earns its slot when enterprise code search, multi-repo refactor, ownership discovery, or large-scale change management is already painful. Devin earns its slot when delegated PRs measurably replace engineering time, not when leadership wants to say the company uses an autonomous engineer. The weak spend is buying agency or autonomy as a category subscription without a named workflow that earns it.

Pitfalls and anti-patterns

Paying for overlapping IDE assistants

Cursor plus Copilot plus Windsurf is usually three tools competing for the same edit loop. Unless the org has explicit IDE coverage needs that one tool cannot meet, the second and third subscriptions are paying for the same suggestion in a different keybinding. Pick one primary and cancel the rest.

Using terminal-agentic for autocomplete work

Firing up Claude Code or Cline to add a method signature is slower than typing the method. Terminal agents earn their slot on tasks the engineer would have to context-switch out of the editor to do anyway: run a test suite, apply a dependency upgrade across files, repair a build failure. Using them for inline edits is theater.

Buying delegated PR autonomy before scoping is real

Devin and Copilot cloud agent earn their slot only when the team can produce scoped tickets with testable acceptance criteria. Without that discipline, a cloud agent generates ambiguous PRs that engineers either rubber-stamp out of fatigue or rewrite from scratch. Either outcome erases the cost saving.

Treating Sourcegraph as another chat sidebar

Sourcegraph is bought because code discovery and repo-scale context are already expensive, not because developers like AI chat. Trialing Sourcegraph Cody as a Cursor alternative is the wrong test; the right test is whether enterprise search, Batch Changes, context filters, and zero-retention controls are load-bearing for the team's actual work.

What to validate before paying for the stack

• Map the work shapes your engineers actually do this quarter. If the team will not delegate cloud PRs for two more quarters, do not pay for delegated autonomy.
• Run each tool's free tier through one real ticket, not a marketing demo. The free tier reveals whether the diff quality, the IDE integration, and the permission model match your actual workflow.
• Confirm the privacy posture matches your data sensitivity. Check whether code leaves the machine, whether the vendor trains on prompts or completions, whether team and enterprise plans default to no training, and whether retention is zero, bounded, or indefinite.
• Confirm repo indexing economics for your codebase size. Single-repo indexing is cheap; large-monorepo indexing is not. Aider explicitly warns very large repos are not optimized for fast response, and Sourcegraph is built for the case that breaks other tools.
• Confirm someone on the team can act on the output. AI coding output only matters if a human engineer can review the diff, run the tests, route the PR, and roll it back when the next regression appears.

Seven routing decisions sharing a marketing label

AI coding is not one tool. It is seven routing decisions sharing a marketing label.

The engineer who consolidates by work shape pays once for each slot and keeps the budget. The engineer who consolidates by vendor logo pays for overlap and calls it a stack. Vendors rename and reprice every quarter; the work shapes outlive them.