The real ROI of AI coding agents is workflow design, not model

The premise. Theo, creator of T3 Code, defines three markdown files he calls 'skills': sole loop, full send, and full stop. These encode reusable agent workflows that govern code review, autonomous merging, and pre-merge handoff. He argues that the real leverage in AI-assisted development is not better models but careful workflow design that captures when and how agents should act without human intervention.

The sole loop skill. This workflow instructs a secondary model (e.g., GPT-4.1 or Opus) to review the primary agent's code changes. The agent must fix genuine issues, push back on unnecessary suggestions, and stop when agreement is reached or a budget of rounds is exhausted. Theo reports this drastically reduces the number of PRs that enter infinite review loops on GitHub. The tradeoff is longer initial turnaround but faster final merge.

The full send skill. Once Theo is confident the agent understands the task, he invokes this skill to grant full autonomy: the agent must finish the change, prove it works (via tests, reproductions, screenshots), file a PR, babysit CI and review bots, and merge when gates pass. In a recent 32 uses, 27 PRs merged without him looking again. The safety net is a nightly release process that catches issues before stable.

The full stop skill. A variant that stops short of merging. The agent does everything full send does but never clicks merge. Theo uses this for riskier changes where he still wants a final human sign-off. The agent flags him only when it believes the PR is ready. This became his most-used skill, allowing him to delegate confidently while retaining control of the merge button.

What's missing. The entire workflow is tightly coupled to T3 Code's sidebar inbox pattern and its multi-agent orchestration. Theo acknowledges he built these skills iteratively by observing his own friction points. There is no independent validation, no data on team-level productivity, and no discussion of governance across multiple developers. The approach is personal and may not scale to larger teams without significant process adaptation.

The organizational takeaway. Theo's underlying insight matters beyond his tooling: the bottleneck in agentic coding is not model capability but the absence of explicit handoff rules, verification requirements, and autonomy boundaries. Engineering leaders should focus on defining those guardrails rather than chasing model benchmarks. The specific syntax is irrelevant; the pattern of encoding approval criteria and safety checks into agent instructions is replicable.