Issue 30

The delegate/review/own line is the new competitive edge

Published August 1, 2026

The boundary, not the assistant

The interesting decision in AI-native engineering is no longer which coding assistant to standardize on. It is where a team draws the line between work it delegates, work it reviews, and work it owns outright. OpenAI's own guide to building AI-native teams makes that framing explicit, and the reason it holds up is capability data rather than enthusiasm: as of August 2025, METR found leading models could sustain 2 hours and 17 minutes of continuous work with roughly 50% confidence of a correct answer, with task length doubling about every seven months.

That trajectory is what pulls agents out of the editor. A few years ago models managed around 30 seconds of reasoning — enough for a line suggestion. Now execution is moving off the individual developer's machine into cloud-based, multi-agent environments, which changes the unit of work from a completion to a workflow. Developers spend less time generating code inside the IDE and more time handing off whole tasks.

The guide's phase-by-phase breakdown is more useful than its headline numbers. In planning, an agent takes the first pass at feasibility: reading a spec, mapping it to the codebase, tracing which services a feature touches, surfacing ambiguities. Humans review accuracy and completeness. Story point assignment, effort sizing, and non-obvious risk still require judgment, and prioritization and sequencing stay human-led. In design, agents scaffold projects and translate mockups; engineers keep core logic and architectural patterns.

Read that as a template rather than a description. Each phase gets three columns, and the middle one — review — is where the real design work sits. OpenAI reports that work once requiring weeks now ships in days, and that routine tasks like documentation, dependency maintenance, and feature-flag cleanup are delegated to Codex entirely. What made those delegations safe was not model quality alone but the fact that each has an obvious check: the tests pass, the flag is gone, the build is green. Ownership of new or ambiguous problems still rests with engineers, which is another way of saying delegation stops where verifiability stops.

489,150
community votes across 104 models on Arena.ai's WebDev leaderboard, as of July 27, 2026

Evaluation of agent output is becoming shared infrastructure rather than vendor marketing — but these are votes on greenfield web apps, not evidence about maintenance work.

Evaluation grows teeth

Code Arena's July 2026 fullstack upgrade is the more telling detail. The platform moved beyond frontend prototyping to test PostgreSQL with authentication and row-level security, third-party API integrations, persistent sandboxes, and direct deploys to Vercel — closer to something a team would actually ship. Anthropic's claude-opus-5-max leads at 1725, with Moonshot's kimi-k3-max at 1682.

The scoreboard measures the wrong half of the problem, though. Rankings come from users building apps and voting on which model did better, which is a reasonable proxy for greenfield capability and a poor one for the work most engineers spend their days on: changing code someone else wrote, under constraints nobody wrote down.

The verification tier you can adopt now

  • Greptile and mrge

    Both aim at context-aware pull request feedback learned from your codebase, which is the only kind of review comment that scales when an agent opens the PR.

  • Tusk and Stably

    Tusk generates unit and integration tests from codebase and business context; Stably keeps plain-English web app tests current as the app changes — coverage as the check on delegated code.

  • Benchify

    Uses formal methods rather than sampling, which matters for the failure class ordinary tests structurally cannot reach.

  • Ellipsis

    Reviews and fixes on pull requests, and notably will not commit without permission — a small governance detail worth checking in every tool of this class.

The check on all of this

Cortex makes the argument most of this market avoids: true developer productivity is not measured by how frequently AI tools are used at work. Its guide pushes teams toward adoption, governance, and measurement together, and toward connecting tool use to deployment frequency, cycle time, and code quality rather than settling for anecdotal speed improvements.

That is the sharpest available critique of the verification layer. Review bots are themselves unaudited models judging model output, and a leaderboard score is not a claim about your repository. If review capacity does not grow alongside generation capacity, faster delegation does not remove the bottleneck — it moves it to the humans approving pull requests, where an adoption dashboard will happily report success.

Keep this thread going.

Get the next issue in your inbox or reading room.