Suppose you need to add authorization to a project settings screen. The backend has to verify a JWT (JSON Web Token), load the user's workspace role, reject expired permissions, and keep password hashing on Argon2id.
You can still write every line yourself. The useful question is how much of that loop you're willing to hand off, and what you'll inspect when the assistant comes back.
Before you pick a vendor, pick an operating mode:
- Autocomplete or next edit: You drive the change. The tool predicts the next local edit.
- Live agent: You share a local loop. The tool searches, edits, runs commands, and pauses so you can steer.
- Delegated agent: You hand off a bounded task. The tool works in an isolated or remote environment and returns a diff, branch, or pull request.
Those modes can live inside one product. Code Completion System explains why inline completion and task agents need different latency, context, and evaluation designs.

As of August 19, 2026, Cursor, Codex, GitHub Copilot, and Claude Code all cover more than one surface. None of them collapses cleanly into "the editor tool," "the terminal tool," or "the cloud agent." Model menus, usage meters, and plan names also move faster than the engineering habits that actually keep you safe.[1][2][3][4][5][6][7]
Run one task through the agent loop
A weak prompt says, "add admin settings auth." A useful brief says:
- Reuse the JWT middleware pattern in
app/middleware/ - Read
db/schema.tsbefore adding queries - Require active workspace admin membership
- Reject expired admin permission
- Keep password hashing on Argon2id, not bcrypt or MD5
- Add tests for a valid token, an expired token, missing membership, and expired permission
That brief names the scope, the constraints, the security rules, and the evidence you expect. The assistant can work without inventing a second auth system beside the one you already have.
Assemble the smallest useful context
The agent shouldn't dump the whole repository into context. It should search for the files that can answer this task:
db/schema.tsfor users, workspaces, and membership stateapp/middleware/for existing auth conventionspackage.jsonfor installed auth and hashing librariestests/for fixtures and runner styleAGENTS.md,CLAUDE.md, or other project rules
Claude Code reads CLAUDE.md across terminal, IDE, desktop, and web surfaces.[6] Cursor documents project, team, user, and AGENTS.md rules.[8] Instruction files make constraints persistent, but relevant source and tests still beat a stale rule.

Patch, test, and consume the failure
After that working set exists, the agent can propose a small plan: reuse the JWT helper, query workspace membership, check admin_expires_at, wire the route, and add failure-mode tests.
Suppose the first run fails:
1FAIL tests/admin-settings-auth.test.ts
2 Admin Settings Auth
3 ✓ accepts valid JWT and valid workspace permission
4 ✗ rejects request when admin permission is expired
5 Expected 403, received 200A completion tool stops after generating code. An agent should treat that failure as new context. If the implementation compared seconds with milliseconds, it patches the unit error and reruns the targeted tests. A green run is evidence for the tested behavior. It isn't proof of architecture or security policy.
Keep policy with the human reviewer
The diff can still import bcrypt because an older package already uses it. Tests pass. The task required Argon2id. You reject the hunk, restate the constraint, and ask the agent to rerun tests after the dependency change.
⚠️ Review boundary: Passing tests don't prove policy compliance. You still own security posture, dependency choices, permission grants, architecture, and release judgment.

The loop closes on evidence: a task contract, a selected working set, a patch, test output, and a reviewable diff.
Compare surfaces, not logos
Current products cross local and remote boundaries. Compare the handoff inside the mode you actually plan to use.
| Product | Live or local work | Delegated work | Review surface | Useful first pilot |
|---|---|---|---|---|
| Cursor | Editor agent, inline edits, rules, and CLI | Cloud agents | Editor diff, checkpoint, or pull request | Feature change that needs frequent file-level steering[1][8] |
| Codex | Desktop app, CLI, and IDE extension | Cloud tasks, worktrees, and scheduled tasks | Local diff, worktree, branch, or pull request | Two bounded tasks that can run independently[2][3] |
| GitHub Copilot | IDE completion, agent mode, and CLI | GitHub cloud agent in an Actions-powered environment | Local diff or GitHub branch and pull request | Issue-to-PR task with CI and review already in GitHub[9][5] |
| Claude Code | Terminal, IDE, and desktop | Web sessions and cloud routines | Diff, command trace, branch, or pull request | Debugging task that crosses code, shell, logs, and tools[6] |

