# tstack: Taking Agent Changes Through Review and CI

A coding agent's work is rarely finished when it produces a patch. Someone still needs to verify the behavior, inspect the diff, explain the change, open a pull request, and respond to CI or review findings. That sequence can consume more attention than the initial edit.

[tstack](https://github.com/t3dotgg/tstack) packages Theo Browne's delivery workflows as nine agent skills for Claude Code and Codex. **The central decision is where automation stops: with a pull request ready for a person, or with a verified change merged.** The files organize an agent's work around that decision, while the host tools and repository controls determine what it can actually do.

This guide explains how the skills compose, what review and monitoring contribute, and how to evaluate the workflow without confusing instructions with enforcement.

<iframe class="aspect-video h-auto" width="100%" height="315" src="https://www.youtube.com/embed/GGrvSnpPTGo" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

## Skills describe a process for the host agent

tstack is a collection of instruction files and supporting workflow material. It is not a replacement model, compiler, test runner, or Git hosting service. The host agent reads the relevant skill and uses its available tools to carry out the process.

![Skill files covering pull requests, review, monitoring, and workflow control](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/0a4aa4a8-0b93-472d-196f-3d9ae54ec600/orig =1920x1080)

*The collection divides delivery work into reusable responsibilities.*

This makes the system understandable and editable. A team can inspect the workflow before using it and adapt its expectations to the repository. It also creates a limit: a sentence in a skill does not become an independent security boundary or a guarantee that the agent will execute every check correctly.

The dependency graph matters as well. `full-send` calls review, PR creation, and monitoring skills. `full-stop` reuses that workflow with a different final boundary. Installing only the top-level file can leave the agent without the instructions or helpers that its workflow references.

Treat the collection as a small process library. Review the complete chain needed for a chosen entry point, along with the tools it expects to use.

## Capabilities and authentication remain prerequisites

The workflows rely on an authenticated GitHub CLI for repository operations, and the PR watcher requires Python 3. Advanced review uses models from additional providers. A harness must be able to invoke those reviewers for the full review process to run.

![Requirements for the GitHub CLI, Python, and access to additional review models](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/50764ad8-b256-47b1-ac34-a0028861fc00/md2x =1920x1080)

*A skill can request a capability, but the surrounding environment must provide it.*

T3 Code offers delegation features used by the collection, while other hosts need an appropriate alternative. A basic agent installation with one model should not be described as equivalent to a working multi-provider review setup.

Likewise, GitHub authentication does not establish permission for every repository action. Token scope, organization policy, branch protection, and required approvals still apply. The workflow needs to discover and respect those controls rather than treating a successful login as a blanket merge authorization.

Before relying on a composed workflow, verify the narrow capabilities it needs: reading the relevant repository state, running the project's checks, creating a PR, observing CI, and obtaining the intended reviews. Missing capabilities should appear as explicit limits in the result.

## Proof comes before a polished pull request

The delivery workflow begins by establishing evidence that the change works. For a bug fix, that may mean reproducing the original failure and confirming that the same case succeeds after the edit. For a visible behavior change, it can require running the application and observing the result.

![Agent workflow examining a small change and its verification before filing a pull request](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/c8a58a29-a9ac-4a50-7d0f-86af23152700/lg1x =1920x1080)

*The useful evidence is tied to the changed behavior, rather than to the existence of a patch.*

This distinction prevents an easy failure mode: a well-written PR description can make a change look complete even when no relevant check was observed. A test command's name is not evidence that it ran, and a green unrelated test is not proof of the intended behavior.

The appropriate evidence depends on the change. A parser fix may have a small deterministic regression case. A UI change may require a screenshot and direct interaction. A configuration change may require checking the running application's effective behavior rather than only validating file syntax.

The final report should connect each material behavior to its evidence and disclose anything that could not be verified. That gives a reviewer a useful starting point instead of asking them to infer confidence from the agent's tone.

## Review is a separate pass with its own limitations

`sol-loop` brings another model into the review process and iterates over feedback. The point is to obtain a perspective separate from the agent that authored the patch, then address findings that affect correctness or maintainability.

A review loop is useful only if findings are evaluated. Automatically accepting every suggestion can introduce churn or new defects. Automatically dismissing all feedback reduces the reviewer to decoration. Each material finding needs a reasoned disposition supported by the code and the requested behavior.

The loop also has costs: additional model calls, elapsed time, and the possibility of disagreement that does not resolve through another round. For a small, well-covered edit, extensive review can cost more than it adds. For a subtle change, another perspective may identify assumptions the author never tested.

The skill provides process, not a mathematical proof of correctness. Keep execution evidence and independent review as complementary sources of confidence.

## A pull request should explain the problem

The `file-pr` skill emphasizes a short description that begins with the concrete problem and resulting behavior. A reviewer should be able to understand why the change exists before reading an inventory of files.

![Pull request description organized around the problem, change, and validation](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/8c4b7ddc-37bb-44e3-18c9-b4f77011fa00/md2x =1920x1080)

*A useful PR description makes the reason for the change and its verification easy to assess.*

For a bug, a before-and-after example often communicates more than a long implementation summary. State what triggers the issue, what the revised behavior is, and how the result was checked. Include limitations that materially affect review.

The description should cover the final diff. If the agent later fixes a CI issue or changes the implementation during review, stale prose can mislead the reviewer about what is actually being proposed.

This is one of the collection's practical strengths: it treats communication as part of delivery. An agent can save editing time and still create work for others if the handoff does not explain the problem, evidence, and unresolved questions.

## Filing a PR is an intermediate state

CI can fail after a PR opens, and reviewers can identify legitimate problems. `babysit-pr` monitors those events and continues the workflow instead of treating PR creation as completion.

![PR monitoring state with a failing required check and review feedback](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/0bdd41f3-917a-42e8-92a9-94661de69100/md1x =1920x1080)

*A created PR still needs its required checks and relevant findings resolved.*

Monitoring involves more than waiting for a green badge. A failure may reflect the change, an infrastructure problem, or an unrelated flaky test. The agent needs to investigate the evidence before deciding whether to edit the branch or report a blocker.

Any fix produces a new state. Tests and review that covered an earlier commit may no longer cover the final diff. The readiness decision must refer to the latest head commit, especially after a rebase or conflict resolution that changes behavior.

There is also a difference between requesting an eventual merge and observing that a merge happened. A queue, auto-merge setting, or pending check can leave the PR open. A workflow claiming completion should verify the live repository state and report the resulting commit or the concrete remaining blocker.

## Full stop and full send choose different endpoints

`full-stop` carries a change through the preparation and monitoring process, then leaves the PR ready for a person to merge. `full-send` includes merging after the workflow's readiness conditions pass.

![Composed workflow moving through proof, review, PR creation, and monitoring](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/f8f4c8de-a950-4913-5716-e8d7f0da7000/orig =1920x1080)

*The workflows share most delivery work while differing at the final merge boundary.*

That boundary needs to be real. If a supposedly stopped PR is still in an automatic merge queue, leaving the browser does not preserve human control. The current [full-stop instructions](https://github.com/t3dotgg/tstack/blob/main/skills/full-stop/SKILL.md) explicitly address existing auto-merge and queue state as part of keeping the PR unmerged.

The workflow's merge gate includes proof for the final diff, required checks, review disposition, and current mergeability. These are conditions to inspect, not assumptions to infer from an earlier successful run.

For an evaluation, full-stop makes the handoff easy to inspect. The team can see how the agent tests, communicates, responds to feedback, and reports readiness before granting it a broader endpoint. The appropriate boundary remains a repository and team decision, rather than a property of the skill's name.

## Council adds perspectives rather than certainty

`council` seeks review from three models from different providers and runs additional rounds within its workflow limits. Diverse reviewers can expose different blind spots, particularly when each examines the implementation independently before discussing findings.

![Multiple provider models reviewing the same implementation across review rounds](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/9878241d-bc33-4263-492f-3b069d298300/public =1920x1080)

*Different reviewers can contribute distinct findings, but agreement is not a substitute for execution evidence.*

Consensus has limits. Models can share training patterns, overlook the same dependency, or converge on a convincing but incorrect explanation. A three-model agreement should therefore be reported as a review outcome rather than as proof that a change is correct.

Review context matters too. A model that receives only a small diff may miss assumptions in surrounding code. A model given an enormous repository dump may spend attention on irrelevant material. The useful task is to give each reviewer enough context to assess the changed behavior and its boundaries.

Multi-model review can also increase latency and spend substantially. Evaluate it on changes where additional scrutiny is likely to matter, and keep a record of which findings led to useful corrections. The number of reviewers is less informative than the quality of the issues they help resolve.

## Taking over work requires preserving its context

`takeover` handles a PR, branch, or agent effort that has not reached completion. It examines existing work, determines what remains, and continues rather than starting a competing implementation without understanding the current state.

![Takeover workflow continuing an unfinished pull request toward its original goal](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/c3ef9881-8e8f-4741-49ca-d146195c7400/md1x =1920x1080)

*Continuing an existing change starts with reconstructing its purpose and current evidence.*

That includes preserving the original author's credit and recognizing work already done. It also requires checking whether the original goal still applies. The `modernize` skill addresses older PRs by updating their relationship to the current base and assessing whether the change remains necessary.

A clean rebase is not enough on its own. The surrounding code may now solve the original problem differently, or a conflict resolution may change the intended behavior. Re-establish proof after meaningful changes instead of inheriting confidence from an old green run.

This is where a delivery workflow becomes more than a sequence of Git commands. It must reason about the problem, not simply make the branch mechanically mergeable.

## Customize the workflow without weakening its controls

The collection is intended as a starting point. Repositories differ in test commands, required reviews, release practices, and the meaning of a completed change. Put those expectations where the agent can reliably discover them and keep personal model choices separate from reusable skill text.

![Full-stop workflow text making its no-merge endpoint explicit](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/86a99cb0-4c5c-47ce-e975-8f500df73200/lg2x =1920x1080)

*An explicit endpoint makes the intended handoff reviewable.*

The host's permissions and branch protections should enforce consequential boundaries independently where possible. Instructions can tell an agent to avoid an action, while tool access and repository rules determine whether the action is available or accepted.

An incremental evaluation can start with PR descriptions and monitoring, then add the review dependencies and the full-stop workflow. Assess whether it produces direct evidence, concise explanations, and useful responses to CI failures. A smaller automated process that is observable is easier to trust than a larger one whose intermediate decisions are hidden.

Keep a final report tied to live state: PR URL, current head, checks, reviewer outcome, verification, and any remaining human approval. That report should make it clear whether the change is ready, waiting, blocked, or merged.

## Final thoughts

tstack focuses on the work between a patch and a completed delivery: proving behavior, obtaining review, explaining the change, and staying with CI. Its skills compose those responsibilities into workflows with different endpoints.

**The useful gain is a more complete and inspectable delivery process.** It still depends on capable tools, relevant tests, clear authorization, and repository controls. Evaluate those together, and choose the final merge boundary deliberately rather than assuming that a skill file supplies its own enforcement.
