The Modern Developer Stack Has One Human Approval Queue

The current AI coding stack is not really five agents competing for the keyboard. It is Claude Code in a terminal, Codex in another terminal, Cursor editing a branch you were certain you understood 14 minutes ago, Cline waiting politely to run a command, Copilot opening a pull request, and one human being becoming the approval queue for all of them. The human is usually holding coffee, a pager, and a vague conviction that this was meant to save time.

Give each agent a job, not a lease on your repository

The reasonable move is not choosing a single winner. It is assigning each tool a narrow operating zone. Claude Code works well as the conversational terminal resident: ask it to map an unfamiliar service, propose a migration, or work through a bounded change while you watch the command stream. Its CLI supports a planning permission mode, and its tool allowlist can make read-only investigation less like an extended sequence of clicking “yes” to git diff.

claude --permission-mode plan
claude --allowedTools "Bash(git log:*)" "Bash(git diff:*)" "Read"

That setup is good for reconnaissance, but Claude Code is bad at being silently trusted with an underspecified task. “Clean up authentication” is not a task; it is an invitation to discover every historical compromise in the repository and replace three of them before realizing one was an undocumented production dependency. Plan first, constrain the directory and tools, then let it edit.

Codex belongs in the same terminal-shaped category, but its useful distinction is the approval boundary. Its documented modes separate reading and suggesting from automatic edits and command execution. Start in the restrictive mode when you want a second set of eyes on a local diff or an explanation of a test failure. Move up only after the agent has shown it understands the project rather than merely recognizing the names of the dependencies.

codex --suggest
# inspect the proposed patch and commands first
codex --auto-edit

Codex is bad at the thing every terminal agent is bad at: making a pile of locally plausible changes feel like a coherent product decision. A passing test suite is evidence. It is not a witness statement.

Use the editor for the edits you intend to see

Cursor earns its place when the work is genuinely editor-shaped: a refactor spanning a few files, a test that needs to be written beside the implementation, or a codebase question where you want the answer next to the symbols in question. Its Ask mode is read-only; Manual mode limits edits to files you explicitly select; Agent can search, edit, and run commands. That is a useful gradient, not a personality test. Use Ask when you are still learning what is broken, Manual when you know exactly where the fix belongs, and Agent when the task has enough surface area to justify it.

Cursor’s failure mode is familiar: an agent takes the phrase “fix the error” as permission to remodel the kitchen. Its custom modes and toggles for terminal access, auto-run, and auto-apply are worth configuring before the first large task, not after it has helpfully rewritten your lint configuration. Also, its agent terminal uses your terminal profile. If your prompt theme makes its output look haunted, Cursor documents a CURSOR_AGENT environment variable specifically for skipping elaborate shell initialization during agent sessions. Your shell prompt should not be the most autonomous system in the room.

Let Cline be the controlled experiment

Cline is particularly useful for developers who want to see the permission model in the foreground. A sane default is simple: auto-approve project reads, require approval for edits and commands, and turn on checkpoints. Cline’s checkpoints save snapshots after tool use and can restore workspace state without rewriting the repository’s Git history. That changes the review rhythm: let it take several small steps, inspect the resulting diff, then restore when it has confidently constructed a solution to a problem nobody assigned.

Do not confuse checkpoints with a safety guarantee. Cline’s own documentation warns that YOLO mode approves file operations, commands, browser actions, and MCP tools without confirmation. That is appropriate for a disposable container or a throwaway prototype. It is less appropriate for the directory containing production credentials, deploy scripts, and the small file named final-final-actually-final.sql.

Make Copilot the pull-request assistant, not the approver

GitHub Copilot is most valuable after the code exists: summarize a pull request, explain a diff, investigate a failed workflow, or send a scoped issue to its cloud agent and receive a pull request back. GitHub says a Copilot code review usually arrives in under 30 seconds. That makes it a decent extra review pass while a human is still loading enough context to remember why the service has both User and UserV2.

But Copilot’s review is deliberately non-blocking: it leaves a comment review, not an approval or request-for-changes review, and GitHub notes that it may repeat comments after a re-review. Treat it as a fast checklist generator. Do not treat a quiet Copilot review as a security sign-off, architectural review, or evidence that the feature does what the issue meant.

The operating model: fewer simultaneous authors, better gates

The stack works when you stop asking every agent to be a full software team. Pick one active implementation agent per branch. Use one other agent, preferably with a different interface, for explanation or review. Then make the human approval stages explicit:

1. Before edits: approve a short plan, affected files, and validation commands.
2. During edits: allow reads automatically; require confirmation for writes, dependency changes, migrations, and networked actions.
3. Before push: inspect git diff, run the project’s real tests, and ask a separate agent to explain the diff rather than generate another one.
4. Before merge: review behavior, rollback, observability, and ownership—the parts no tool can infer from a green check.

That last step is the unglamorous answer to the approval queue. The tools have not eliminated judgment; they have converted it into a higher-volume diff-reading job. The practical win is not pretending the human is gone. It is preventing five tireless assistants from all assigning the same human an emergency homework packet at 4:47 p.m.