
pipe-skills
Write a Linear or GitHub issue as its own spec, implement it in reviewed steps, ship it, or work through a whole Todo queue on its own.
- GitHub stars
- 18
Install
/plugin install pipe-skills@pipe-skillsRun it inside Claude Code after adding the marketplace with /plugin marketplace add felipeam86/pipe-skills.
Contents
Discovered from sourceSkills 13
Advise
Change nothing: do not use Edit, Write, or NotebookEdit, and do not run a command that changes state. Read and search as much as you need, with subagents for wide reading.
Answer the question that was asked, honestly, in short and simple words. Say what you are not sure about, and give one recommendation. The user gives the go on a later turn, and a go for one step is not a go for the next.
Assess an issue
An issue that waits can drift from the code that it specifies. Give a verdict on one issue in Backlog or Todo, with the evidence. Change no file except by the pull of the reference branch, post no comment, and change nothing in the tracker: the session or the skill that ran you applies the verdict after the user approves it, as Apply a verdict says. For an issue in another state, say that it is out of scope, and stop.
The project CLAUDE.md names where it tracks work. Read the tracker file for it, ${CLAUDE_PLUGIN_ROOT}/trackers/linear.md or ${CLAUDE_PLUGIN_ROOT}/trackers/github.md, and run each operation below as that file says.
Read
- Read an issue, with its comments and the date it was created, and Find the blockers.
- The base of the check comes from the last review comment (below). Its SHA is the base when its branch is
<ref>, compared without theorigin/prefix, andgit merge-base --is-ancestor <sha> <ref>succeeds. Else its date is the base, because a review on another branch, or a SHA that the repository no longer holds, says nothing about the commits of<ref>. Without a review comment, the base is the date the issue was created. - The reference branch
<ref>is the branch you stand on, because the user runs you from the branch that the issue builds on, which can differ from the default branch of the remote. A skill that runs you can name another one. First pull it withgit pull --ff-only, unless the skill that runs you already did, so that it holds the new commits of its remote. When the pull fails, say so, and check the branch as it is.
Evidence
Each check gives facts with their proof: a path, a commit SHA, a pull request, or an issue.
- Names. Each file, directory, function, command, or module that the issue names as existing still exists, with
git ls-filesandgit grepon<ref>. A path that the plan says to create is missing until the work is done, and that is not drift. When the issue names nothing, search by the concepts of its goal, and say that the evidence is weaker. - Changes. The commits since the base on the named paths:
git log <sha>..<ref> -- <paths>, orgit log --since=<YYYY-MM-DD> <ref> -- <paths>. Read each one, and say what it changed in the facts of State and in the steps of Plan. - Work already done. Read the code against the Success criteria. Search the merged pull requests (
gh pr list --state merged --search <terms>with a GitHub remote) and the closed issues for the same goal. - Goal. When the issue has an outcome, it is still open (List the outcomes). Each blocker is still open, or it was closed or canceled.
- Overlap. An open issue of List the backlog with the same goal.
Verdict
Give one verdict:
| Verdict | When | Proposed change |
|---|---|---|
current | The issue still matches the code. | A review comment only. |
drifted | The goal holds, but a fact or a step is wrong. | The new text of each section that changes. |
done | The code already meets the success criteria. | Close, with the commit or the pull request that did the work. |
superseded | Another issue or a design change replaces it. | Cancel, with the issue that replaces it. |
obsolete | The goal no longer applies. | Cancel, with the reason. |
ask | The code cannot decide between two verdicts. | One question for the user. |
The code can prove drift, but it cannot prove that the user still wants the goal. Keep these two parts apart: The code says holds only facts with their proof, and Your call holds the question that only the user can answer, or none. Give obsolete only on a fact, such as a removed module or a closed outcome. When only the business value is in doubt, give ask.
Report
Start with the verdict and one line of reason. Then The code says, Your call, Proposed change, and the checked commit SHA with the paths you checked. Run alone, end with one question: may the session apply the proposed change and post the review comment? Run by another skill, give the report in the form that its prompt asks for.
Apply a verdict
These steps never run in your own run. A session or pipe-skills:sweep runs them, only after the user's go:
- Run the change of the verdict:
current: no change.drifted: rewrite the description with the proposed text andpipe-skills:final-state, as the Update ofpipe-skills:prdsays.done: Close.superseded: Cancel, as a duplicate when the other issue holds the same work.obsolete: Cancel.ask: the verdict that the user's answer gives.
- Then add the review comment, last, so that the next check reads its base from it. For
drifted, it is also the comment of the change and its reason.
Review comment
The hash comes from Hash the description after the change:
**Assessed** <YYYY-MM-DD>: `<verdict>`, on `<ref>` at `<sha>`, description `<hash>`.
Paths: `<path>`, `<path>`.
<the code says, as bullets>
<the user's decision, quoted, when there was a question>
Implement and ship a queue of issues
You are the orchestrator. You do not read, write, or review code. The project CLAUDE.md names where it tracks work. Read the tracker file for it, ${CLAUDE_PLUGIN_ROOT}/trackers/linear.md or ${CLAUDE_PLUGIN_ROOT}/trackers/github.md, and run each operation below as that file says.
Queue
- The issues the user names. Else the queue of the project that the argument or the project
CLAUDE.mdnames: everyTodoissue, in the order of the tracker file. When the queue of the tracker file needs a project that the argument does not name, list the outcomes and stop before you start. - Freeze the queue at the start. An issue created during the run is often a follow-up that the user has not read yet.
- Read the target branch (the branch the user is on) and the repository root.
State the queue in one line per issue, then start. The call of this skill authorizes, for the issues in the queue only, to push, merge, close the issue, and delete the branch and the worktree. It does not authorize a version bump, a tag, or a release.
Run
One issue at a time, because each one merges into the target branch before the next starts. For each issue:
- Skip it when it is no longer
Todo, or when it has an open blocker. - Start a fresh subagent with the Agent tool:
isolation: "worktree", the model of this session, and the prompt below. Do not fork, so that the subagent starts clean. - End the turn and wait for its notification. When it ends without its report, ask it for the report with SendMessage.
- Record its report, and remove its worktree when the harness did not. A worktree that the Agent tool made is locked: remove it with
git worktree remove -f -f.
A result other than shipped does not stop the loop. When a guard or a tool stops a subagent, start one more subagent for the same issue. When the same failure stops three issues in a row, the failure is in the environment: end the loop. At the end, take the issues skipped for a blocker once more when they have no open blocker now. An issue skipped for its verdict waits for the user.
Subagent prompt
Implement and ship the issue
<identifier>of<root>, with no stop for the user. The target branch is<target>. Read${CLAUDE_PLUGIN_ROOT}/skills/implement/SKILL.mdand${CLAUDE_PLUGIN_ROOT}/skills/ship/SKILL.md, and the tracker file<tracker file>, and follow them with these changes:
- Before anything else, assess the issue as
${CLAUDE_PLUGIN_ROOT}/skills/assess/SKILL.mdsays, withorigin/<target>as the reference branch aftergit fetch origin, because your worktree is on a new branch and you do not pull in<root>. When the verdict is notcurrent, change no file, post no comment, keep the state of the issue, and reportskipped: verdict <verdict>with the reason and The code says of the assessment.- Then decide whether the issue is worth its cost. When it is not, change no file, explain why in an issue comment, set the issue to
Backlogso that no later loop takes it again, and reportskipped: not worth it.- You already run in a worktree. Do not call EnterWorktree: name the branch as the tracker file says, and check it out as the implement skill says.
- Never ask the user. When the issue leaves a choice open, take the option that changes the least and is easiest to reverse, and record it in an issue comment. Stop only when the issue does not say what to build.
- Fix the findings in the branch as the implement skill says, and file a new issue only by step 4 of the ship skill. Where the implement skill asks the user after 3 review rounds, stop the loop of reviews and ship.
- Ship without waiting for a go. Rebase when the branch holds only your commits. Mark the pull request ready, watch its checks with one background watcher, and fix a failed check at most three times. Do not remove your worktree, and do not run step 6 of the ship skill: the orchestrator does it in
<root>.- When the environment fails (a login, a registry, a credential), stop and name the command that fixes it.
End with this report and nothing more, at most ten lines: the result (
shipped,skipped: verdict <verdict>,skipped: not worth it,stopped at merge gate,stopped before work, orstopped by guard), the reason when it did not ship, the pull request, the merge commit, the decisions you recorded, the issues you filed or added a case to, your branch, and your worktree path.
Report
The counts first: shipped, skipped, stopped. Then one line per issue with its result, pull request and merge commit; the decisions the subagents recorded; the issues they filed; and for each issue that did not ship, the reason and the repair you propose. For an issue skipped for its verdict, give the verdict and the evidence, and propose /pipe-skills:sweep <identifier>. Before the report, leave <root> as step 6 of pipe-skills:ship says in ${CLAUDE_PLUGIN_ROOT}/skills/ship/SKILL.md, for the branch of each shipped issue, and report what it could not clean.
Away
The user is about to leave, and no one answers until they return. A blocker found after they leave costs the whole absence, so find each one now, while the user can still remove it.
Before the user leaves:
- Make sure that each access the work needs works for the operation it must do, with the cheapest test that would fail the same way, because an access that only looks correct fails when no one can fix it.
- Ask every question that only the user can answer, in one message, with the options and your recommendation. Wait for the answers, unless the user said when they started this skill that they cannot answer.
- Say what you checked, what is missing, and what can still stop you.
- When nothing more is needed from the user, say so explicitly: tell them they can go.
While alone, never ask. Choose what is easiest to reverse, record each decision with its reason, and leave for the user each action they did not authorize. Keep the work resumable, so that a stall costs a resume and not the whole absence.
On return, the user must see in one look what works and how to open it, what you decided, what needs them, and what is not proved.
Final state
A document states the design that holds today. Read the whole document first, because a trace in one section often has a partner in another.
- Cut the decision history: "we first used X", "no longer", "unlike the previous version". A reader who arrives today does not know X.
- Keep the rationale, stated forward: why the design is what it is.
- Keep the plan.
The history goes in a commit message or a new comment, not in the document.
Implement an issue
The issue is the specification. The project CLAUDE.md names where it tracks work. Read the tracker file for it, ${CLAUDE_PLUGIN_ROOT}/trackers/linear.md or ${CLAUDE_PLUGIN_ROOT}/trackers/github.md, and run each operation below as that file says.
Set up
- Read the issue with its comments, and every
CLAUDE.mdthat governs the files it touches. - The target branch is the branch the user is on.
- Create the worktree with EnterWorktree and the worktree name of the tracker file as its
name. Name the branch, then rungit fetch originand check it out in the worktree:git checkout -B <branch> origin/<branch>when it is on the remote, so that the commits of an earlier run stay, elsegit checkout -B <branch> origin/<target>. Without a remote,git checkout -B <branch> <target>, or keep the local branch when it exists. Set the issue toIn Progress. - With a GitHub remote, push each commit of the run, a step or a fix, so that the reviewer, the merge, and a later run see it. After the first push, when the branch has no pull request, open a draft pull request whose title starts with the issue identifier, because GitHub refuses a pull request with no commit, and link it to the issue. Without a remote, the issue holds the record.
Work in steps
Build the simplest change that meets the success criteria, at the weight that the Business impact gives, because each guard you add is more to review, and more to maintain. Follow the decisions the issue records, and choose the rest of the method yourself.
For each step: implement it, validate it by the rule of the repository, and commit it with a message that starts with the issue identifier and says what the validation found.
When a discovery changes the plan, rewrite the issue description and the pull request description to the current proposal with the pipe-skills:final-state skill, and put the change and its reason in an issue comment.
Review
Start a fresh reviewer subagent on the most capable model you have, with the pipe-skills:review skill. Give it the issue identifier and the pull request number, or the worktree path, the branch and the target branch, and nothing more: no account of your work and no earlier findings, so that it judges the change as it is.
You decide what this branch fixes. Fix every blocker, and each in-scope finding that is worth its cost at the weight of the issue. Do not fix out-of-scope findings: keep them for the merge-gate comment. Drop a finding you disagree with, and say why in one line. Commit the fixes and start a new reviewer.
When findings come back in one area after a fix, stop adding guards there: question the method, and change it or ask the user, because each new guard brings a new finding.
The loop ends when no blocker is left and no remaining finding is worth another round. After 3 rounds, stop and ask the user, because by then the problem is in the method or in the specification.
Merge gate
Do not merge. Set the issue to In Review, and add a comment with the branch, the target branch, the final verdict, the out-of-scope findings, and the in-scope findings you did not fix with their reason. Report the verdict first, what you built, what the validation showed, and whether a reviewer read the last commit.
Follow the user instructions and interview me in detail with the AskUserQuestion tool about literally anything, but make sure the questions are not obvious. Read the code and the data first, so that each question rests on facts. Continue until the spec is complete, then state the spec back to me and stop. $ARGUMENTS
Issue as PRD
An issue is the specification for its implementation: the design and the plan live in the issue, not in a document in the repository.
The project CLAUDE.md names where it tracks work. Read the tracker file for it, ${CLAUDE_PLUGIN_ROOT}/trackers/linear.md or ${CLAUDE_PLUGIN_ROOT}/trackers/github.md, and run each operation below as that file says. If the project CLAUDE.md names no tracker, stop and offer /pipe-skills:setup.
An outcome holds issues, and the tracker file says what an outcome is. Order issues with "blocked by" relations. Link issues as children of a parent issue only when the group is itself a piece of work with its own success criteria, with the parent link of the tracker file.
Draft first
Show the draft before you file. Read the outcomes with their descriptions, put each issue in the outcome whose goal it serves, and name that outcome in the draft with a one-line reason. Propose a new outcome only for a goal that no outcome covers, with its own success criteria and more than one issue. Ask the user when two outcomes fit, when none fits, or when the work covers more than one. List each open decision with the options and your recommendation, and ask whether the scope is complete. File only after the user's go.
Outcome
Sections: Description (one line), Goal, Business impact, Success criteria, Risks. Set the target date. Its issues are its plan.
Issue
The case, written when the issue is planned: Description (one line), Goal, Business impact, Success criteria (how you prove it), Risks.
The issue says what the work must achieve and what it is worth, not how to build it. The Business impact gives the weight of the work: what it costs today, how often, and for whom, because implement sizes the change and review sizes its bar from it. The Success criteria say what done looks like. Name a method, a plan, or a list of edge cases only when the user decided it, and mark it as decided, because each prescribed guard is more for the implementer to build and for the reviewer to attack.
The design, added when the work starts: State (what exists today), Options (when there is more than one path), Plan (only the steps the user decided, in order), Context (the decisions and what else a reader needs).
Drop a section that holds nothing. File the issue in its outcome, assigned to the user, in state Todo, with its priority and its "blocked by" relations, so that pipe-skills:autonomous-loop takes the issues in the correct order. Give the identifier and the URL, and offer to run pipe-skills:implement.
Update
When the plan changes, rewrite the description to the current proposal only, with pipe-skills:final-state, and add a comment with the change and its reason. When the issue serves another outcome, move it there after the user's go, and say why in the same comment.
Close
/pipe-skills:ship closes the issue after the merge. To close it by hand, first ask the user: "do you think we are ready to close this issue?"
Write each paragraph or bullet as one line, with real newlines, not \n escapes.
Promote rule
Propose a rule only for a principle that outlives the current work. A decision for one piece of work goes in its issue or its code, not in a rule file.
Choose the level by scope:
- Every project:
~/.claude/CLAUDE.md. - One repository: the
CLAUDE.mdat its root. - One repeated workflow: the skill that runs it.
Read the target file first. When a rule there already covers the principle, sharpen or replace it instead of adding one.
Propose at most one rule per turn, in one message: the exact line, the file, and why that level fits. For example: "I suggest that we promote this as a rule: . It goes in the repository CLAUDE.md, because it holds only for this repository. What do you think?"
Write only after a yes, in the user's words when they change yours. After a no, do not propose it again in this session. An explicit request to record a rule is the yes.
Write the rule in at most two lines, in the present tense, with its reason, next to the rules it belongs with.
Review
Answer one question: is the change ready to merge? Change no file.
- Read the diff:
gh pr diff <n>with a pull request,git diff <target>...<branch>without one. Read the linked issue, which is the specification, with the tracker file that the projectCLAUDE.mdnames,${CLAUDE_PLUGIN_ROOT}/trackers/linear.mdor${CLAUDE_PLUGIN_ROOT}/trackers/github.md. Read everyCLAUDE.mdon the path of a changed file. Judge from these three only, not from an account of the work or from an earlier review, so that each review judges the change as it is. - Review at the weight that the Business impact of the issue gives: a small issue gets a short review. Raise only what a careful senior reviewer would raise, a finding the user would act on, because minor findings cost a round each and hide the important ones.
- Prove each finding with a concrete failure: the input, the state, and the wrong result. Drop a finding you cannot make concrete, a failure that is unlikely in real use, and a failure that is safe: it stops, refuses, or reports, and loses nothing.
- Class each finding by its relation to the issue. You do not decide when it gets fixed.
- Blocker. The change is wrong, does not do what the issue asks, or breaks a
CLAUDE.mdrule. - In scope. A real bug or a clear improvement with the same root cause as the issue, or in the code this change touches.
- Out of scope. A real problem with a different root cause, such as a problem that was already in the target branch. It never blocks the merge.
- Blocker. The change is wrong, does not do what the issue asks, or breaks a
Report the verdict first, ready or not ready, with one sentence of reason. Then the blockers, each with file, line and failure, and the in-scope and out-of-scope findings, one line each. List failures only, not the checks that passed.
Set up a project
Make the project ready for pipe-skills:prd, pipe-skills:implement, pipe-skills:ship and pipe-skills:autonomous-loop, and change nothing else. Running it again on a ready project changes nothing.
- Read the
CLAUDE.mdat the root of the repository. When it names a tracker, show the tracker line and ask the user to keep it or to change the scope; on keep, take that tracker, team, and project or initiative. On change, or when it names no tracker, ask the user: Linear or GitHub Issues, and which team and project, or team and initiative, or which GitHub project and owner. Offer the projects or initiatives that exist, and a new one as the last option. On change, the map line that exists does not apply to the new scope. - Read the tracker file,
${CLAUDE_PLUGIN_ROOT}/trackers/linear.mdor${CLAUDE_PLUGIN_ROOT}/trackers/github.md, and its setup file,${CLAUDE_SKILL_DIR}/linear.mdor${CLAUDE_SKILL_DIR}/github.md. Check each item of the Requirements of the setup file, read-only. - Report one line per requirement: ready, or missing with the fix. Name what the user must do by hand, and what you can do.
- After the user's go, run the fixes of the Setup section of the setup file. When a state has no option of its own, or the scope changed, the Setup maps every state again as if no map line exists; on keep, the entry of the old map line is the default answer, unless another state already takes that option. Then check the requirements again.
- Write the tracker line in the project
CLAUDE.mdin place of the tracker line that exists, if any. On change, or when the Setup mapped the states again, write the map line that the Setup made in place of the map line that exists, or remove the old line when it made none. Write them in the form that the tracker file shows, next to the rules they belong with, and with the user's names. Do not commit them: say that they are ready to commit.
End with the state of each requirement and the first command to run, for example /pipe-skills:prd.
Ship an issue
The project CLAUDE.md names where it tracks work. Read the tracker file for it, ${CLAUDE_PLUGIN_ROOT}/trackers/linear.md or ${CLAUDE_PLUGIN_ROOT}/trackers/github.md, and run each operation below as that file says. Read the branch and the target branch from the user's argument, else from the merge-gate comment on the issue, else from gh pr view.
Read the final verdict in the merge-gate comment. When it is not ready, or no merge-gate comment exists, say so in the plan and do not merge without a go from the user.
Run the merge, the cleanup and the checkout from the main checkout, not from the worktree, because git refuses a branch that another worktree holds.
Report the state and the plan first. Wait for a go before a step that can lose work: an unpushed commit, an uncommitted change, or a rebase. Then run the steps that still apply:
- Rebase the branch onto the target branch, if it is behind.
- Squash merge: mark a draft pull request ready with
gh pr ready <n>, thengh pr merge <n> --squash --subject "<identifier>: <issue title> (#<n>)". Without a pull request,git merge --squash <branch>and a commit titled<identifier>: <issue title>whose body keeps the step messages. - Close the issue, and add a comment with the merge commit and the findings that the merge-gate comment lists.
- File a follow-up issue only for an out-of-scope finding that is a reproduced bug, a broken
CLAUDE.mdrule, or a feature of high value. Before you file, add the case to an open issue with the same cause, if there is one. File nothing when the closed issue is itself a follow-up. Start each new issue withDeferred from the review of <identifier>.and link it to the closed issue. - Leave the worktree with ExitWorktree when the session is in it, remove it, and run
git worktree prune. - Leave the local repository equal to the remote: the target branch at
origin/<target>, and no local branch, remote branch, or stale remote-tracking ref of the shipped branch. Never lose the merge or a commit that it does not hold, and never touch an uncommitted change of the user. Without a remote, delete the local branch and check out the target branch.
Report the merge commit, the closed issue, the issues you filed or added a case to, and what step 6 could not clean, with the reason. Never use --no-verify, and never force-push a shared branch.
Sweep the backlog
You are the orchestrator. You do not judge an issue yourself. The project CLAUDE.md names where it tracks work. Read the tracker file for it, ${CLAUDE_PLUGIN_ROOT}/trackers/linear.md or ${CLAUDE_PLUGIN_ROOT}/trackers/github.md, and run each operation below as that file says.
Post no comment and change nothing in the tracker before the user approves the rows. This holds also when the user names one issue.
Scope
- The issues the user names, in
BacklogorTodo; name each other one and say that it is out of scope. Else every issue of List the backlog, in the scope of the tracker line. - The reference branch
<ref>is the branch you stand on. Pull it once, here, withgit pull --ff-only, so that the subagents do not pull at the same time. When the pull fails, say so, and check the branch as it is. - Skip an issue that did not change since its last review: its last comment is the review comment of
pipe-skills:assess, that comment names<ref>as its branch, compared without theorigin/prefix,git merge-base --is-ancestor <sha> <ref>succeeds, the comment holds the hash that Hash the description gives now, andgit log <sha>..<ref> -- <paths>, with the SHA and the paths of that comment, finds no commit. A review on another branch says nothing about<ref>. The hash catches an edit of the description, and the last comment catches a word of the user, which the edit date cannot tell apart from the review comment. Never skip an issue that the user names. - State the scope in one line: the number of issues to assess, and the skipped issues with the date of their last review.
Assess
Start one fresh subagent for each issue with the Agent tool, at most eight at a time, with the model of this session and the prompt below. Do not fork, so that each subagent starts clean. It only reads, so it needs no worktree. When one ends without its report, ask it for the report with SendMessage.
Assess the issue
<identifier>of<root>. Read${CLAUDE_PLUGIN_ROOT}/skills/assess/SKILL.mdand the tracker file<tracker file>, and follow them. The reference branch is<ref>, already pulled: do not pull. Change no file and nothing in the tracker. End with this report and nothing more: the verdict and one line of reason; The code says, at most five bullets, each with its proof; Your call, one question ornone; Proposed change, with the full new text of each section that changes fordrifted; the checked commit SHA; the checked paths.
Report
Report the verdicts in the conversation, in the form that suits the case: one numbered row for each issue (identifier, title, verdict, reason, proposed change) when the issues are many, and the full report of each issue when they are few. Put first the rows with a question for the user. Then ask which rows to apply, and wait. The user can approve a row, reject it, or change its verdict.
Apply
For each approved row only, run Apply a verdict of pipe-skills:assess, which ends with the review comment that the skip rule reads. A rejected row gets nothing. Report each row that you applied, with its link, and each row that failed with its reason.
Hooks 1
Sponsors
Details
- Marketplace
- felipeam86/pipe-skills
- Category
- Community