How to Use tstack Agent Skills in Claude Code and Codex: Install Theo's Daily Skills and Ship a PR End to End

Introduction

Most coding agents can write a patch. Far fewer can take that patch all the way to a merged pull request without you watching every step: proving it works, getting a real review, filing a readable PR, waiting out CI, and fixing only the findings that matter. tstack is a small collection of agent skills that encodes exactly that loop. This tutorial installs the skills in Claude Code or Codex and walks one change through the full pipeline: full-send to open the PR, council for a multi-model review, and babysit-pr to watch it to merge.

Quick answer

Clone tstack, copy its skills folder into ~/.claude/skills/ or ~/.codex/skills/, then say “full send” in your agent: it proves, reviews, files, babysits, and merges your pull request without you watching.

Evidence

tstack arrived fast. On GitHub Trending for October 26, 2026, the repository gained 1,356 stars in a single day, and its total stood at roughly 1,500 stars as of October 27, 2026, according to the GitHub repository page. That velocity is worth reading with care: part of the spike came from the author’s YouTube video “These 3 skills changed my life”, so some of the attention is video-driven and may fade, unlike the steady adoption curve of an established tool. The repository itself is only days old, which means skill names and behavior may still change.

The author’s own framing is modest and useful. The tstack repository describes the collection as “The agent skills I use every day, cleaned up so anyone can use them.” The same README is explicit about the portability boundary: “Some use T3 Code features when they are available and fall back to native tools when they are not.” That fallback matters for this tutorial, because everything below works without T3 Code except the cross-provider review loop, which needs its own harness.

The collection holds nine skills, not the six that early aggregator posts listed: full-send, full-stop, council, sol-loop, file-pr, takeover, babysit-pr, modernize, and leaving-pr-comments. Several skills call others, so installing the whole folder is the correct default: full-send uses sol-loop, file-pr, and babysit-pr, and takeover uses modernize, file-pr, babysit-pr, and leaving-pr-comments. If you cherry-pick single skills and the workflow stalls, a missing dependency is the first thing to check.

Prerequisites

• Claude Code or Codex installed and working on your machine.
• Git and a GitHub repository you can open pull requests against. A small personal repo is ideal for the first run.
• An authenticated GitHub CLI, verified with gh auth status. The skills drive GitHub through gh, so an unauthenticated CLI stops the workflow at the first PR step.
• python3 installed, because babysit-pr uses a pr-wait script written in Python.
• For the council step: either T3 Code, which provides cross-provider subagents through delegate_task, or your own harness that can run models from other providers. Without one of these, council and sol-loop cannot run, and you should skip that step rather than fake it.
• Basic comfort with branches, pull requests, and CI. The skills do the waiting, but you still own the merge decision until you trust the loop.

Step 1: Verify your prerequisites

Before cloning anything, confirm the two hard requirements. Run these commands in your terminal:

gh auth status
python3 --version

gh auth status should report a logged-in account with repo scope. If it reports that you are not logged in, run gh auth login and complete the browser flow before continuing. python3 --version should print a 3.x version. If either check fails, fix it now: every later step assumes both tools work, and a failure here looks confusingly like a skill failure later.

Step 2: Clone tstack and install the skills

Clone the repository, then copy its skills folder into your agent’s skills directory. The tstack install instructions give both paths:

