Full Send: The Skill Pack That Lets Agents Merge Their Own PRs

Somewhere between the link-in-bio builders and the Free Pascal container classes (more on the search-results graveyard later), there is a repository called tstack that deserves the attention its name keeps accidentally diverting. It lives at t3dotgg/tstack, it comes out of the same ecosystem as T3 Code — the ping.gg-adjacent agent harness — and it is, on its face, almost nothing: a folder of skill files, a README, an MIT license. What it actually contains is a point of view about how far coding agents should be allowed to go when nobody is watching.

The README’s own framing is disarmingly modest: “The agent skills I use every day, cleaned up so anyone can use them.” That’s the whole pitch. No framework, no API, no package to install in the dependency sense — the skills work in Claude Code and Codex, lean on T3 Code features when they’re present, and fall back to native tools when they’re not. The unit of distribution is prose. The unit of value is workflow.

Nine verbs for the pull-request lifecycle

Strip away the branding and tstack is a set of named procedures — invoked by short spoken commands like “full send” or “babysit” — that cover the territory between “I made a change” and “it’s merged.” The names are jokey; the coverage is not.

full-send is the headline act: it takes a change all the way to a merged PR with nobody watching. It proves the change, reviews it, files the PR, babysits it through CI, and merges it. full-stop is the same pipeline with the last door left closed — it stops when the PR is ready for a human to merge. That single distinction is doing a lot of ideological work in this repository, and we’ll come back to it.

file-pr encodes a small editorial opinion that experienced reviewers will recognize: a pull request should lead with the problem, not an inventory of changes. babysit-pr watches a PR through CI and review bots and fixes what it calls “the real findings” — a phrase that quietly contains an entire philosophy about how much bot commentary deserves engagement. modernize rebases an old PR and, more interestingly, decides whether it should still exist at all. leaving-pr-comments is automatic formatting for comments an agent posts on your behalf, which is the kind of unglamorous hygiene that separates agents you can work alongside from agents you have to apologize for.

The skills compose. full-send calls sol-loop, file-pr, and babysit-pr; takeover calls modernize, file-pr, babysit-pr, and leaving-pr-comments. That dependency graph is the closest thing the repo has to an architecture, and it’s a sensible one: the high-autonomy commands are assembled from smaller, individually useful procedures rather than being monoliths.

Disagreement as a quality signal

The two review skills are where tstack stops being a convenience pack and starts being an argument.

council gets review from three models from different providers and loops until they agree. sol-loop is the two-agent version: it reviews a change with GPT Sol in a loop until both agents agree. The underlying idea is old — it’s ensemble methods, adversarial review, the intuition that models from different training lineages fail differently — but applying it to code review inside a coding-agent session is a genuinely interesting move. A single model reviewing its own work has an obvious conflict of interest. Three models from three providers, forced to converge, at least fail independently.

Whether agreement actually correlates with correctness is an open empirical question, and the README doesn’t claim it does. What the design does assume is that cross-provider disagreement is cheap to obtain and informative when it happens. In a landscape where the coding-agent field is consolidating around a handful of harnesses — Claude Code positioned as the strongest “coding brain,” Codex as an agent-native platform — tstack treats those harnesses less as rivals and more as interchangeable reviewers in a panel.

There’s a practical catch, and the README is honest about it: council and sol-loop need subagents running on other providers’ models. T3 Code does this with a feature called delegate_task; without it, you need a harness that can run those models yourself. The most ambitious skills in the pack are also the ones with the most environmental prerequisites.

The sociology is the software

The most quietly original skill here is takeover. It finishes someone else’s PR, branch, or agent thread — and keeps their credit. Read that again. The design goal isn’t just completing abandoned work; it’s completing abandoned work without erasing the person (or agent) who started it.

That matters because abandoned pull requests are one of the real costs of the current agent boom. Agents generate changes far faster than humans can shepherd them through review, and the result is a growing graveyard of half-finished branches and stalled agent threads. modernize’s willingness to conclude that an old PR shouldn’t exist anymore is the other half of the same answer: not every stalled change deserves resuscitation, and pretending otherwise is how backlogs calcify. babysit-pr addresses the third failure mode, the PR that’s fine but dies waiting on CI flakiness and bot noise.

