agentleFS
RIJUDEVxRIJUDEVx/agent-skills/full-send/SKILL.md

full-send

Skill1 starsChanged 3 days agoMITView on GitHub

Use when the user invokes `$full-send` to finish work end-to-end and merge.

  • Commits and pushes

20 other projects use a version of this, 11 of them edited.

Adopted by

Most recently taken up by

Used with

Projects with it also use leaving-pr-comments, sol-loop and 7 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • scottwaterSkill

    leaving-pr-comments

    Format comments an agent posts on GitHub on the user's behalf. Use whenever leaving a PR comment, review comment, or reply.

    Also in 8 projects that use this

  • scottwaterSkill

    sol-loop

    Review a change with GPT Sol in a loop until both agents agree. Use when the user says sol loop, or when another skill asks for a Sol review.

    Also in 8 projects that use this

  • assisjpSkill

    file-pr

    Prepare and open or update an authorized pull request with a concise problem-first description and verifiable evidence. Use when the user asks to create, file, open, or update a PR. Do not use merely to review a diff or when publication is not authorized.

    Also in 8 projects that use this

  • assisjpSkill

    takeover

    Take over an existing branch, pull request, worktree, or agent handoff while preserving the original goal, contributor credit, and concurrent work. Use when the user asks to take over, finish, rescue, or continue someone else's implementation. Do not use to replace a clear request to start new work.

    Also in 3 projects that use this

  • owidSkill

    babysit-pr

    Spawn a background agent that babysits an open PR — triggers a Codex review, watches CI, judges and fixes valid findings, replies to and resolves review threads, and loops to a cap. Never merges. Trigger when the user asks to "babysit the PR", "ask for codex review(s) and watch CI", or after pushing a substantial chunk to a PR branch.

    Also in 8 projects that use this

  • jaydubya818Skill

    no-comments

    Use when code comments need structural review, root-cause fixes, and constraint encoding.

    Also in 3 projects that use this

  • +1 more from scottwater

The file

Show its rules and text

We split this skill into the rules it gives an agent

