# Theo’s Agent Skills Make the Merge Boundary Explicit

- Date: 26 Oct 2026 (2026-10-26T17:06:11.000Z)
- Summary: Theo’s reusable coding-agent skills distinguish delegation through merge from stopping at a review-ready pull request. His practitioner account highlights explicit permissions, bounded review, and verification, but does not establish general reliability gains.
- Tags: `digest`, `ai-discourse`, `coding-agents`, `agent-skills`, `verification`, `code-review`, `developer-workflows`

## Sources

1. [Theo / t3.gg - These 3 skills changed my life](https://www.youtube.com/watch?v=5Bmp9cz1JN8) (youtube)

## Executive Summary

Delegating implementation and authorizing a merge are different decisions. Theo’s latest account of reusable coding-agent skills makes that distinction concrete: the same broad workflow can either finish at a review-ready pull request or proceed through verification and merge, depending on the permission granted at the start.

In [“These 3 skills changed my life”](https://www.youtube.com/watch?v=5Bmp9cz1JN8), published October 26, he describes bounded cross-model review, a “full send” workflow, and a “full stop” alternative. This is the day’s clearest practical contribution: autonomy expressed as an explicit workflow boundary rather than a vague instruction to keep working. It is one practitioner’s account, not evidence of an industry-wide reliability improvement.

## What Happened

The three skills address different recurring problems in delegating coding work:

- **Cross-model review** puts another model into a bounded review loop. The important qualification is the limit: review should produce actionable corrections without turning into indefinite model-to-model discussion.
- **“Full send”** delegates implementation through verification and merge, subject to explicit permission and merge gates. Tests, direct evidence, completed CI and review, and escalation when blocked are part of the described workflow.
- **“Full stop”** prepares a pull request but reserves the final merge decision for the user. It preserves much of the delegated work while retaining a human decision at the consequential boundary.

Theo says 27 of 32 recent full-send runs merged without his further review. That is an attributed, unverified personal result—not an independently measured success rate. It shows how he says he is using the workflow; it does not establish that the resulting changes were correct or remained problem-free after merging.

He also describes developing the skills from repeated workflow problems and revising them after observing model mistakes. Their value, in this account, comes from preserving lessons that would otherwise need to be restated during each task.

## Why It Matters

The distinction between full send and full stop exposes an ambiguity in agent discourse. “The agent finished” can mean that code was written, that checks passed, that a pull request is ready, or that a change has merged. Those endpoints carry different consequences. Naming the endpoint makes the delegation easier to understand and assess.

Verification and permission also answer separate questions. Tests and review provide evidence about a change; permission determines whether the agent may take the next action. Passing checks does not itself grant merge authority, and granting merge authority does not make the checks sufficient.

Cross-model review fits this structure as another check, not a guarantee. A second model can challenge an implementation, but the account does not demonstrate independent error detection or quantify what that reviewer catches. The stronger takeaway is the combination of bounded review, observable checks, and an explicit stopping rule—not the mere presence of multiple models.

## The Bigger Story

This reinforces the distinction between capable models and dependable workflows. Here, the reusable artifact is not just an instruction for generating code. It records how work should proceed, what evidence should accompany completion, and where authority ends.

The limits matter. The video does not establish how these workflows perform across teams, unfamiliar repositories, or higher-risk changes. Nor does the reported merge count provide a comparison against the same tasks completed without the skills.

The useful shift is nevertheless concrete: describing agent autonomy in terms of permissions, evidence, and endpoints makes it more assessable. The question becomes not simply whether an agent can implement a change, but what must be true before it is allowed to call that change finished.