git clone https://github.com/t3dotgg/tstack
cp -R tstack/skills/* ~/.claude/skills/   # Claude Code
cp -R tstack/skills/* ~/.codex/skills/    # Codex

Use only the line for the agent you run, so you keep one canonical install per machine. Verify the install by listing the directory:

ls ~/.claude/skills/

You should see nine entries, including full-send, council, and babysit-pr. If the directory does not exist yet, create it first with mkdir -p ~/.claude/skills/ (or the Codex equivalent) and rerun the copy. Start a fresh agent session after installing: skills are typically discovered at session start, so a session opened before the copy may not see them.

Skills in Claude Code follow the discovery model in the Claude Code skills documentation: a skill is a directory with a SKILL.md file that the agent loads when the task matches. That is why the copy step is literal file copying rather than a package install: the skill files are the product, and you can read and edit every one of them.

Step 3: Pick a small, real change

For the first full-send run, choose a change with a fast, reliable test suite: a bug fix with a regression test, a small refactor covered by existing tests, or a fix you can verify in under two minutes. Avoid a large refactor or flaky tests, because proving will either take a long time or fail in ways that teach you nothing about the skills.

Create a branch and make the change as you normally would:

git checkout -b fix/meaningful-bug-fix

Work until the change is complete and locally green, then stop. Do not commit yet if your normal flow leaves committing to the agent, but do have the tests passing. The full-send skill’s first job is proving the change, and it can only prove what is actually on the branch.

Step 4: Say “full send” and watch the proving step

In your agent session, on the branch with your change, say:

full send

The skill takes over the rest of the loop. Its first phase is proving: it runs the relevant tests and checks the change actually does what it claims. If tests fail, it fixes the change or reports back rather than pushing a broken branch. Do not interrupt proving to file the PR manually: filing happens only after proving passes, and short-circuiting that order removes the safety the workflow exists to provide.

Expect clarifying questions on the first run, especially about which tests prove the change and what the PR should emphasize. Answer them concretely: file-pr leads with the problem, and it can only lead with a problem you actually stated.

Step 5: Let file-pr write a problem-first PR

Once the change is proven, the skill files the PR through file-pr. A file-pr PR is deliberately short and leads with the problem, not an inventory of changes. That is a deliberate editorial choice worth noticing: reviewers decide whether the change deserves to exist from the problem statement, and the diff itself shows what changed. If the generated PR reads like a changelog of files touched, tell the agent to rewrite it around the problem and the user-visible effect. The skill is a starting point, and the README explicitly invites you to edit skills to fit your taste.

Check the opened PR on GitHub before moving on. Confirm three things: the problem statement is accurate, the test evidence is mentioned, and the branch contains only the intended change. If any of those is wrong, fix it now while the PR is young.

Step 6: Run a council review

With the PR open, ask for a multi-model review:

council

Council gets review from three models from different providers and loops until they agree. This catches the class of problem a single model misses: one reviewer fixates on style, another on correctness, and the loop forces them to converge on findings they all endorse. The cost is time, so reserve council for changes where a missed bug is expensive, not for trivial docs tweaks.

If you do not have T3 Code or another cross-provider harness, this step fails with an error about subagents on other providers’ models. That is an expected limitation, not a bug in your install: the README states that council and sol-loop need subagents on other providers’ models, with T3 Code providing that through delegate_task. In that case, skip council and use your normal single-model review. Do not pretend a single-model review is a council review when you report results to your team.

When council finishes, read its findings before babysitting starts. Genuine findings go back into the branch as fixes. Findings you disagree with should be answered in the PR, not silently ignored, because the next reviewer, human or bot, will raise them again.

Step 7: Babysit the PR through CI to merge

Finally, hand the PR to babysit-pr:

babysit

Babysit-pr watches the PR through CI and review bots and fixes the real findings. The word “real” does heavy lifting here: CI produces noise alongside signal, and the skill’s job is to distinguish a failing test caused by your change from a flaky test or an unrelated bot complaint. It uses its pr-wait script, which is why python3 is a hard requirement, to poll PR status without you refreshing the page.

While babysitting runs, resist the urge to push manual fixes on top of it. Two writers on one branch produce merge conflicts and confused CI states. If you spot something urgent, tell the agent rather than pushing around it, so the babysitting loop keeps a single coherent view of the branch.

When CI is green and review findings are resolved, full-send merges the PR. If you are still building trust in the loop, use full-stop instead on your next run: it runs the same pipeline but stops when the PR is ready for you to merge. Graduate to full-send only after several PRs where you agreed with every automated decision.

Step 8: Make the skills yours

The README’s closing advice is the most durable part of the collection: “These are starting points. Edit them.” Put personal settings, like which models sit on your council, in your CLAUDE.md or AGENTS.md, so you can update the skills without losing them. Two edits pay off immediately. First, pin the council model list to providers you actually have API access to, so council never stalls waiting on a model you cannot run. Second, add your repo’s test command to the proving guidance if the skill guesses wrong on the first run. Both edits live outside the skill files, so a future git pull in your tstack clone updates the skills without clobbering your settings.

To update later, pull the repository and recopy with cd tstack && git pull && cp -R skills/* ~/.claude/skills/. Do this deliberately, not on a schedule: the repository is days old, and an update may rename a skill or change its behavior. Rerun a full-stop PR before trusting full-send again after an update.

Troubleshooting

The agent does not recognize “full send”. The usual cause is discovery, not installation. Confirm the skill files are in the right directory with ls ~/.claude/skills/ or ls ~/.codex/skills/, then start a fresh session. A session opened before the copy will not see new skills. If the directory listing is correct and a fresh session still misses the skill, check that you copied into the directory for the agent you are actually running: Claude Code reads ~/.claude/skills/, Codex reads ~/.codex/skills/, and the two are not interchangeable.

The workflow fails at the PR step with a GitHub authentication error. Run gh auth status outside the agent. If it reports no logged-in account, run gh auth login and complete the flow, then retry. If gh auth status is healthy but the agent still fails, the agent’s environment may not inherit your shell’s credentials; start the agent from the same terminal where gh auth status succeeds rather than from a launcher with a stripped environment.

Council fails with an error about other providers’ models. This is the documented harness requirement. Council and sol-loop need subagents on other providers’ models. T3 Code provides this through delegate_task; otherwise you need a harness that can run those models. Without either, skip council and use a normal review. Do not work around the error by pointing all three council seats at the same model: the value of council is disagreement between different providers, and three copies of one model cannot disagree independently.

Babysit-pr fails or hangs while waiting on CI. Check python3 --version first, since the pr-wait script needs Python 3. Then check the PR’s CI state on GitHub directly: if CI itself is stuck or failing for infrastructure reasons unrelated to your change, babysit-pr correctly waits rather than merging, and the fix belongs to your CI setup, not the skill. If CI is green but babysit-pr still waits, the script may be polling a stale PR reference; stop the session, confirm the PR number, and restart babysitting with the PR explicitly named.

A skill behaves differently than the README describes. The repository is days old and actively changing, so drift between docs and behavior is plausible. Read the skill’s SKILL.md file in your install directory: the file on disk is what the agent actually follows, and it is authoritative over any blog post or aggregator summary. If the on-disk skill contradicts the README, trust the on-disk file for that run and check for repository updates afterward.

T3 Code features are unavailable in my setup. That is fine for most of the workflow. The README states that some skills use T3 Code features when available and fall back to native tools when they are not. Expect the fallback to be slower or less automated in the affected steps, and do not treat fallback behavior as a failure. Only council and sol-loop have a hard external dependency; the rest of the loop degrades gracefully.

FAQ

Two points deserve emphasis here. First, tstack is not a product launch: it is one developer’s daily workflow, published as plain files, and its GitHub velocity in late October 2026 partly reflects a popular video rather than enterprise adoption. Evaluate it on whether one full-stop PR run saves you time, not on its star count. Second, the skills compose with your existing workflow rather than replacing it. Teams already sharing skills through a registry can keep that system for shared knowledge and use tstack for the individual PR loop, as our guides to n8n agent skills and sharing Gemini skills with your team show.

Conclusion

Install the whole folder, run one small change through full-stop before trusting full-send, use council only where multi-model disagreement is worth its cost, and let babysit-pr do the waiting you used to do by hand. That is the entire tstack loop, and it fits in a single afternoon of practice. For a broader view of how agent skills shape coding workflows, the complete n8n guide collects our workflow automation tutorials in one place, and the n8n agent skills tutorial shows the same SKILL.md pattern applied to building workflows instead of landing pull requests.

Frequently asked questions