27 rules. 1 is common, 14 are distinctive, and 12 are very specific to this project.

  • 1

    Common

    Most of the 20 edited versions we read keep these.

  • 14

    Distinctive

    This author's own choices. Worth a look.

  • 12

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  • could be automatic: a setting could enforce it
  1. Very specific:

    If the user did not explicitly invoke $full-send or clearly ask for full send, do not assume full autonomy.

    line 14
  2. Distinctive:

    Use the test methods that Proof needs, without asking first.

    line 25
  3. Distinctive:

    Look up the repo's rules before you open a PR:

    line 48
  4. Very specific:

    If .agents/skills/pr/SKILL.md exists, use it to open the PR.

    line 50
  5. Distinctive:

    Use the repo's documented CI command.

    line 54
  6. Very specific:

    Run every stage in order. The user names only $full-stop or $full-send.

    line 58
  7. Distinctive:

    Use what this session already shows.

    line 80
  8. Very specific:

    If a spec or tickets exist, or an agreed $architect design does, skip the stages they already cover.

    line 92
  9. Very specific:

    Every sub-agent model comes from the tiers in the t3-tools skill ("Choosing a model").

    line 109
  10. Very specific:

    If the repo has no tracker docs, use the local ticket form in to-tickets.

    line 132
  11. Distinctive:

    Run the repo's documented CI command.

    line 153
  12. Distinctive:

    Add one focused test that fails without the fix, when the behavior has none and the repo has a test setup.

    line 154
  13. Distinctive:

    When you cannot find a way to prove a change, you do not have full confidence.

    line 160
  14. Very specific:

    Before stage 8's last pass, read /Users/home/.agents/skills/full-send/references/review-loop.md and follow it.

    line 165
  15. Distinctive:

    Only act on checks and comments newer than the latest push.

    line 170
  16. Very specific:

    If the repo has .macroscope/check-run-agents/*.md, read those rules before you reply to a Macroscope finding.

    line 177
  17. Distinctive:

    Keep the PR at the size the goal needs.

    line 181
  18. Distinctive:

    If nothing has changed, stay quiet rather than posting filler comments.

    line 186
  19. Distinctive:

    If an overlapping PR makes this one obsolete, stop, report it to the user, and ask before closing the PR.

    line 187
  20. Very specific:

    Use one watcher per PR. Never write your own polling loop or sleep loop, and never run two watchers on the same PR.

    line 192
  21. Very specific:

    Only the thread that owns the PR watches it.

    line 200
  22. Very specific:

    If remaining is near 0, wait for reset with one background command, then watch again.

    line 211
  23. Distinctive:

    Before a merge, run git fetch and check the PR again.

    line 213
  24. Common:

    No human review still requests changes.

    line 228
  25. Very specific:

    Before you post any comment on the user's behalf, read /Users/home/.agents/skills/full-send/references/comment-format.md and follow it.

    line 238
  26. Distinctive:

    Ask only when you cannot continue alone:

    line 249
  27. Distinctive:

    If no question tool is available, or the tool returns no answer, take the safe path: leave the PR open and unmerged, and start your final …

    line 262

“Common” is measured: kept by at least 6 in 10 of the 20 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Full Send

The user invoked $full-send, so they are not watching this thread and want the work completed end-to-end without them. Your updates and your final message go unread until long after you stop. You own the work from its current state to a merged PR.

If the user did not explicitly invoke $full-send or clearly ask for full send, do not assume full autonomy. If they did, everything below applies.

Grant

The user grants you permission to:

  • Merge the PR once the merge gate passes. This is the only agent merge authority. It overrides any repo PR skill rule that says "mark ready, then stop." Sub-agents never merge.
  • Force-push the PR's own branch with --force-with-lease after a rebase.
  • Use the test methods that Proof needs, without asking first.

Testing permission

A $full-send request is the permission. If a project file or other instruction says to ask before a test method, or to leave testing to the user, this request replaces that rule for this task.

That includes ask-first rules for computer use, browser automation, simulators and devices, running the app or a dev server, screenshots, and visual checks. Use the method that gives direct proof. List it in the report.

Rules about how to test still apply. Follow rules that name the correct command, fixture, or check. This permission only removes the ask-first or leave-it-to-the-user step. If a preferred method cannot prove the change, use a gated method under this permission.

It covers only the tests needed for this task. It does not add permission for the steps under "Asking the user", such as production changes or data deletion. It also does not bypass a harness or system approval prompt if one appears.

Repo rules

Look up the repo's rules before you open a PR:

  • If .agents/skills/pr/SKILL.md exists, use it to open the PR. Its "mark ready, then stop" rule does not apply here. Full send's merge grant does.
  • Otherwise open the PR directly with gh pr create as a draft, following AGENTS.md and CONTRIBUTING.md.
  • Use the repo's documented CI command. Do not substitute a generic one.

Stages

Run every stage in order. The user names only $full-stop or $full-send; picking the skills is your job. Record each stage as run or skipped, with the reason, and put that ledger in the report. A stage marked "may skip" needs a stated reason.

#StageDo
1FrameWrite the goal, the done condition, what is out of scope, and how you will prove it, before any code
2SizePick Direct, Design, or Split. See "Routes"
3ImpactUse the Blast radius mode of interrogate: who and what this touches, and the one fact it is safe because of. May skip only for a local change with no shared code, schema, API, auth, or data
4DesignDesign and Split routes, when the shape is open: run architect
5PlanSplit route: run to-tickets
6BuildRead the implement guide. Direct and Design use its TDD loop when there is a cheap test target. Split uses "Fan out a spec". If you are on the default branch, create a branch first. Use the smallest change that works, and fix the case that happened, not every case that could
7ProveRun the proof from stage 1, plus anything impact flagged. See "Proof"
8ReviewRun each pass in "Review passes". Fix or decline every finding before the next pass
9Open the PRRebase onto origin/<base>, then open the PR with the repo rules above. Write the body through unslop, with one short line on how you proved the change unless the template covers it. Use t3-tools for the T3 steps. Right after gh pr create, call link_pull_request with the URL if T3 tools are present
10Push and gatePush the tested commit, run the repo CI command, and wait for the required check to succeed on the head SHA before gh pr ready. Then start the watcher. See "Watching"
11BabysitFix real findings and CI failures. Get proof for each fix before you push it. See "Review rules"
12MergeWhen the merge gate passes. If the repo uses a merge queue or auto-merge, stay until GitHub reports the PR as merged
13ReportThe route and why, the stage ledger, the PR link, the merge commit, your proof, the reviewer model used (and any substitution), and each decision you made for the user

Routes

Use what this session already shows. If that does not settle it, start one read-only scout sub-agent on the cheapest capable model. It reports the files and modules involved, any new or changed public interface or schema, how many slices could ship independently, and any existing spec, tickets, or ADRs. It does not edit. The route is your decision, not the scout's.

RouteUse when
DirectOne concern, the shape is obvious, and it fits one session
DesignIt fits one session, but the shape is open: a new module, interface, or data model, or more than one reasonable design
SplitIt is too big for one session, or it holds several slices that ship independently

If a spec or tickets exist, or an agreed $architect design does, skip the stages they already cover. Take the lightest route that fits. If the work proves bigger than the route, move up one and say so. All routes end in one PR.

Review passes

PassRuns
code-reviewEvery behavior change: repo standards and the spec
interrogate, review modeSplit route, a real risk from impact, or anything touching auth, permissions, payments, data loss, or concurrency
Review loopEvery behavior change. See "Review loop"

Comment, doc, or format-only changes run the last pass only. interrogate findings count only when a run proves them.

Models

Every sub-agent model comes from the tiers in the t3-tools skill ("Choosing a model"). That skill also says how to set one and what to do when one fails.

WorkTier
Scout, build, merge work, code-reviewFast. Move a job up to Balanced if a Fast model gets it wrong twice
architect runnersStrong: Opus plus one OpenCode model, so two families
interrogate reviewersStrong: all three models, one per family
Review loopCheap strong, first model (see references/review-loop.md)

Loading

code-review, interrogate, unslop, and t3-tools are normal skills. Load architect from /Users/home/.agents/skills/architect/SKILL.md. Load the others from /Users/home/.agents/skills/full-send/routes/<name>/GUIDE.md: to-tickets and implement.

Nobody is watching, so these rules override those skills and guides on this task:

  • Where they say to check with the user (seams, the ticket breakdown, which candidate to pursue, unclear intent), decide yourself and list the decision in the report.
  • grilling needs the user, so do not run it here.
  • If the repo has no tracker docs, use the local ticket form in to-tickets.
  • Replace the final review and "mark ready" steps in implement with stages 7 to 13, run on the integration branch.
  • Merger sub-agents may merge worktree branches into the integration branch. Only this thread merges the PR.
  • A missing decision about how to build it is yours. A missing decision about what to build falls under "Asking the user". If several are missing, stop and tell the user to run $architect first.

Stay active from stage 1 to stage 13. If you end your turn while checks or reviews are pending, the work stops, because nobody will prompt you again. Wait with the watcher so something wakes you when the PR changes. If you stop before the merge, call unwatch_pull_request first.

Proof

Proof is evidence you observed yourself in this session: command output, a reproduction, a screenshot. Use the most direct proof the change allows:

  • Reproduce the original failure, apply the fix, then watch the same reproduction pass.
  • Run the repo's documented CI command.
  • Add one focused test that fails without the fix, when the behavior has none and the repo has a test setup.
  • For UI and runtime behavior, run the app and look at the change. Green mocked tests do not prove that the user experience works. Attach screenshots to the PR when they help and you have a way to upload them.

When you cannot find a way to prove a change, you do not have full confidence. Ask the user.

Review loop

Before stage 8's last pass, read /Users/home/.agents/skills/full-send/references/review-loop.md and follow it. It holds the reviewer model, budget, round brief, and stop rules.

Review rules

Only act on checks and comments newer than the latest push. Verify every review finding against the source before you change code. Fix real findings and CI failures. Distinguish repository failures from infrastructure flakes. When you dismiss a false positive, reply with a written reason and resolve the comment.

  • Any auto-review on the head has finished, and each finding is fixed or dismissed with a written reason.
  • If the repo has .macroscope/check-run-agents/*.md, read those rules before you reply to a Macroscope finding. Its findings cite them.
  • CodeRabbit is advisory. Treat its findings like any other finding, but never wait for it and never hold a merge for it.
  • Keep the PR at the size the goal needs. Review loops tend to grow a PR one cheap-looking fix at a time. Fix real bugs in the intended case. Decline the rest with a written reason and list them as follow-ups: unneeded tests, guards for edge cases that do not matter, extra integration or compatibility, and small performance costs. Prefer the fix that deletes or narrows code.
  • If nothing has changed, stay quiet rather than posting filler comments.
  • If an overlapping PR makes this one obsolete, stop, report it to the user, and ask before closing the PR.

Watching

Use one watcher per PR. Never write your own polling loop or sleep loop, and never run two watchers on the same PR.

  • In T3 Code, handle the existing checks and comments first. Then call watch_pull_request and end your turn. T3 Code wakes you when a check fails, the required checks pass, someone comments or reviews, or the branch conflicts.
  • Outside T3 Code, poll the head check-runs with gh api in one background command at a modest interval. Never run a tight loop.
  • Only the thread that owns the PR watches it. If you are a delegated child task (a reviewer or any delegate_task child), never call watch_pull_request.
  • A wake is news, not a merge decision. Check the merge gate yourself.
  • Unwatch when you hand off. Call unwatch_pull_request before you stop, whether the PR is ready, blocked, or you are asking the user. A merge or close ends the watch on its own.
  • Use gh api repos/<owner>/<repo>/pulls/<n> and gh api repos/<owner>/<repo>/commits/<sha>/check-runs to read the PR and its checks. gh pr view and gh pr checks use GraphQL, which runs out first.
  • "Stopped watching, could not read it" usually means the GitHub rate limit is used up. Run gh api rate_limit --jq .resources.graphql before you watch again. If remaining is near 0, wait for reset with one background command, then watch again. Never watch again in a tight loop.
  • Before a merge, run git fetch and check the PR again. Never merge when it is BEHIND or DIRTY, or when base commits that landed after the last green run touch this PR's files. Rebase, push, and wait for green again.

Merge gate

Full confidence means all of these are true on the latest commit:

  • Your proof covers every change in the diff.
  • Trust the forge's verdict, not a green check list. Ready means the forge agrees the PR can merge: read the status of the current head SHA and require the required check to be success. After any amend, rebase, or base update, rerun CI. Exit 0 is not the gate.
  • Any auto-review on the head has finished, and each finding is fixed or dismissed with a written reason.
  • No human review still requests changes.
  • The branch is up to date with its base, and GitHub reports it as mergeable.

Merge with the method the repo allows. If its docs do not say, read allow_squash_merge, allow_merge_commit, and allow_rebase_merge from gh api repos/<owner>/<repo>. Never use --admin or other bypasses. Merge only through branch protection as configured.

Comment format

Before you post any comment on the user's behalf, read /Users/home/.agents/skills/full-send/references/comment-format.md and follow it.

Asking the user

A question in a normal message goes unseen, and the thread looks done. To ask the user something, use the harness's question tool so the thread shows that it is waiting: AskUserQuestion in Claude Code, request_user_input in Codex, or the question tool your harness has. Put all the context in the question: the PR link, what blocks you, and the options with your recommendation first.

Ask only when you cannot continue alone:

  • You cannot prove the change.
  • The merge gate cannot pass, and you cannot fix that yourself.
  • The next step is outside the grant above: deleting data, touching production, changing things outside the repo, closing a PR, or force-pushing any other branch.
  • The goal is ambiguous in a way that changes the result.
  • Another PR makes this one obsolete.

Decide everything else yourself with sensible defaults, and list those decisions in the report.

If no question tool is available, or the tool returns no answer, take the safe path: leave the PR open and unmerged, and start your final message with the question.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.