None of this is algorithmically hard. It’s sociologically precise. The value is in correctly identifying which parts of the collaborative workflow around code — not the code itself — are now bottlenecks, and encoding the etiquette for an agent occupying a role that used to require a human colleague.

Honest about being glue

It’s worth saying plainly: tstack is glue, and it’s glue in the best sense. The skills are prompt-level procedures that orchestrate an authenticated GitHub CLI, a bit of Python for babysit-pr’s PR-waiting script, and whatever model-delegation machinery your harness provides. There is no engine here. If you were expecting a system, you’ll be disappointed; if you were expecting a well-edited set of opinions about agent workflow, you’ll find exactly that.

The README’s “Make them yours” section is the tell. “These are starting points. Edit them.” Personal settings — like which models sit on your council — belong in your CLAUDE.md or AGENTS.md, so you can update the skills without losing your customizations. That’s a deliberately anti-product design decision. The repo is positioned as upstream for your own workflow rather than as a tool you consume, which is unusual and, frankly, healthier than the alternative. Most skill packs want to be installed; this one wants to be forked conceptually.

The rough edges are visible and minor. The inter-skill dependencies mean you can’t cherry-pick naively — pull full-send without its three dependencies and you’ve bought a verb that can’t do anything. The multi-provider requirements gate the most interesting skills behind either T3 Code or a DIY harness. And the whole pack presumes a workflow built on pull requests and GitHub specifically; if your team ships differently, most of this is vocabulary without referents.

A small fish in a flooded pond

Context matters here, because “skills” have become a genre. Anthropic has been building out the concept formally — there’s an official guide to building skills for Claude, and Claude Academy now carries courses on running long, hands-off agent sessions you can trust. The community side has exploded accordingly: the awesome-claude-skills list at one point absorbed 832 Composio automation skills into a subfolder while keeping about 30 curated skills at its root — a ratio that tells you everything about the signal-to-noise problem in this space.

Against that backdrop, tstack’s nine skills are almost provocatively small. No PDF extraction, no PowerPoint generation, no domain-name brainstorming. Just the PR lifecycle, done well, by someone who visibly uses the thing daily. The minimalism reads as a claim: the interesting frontier isn’t teaching agents new capabilities, it’s deciding how much of the existing shipping process they’re allowed to own.

It’s also worth noting, with some affection, what the surrounding search landscape says about the name. “Tstack” is simultaneously a free link-in-bio builder, a LIFO pointer stack in Free Pascal, a generic collection in Delphi, and — one letter off — a TypeScript scaffolding CLI with actual paying sponsors. The repo’s discoverability is hostage to a crowded namespace. That says nothing about its quality and everything about how bad we all are at naming things.

The open question

The unresolved tension in tstack is the one baked into its best-known command. full-send merges without a human in the loop; full-stop exists for people who aren’t ready for that. The README offers both without ranking them, which is either diplomatic or an admission that the author hasn’t fully decided either.

This is the live question for the whole field — the one every coding-agent roundup eventually circles: can agents ship software without human oversight, and if so, what has to be true first? tstack’s implicit answer is that oversight can be restructured rather than removed. The council provides the check, the babysitting provides the patience, and the human provides — optionally — the final merge. Whether three disagreeing models are an adequate substitute for one skeptical colleague is exactly the experiment this repository packages up and hands to anyone who wants to run it.

What’s unclear from the available material is adoption. There are no numbers here — no star counts, no testimonials, no notable users to name. The README’s authority rests entirely on “I use these every day,” which is either the strongest or the weakest endorsement available depending on how much you trust the author’s judgment. For a pack of workflow opinions, that’s probably the right kind of authority. For infrastructure, it wouldn’t be.

Where it goes from here depends on whether skills-as-personal-workflow becomes a shared genre or stays a personal artifact. The composability is promising — the small verbs could be recombined into pipelines the author never imagined. The multi-provider review loop is the piece most worth watching, because it’s the one that generalizes past GitHub and past pull requests. And takeover’s credit-preservation rule is the kind of small ethical design decision that will matter more, not less, as agents leave more half-finished threads behind them for other agents to inherit.