Surface details change the result. GitHub's cloud agent, for example, works on one repository, one branch, and one pull request per task, uses Actions minutes plus GitHub AI Credits, and has a 59-minute hard limit. It's available on paid Copilot plans, not Copilot Free.[5][4] That can be a good boundary for issue-sized work and a poor fit for an open-ended migration. Codex supports local checkouts, isolated worktrees, and cloud threads, so review can happen during the work or after it.[2]
💡 Key insight: The interesting product difference isn't "editor vs terminal." It's when you can still steer, and what evidence you get when you can't.
No surface wins for every task. Live steering favors rapid correction. Delegation favors parallel work. Pull-request handoffs favor team visibility. Terminal access favors inspection and tool composition. Match the task to the workflow you already have.
Read price as a meter, not a task quota
Vendor units aren't interchangeable. "5x usage," GitHub AI Credits, included model usage, and API tokens measure different things. Context size, model choice, tool calls, local versus cloud execution, and retries all change consumption.
| Product | Individual entry point | Higher or team entry point | Meter to watch |
|---|---|---|---|
| Cursor | Hobby free; Pro $20/month includes $20 of third-party model usage | Pro+ $60/month ($70 pool); Ultra $200/month ($400 pool); Teams Standard $40/user/month; Teams Premium $120/user/month with 5x Standard agent limits | Cursor Models pool, Other Models pool, then on-demand usage[10] |
| Codex | ChatGPT Plus $20/month; Free and Go include tighter Codex trial access | Pro $100/month for 5x Plus usage or $200/month for 20x; Business $20/user/month billed annually or $25 monthly (two-user minimum) | Shared five-hour local and cloud window, then credits or API-key token billing[3] |
| GitHub Copilot | Free; Pro $10/month | Pro+ $39/month; Max $100/month; Business $19/seat/month; Enterprise $39/seat/month | GitHub AI Credits (1 credit = $0.01) plus Actions minutes for the cloud agent[4][5] |
| Claude Code | Pro $20/month or $17/month billed annually ($200/year) | Max from $100/month (5x or 20x Pro); Team Standard $20/user/month annually or $25 monthly; Team Premium $100/user/month annually or $125 monthly | Shared Claude and Claude Code limits on a rolling five-hour window plus weekly caps, or API tokens<a href="https://claude.com/pricing" target="_blank" rel="noopener noreferrer" title="Plans & Pricing |
Those are vendor list prices checked on August 19, 2026, before tax, negotiated contracts, or temporary promotions. Availability can depend on region, organization type, and billing cadence. GitHub has paused new self-serve Copilot Business sign-ups for organizations on GitHub Free and GitHub Team plans since April 22, 2026, so confirm checkout before you plan a rollout.[4] Anthropic's pricing FAQ says Claude Code is included in paid plans and shares the same usage pool as chat.[7]
Don't convert a plan multiplier into a promised task count. Run the same repository tasks for one billing cycle, record usage after each task, and compare cost per accepted change. Also record the exact model and mode. Vendors offer multiple models or routing profiles, and a cheaper or faster choice can change both quality and consumption.
Privacy and permissions belong in the purchase decision
Security posture depends on the plan and the settings, not the product name alone.
| Product | Current policy checkpoint |
|---|---|
| Cursor | Enable Privacy Mode if code and prompts must not be used for training. Team plans add admin privacy controls.[1] |
| Codex | ChatGPT Business, Enterprise, Edu, and API data aren't used for training by default. Individual ChatGPT use follows separate data controls.[3][12] |
| GitHub Copilot | Business and Enterprise data isn't used for training. Starting April 24, 2026, Free, Pro, Pro+, and Max interactions may be used unless the user opts out.[13] |
| Claude Code | Team and Enterprise work data isn't used for model training by default. Consumer plans use opt-out controls.<a href="https://claude.com/pricing" target="_blank" rel="noopener noreferrer" title="Plans & Pricing |
Then inspect runtime permissions: repository read scope, command execution, network access, secrets, branch protection, and the ability to push or open a pull request. Code Generation & Sandboxing covers isolation, allowlists, and execution boundaries.
🎯 Rollout tip: Start with read access, targeted commands, and a disposable branch or sandbox. Expand permissions only after review logs show why they're needed.
Pilot with repository evidence
Don't decide from one toy prompt or a vendor demo. Give each candidate the same starting commit, task brief, allowed tools, and time budget.
| Task | Evidence to save | Failure worth noticing |
|---|---|---|
| Small bug fix | Final diff and targeted test output | Unrelated churn |
| Multi-file refactor | Plan, changed API surface, and full affected checks | Missed dependency or duplicated abstraction |
| Failing test repair | Original error and retry trail | Guessing without reading the failure |
| Security-sensitive change | Permission log, negative tests, and reviewer notes | Constraint silently weakened |
| Documentation update | Source links and rendered output | Fluent but stale claim |
Score the accepted outcome, diff size, review time, tests actually run, risky-command approvals, policy preservation, task duration, and measured cost. Evaluating AI Agents shows how to grade outcome, process, safety, cost, and repeatability as one episode.
SWE-bench originally turned real GitHub issues into repository-level test tasks.[14] A public leaderboard score still isn't a purchase decision. OpenAI stopped reporting SWE-bench Verified in 2026 after finding flawed tests and growing contamination. It first pointed people at SWE-bench Pro, then later estimated that about 30% of those tasks are also broken and retracted that recommendation.[15][16][17] Record the benchmark variant, scaffold, model, tool access, and evaluation date. Don't compare scores produced under incompatible setups.
The purchase decision should come from repeatable work in your repositories. Save the prompt, starting commit, expected checks, final diff, usage, and review notes. Rerun that pack after major model, product, or pricing changes.
Tool menus will change. Operating discipline survives: define the task, bound the environment, keep evidence visible, and keep a human on policy and release. AI Coding Workflow with Agents turns that discipline into a repeatable repository workflow.