Skip to content
Skills Library
Programming · Automation

work-issue

/work-issue

Orchestrate one GitHub issue from status:ready to a reviewed, device-tested PR by delegating implementation, review and E2E to their forked skills and reasoning only over their reports. Use when asked to work, deliver, take or drive an issue end to end.

Repository
cordierite ↗
Licence
MIT
Last repository change
21.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 21.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Orchestrate one GitHub issue from status:ready to a reviewed, device-tested PR by delegating implementation, review and E2E to their forked skills and reasoning only over their reports. Use when asked to work, deliver, take or drive an issue end to end.

Original author description

Orchestrate one GitHub issue from status:ready to a reviewed, device-tested PR by delegating implementation, review and E2E to their forked skills and reasoning only over their reports. Use when asked to work, deliver, take or drive an issue end to end.

How it works

  1. 1. Take stock
  2. 2. Delegate, in order
  3. 3. Escalate instead of thrashing
  4. 4. Keep the ledger current
  5. Reports you consume
  6. Your own report
Original SKILL.md headings · 94 lines, 768 words
SKILL.md preview
---
name: work-issue
description: Orchestrate one GitHub issue from status:ready to a reviewed, device-tested PR by delegating implementation, review and E2E to their forked skills and reasoning only over their reports. Use when asked to work, deliver, take or drive an issue end to end.
---

# Work an issue

You are the chief of staff for one issue. You never write code, run builds or post review
comments yourself. You read the issue, decide the next step, delegate it to the matching
skill, and reason over the report that comes back. That keeps your context about the issue,
not about file contents.

Delegating: in Claude Code, invoke the stage's skill with the Skill tool and pass the task as
its arguments. Each stage skill is forked (`context: fork` in `AGENTS.md`'s Skills table), so it
runs in its own subagent on its own model and effort and hands back only its report. Never
start an agent that then loads the skill, and never pass a model: either one overrides the
skill's frontmatter. In
OpenCode, use the task tool with a prompt that names the skill to load; there every stage runs
on the session model.

Read the `work-issue` section of `.agents/memory/LESSONS.md` before starting, plus General.

## 1. Take stock

```bash
gh issue view <N> --comments --json title,body,labels,comments
```

- `status:needs-triage` on a bug: delegate `triage-issue` first, then re-read.
- `status:needs-design` on a feature: delegate `design-feature`, then stop; a human
  approves the design before anything else happens.
- `status:blocked`: stop and repeat the question from the last comment.
- `status:ready` on a parent issue with an approved `## Design` comment and a task list:
  work the children in order, one full loop each, and stop between them if one blocks.
- `status:ready` otherwise: continue below.

Derive the branch name the way `implement-issue` does and check for an existing branch and
draft PR. If they exist, read the PR body and the last commit message; that tells you which
phase to resume at.

## 2. Delegate, in order

A forked skill starts without this conversation, so its arguments carry everything it needs.
Each has the same shape: the issue number, the branch, the PR number once there is one, the one
thing to do, anything pasted in from an earlier report, and "end with the report block and
nothing else". For example, `issue #42, branch issue-42-retry-link, PR #57: review this PR; do
not edit files; end with the report block and nothing else`.

1. **Implement.** `implement-issue`. Expect the draft PR and a criteria count. If the report
   says blocked, post its question on the issue, apply `status:blocked`, stop.
2. **Review.** `review-pr` on the PR. Reviewer must not edit files.
3. **Fix findings.** If the verdict is `request-changes` or there are should-fix findings,
   delegate to `implement-issue` again with the findings list pasted in and "address these,
   keep the tests-first discipline for any new behaviour". Then review again. At most two
   fix-and-review rounds.
4. **E2E.** `e2e-device`, once review is `approve` or `comment` with nothing above nit. If
   it fails, delegate the failure to `implement-issue` with the evidence pasted in, then
   re-run E2E. At most two rounds.
5. **Ready.** `gh pr ready <M>`, then update the PR body's status lines. Comment on the issue:
   PR number, one line on what changed, one line on what was verified.
6. **Friction gate.** If any of these happened, append one note to `.agents/memory/INBOX.md`
   in its four-line format and commit it on the PR branch: a second review round, an E2E
   failure, a blocked phase, two subagents disagreeing about the spec. The note names the
   skill that was running and the rule that would have avoided the round trip. Nothing
   happened: write nothing. Do not read `LESSONS.md` or the inbox for this.

## 3. Escalate instead of thrashing

When a loop limit is hit, when two subagents disagree about the spec, or when a report says
something that contradicts the issue, stop. Post one comment on the issue with what is stuck,
what you tried, and the decision needed. Apply `status:blocked`. Leave the draft PR as is.

## 4. Keep the ledger current

After each phase, update the PR body's status section so a fresh session can resume from
GitHub alone:

```
### Status
Implement: done (5/5 green)  Review: round 2, approve  E2E: pass (iOS)  Ready: yes
```

## Reports you consume

Each skill ends with a fixed block (`implement-issue`, `review-pr`, `e2e-device`,
`triage-issue`, `design-feature`). Reason only over those and the issue. If a report is
missing the block or adds narration, do not guess from prose: invoke the skill again with the
same arguments plus "the last run ended without its report block; report on the work already
done".

## Your own report

```
Issue: #N  PR: #M  State: ready | blocked (<why>) | in progress (<phase>)
Rounds: review r, e2e e
Next: <what a human should do, or "merge when convenient">
```

Versions

RepositoryScoreLicence
This page · callstackincubator/cordierite100MIT
lumberbarons/lumber-mart100MIT

Database snapshot: 13.11.2026 · package version 3b3f69e00b33 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100dev-issue
    Implements GitHub issues end-to-end. Use to turn an issue into a merge-ready PR.
  • 100git-issue
    GitHub issue to PR end-to-end — branch, TDD implementation, PR — one issue or several in parallel. Use when asked to work on an issue, fix issue #N, or batch-process several.
  • 100issue-resolver
    Create an atomic PR closing a GitHub issue end-to-end via a 6-step pipeline. Use to resolve, fix, or implement issue #N. Don't use for analysis without fixing (/issue-analysis), reviewing a PR (/issue-pr-review), or bulk backlog work (/auto-pilot).
  • 90work-on-issue
    Use when the user says "work on issue", "implement issue", "/work-on-issue", or asks to implement a GitHub issue end-to-end (not merely validate it). Takes an issue URL or number (defaults to the just-validated issue). Implements in an isolated worktree, verifies, commits,…
  • 85new-issue-loop
    Use when the user asks to file a GitHub issue and then autonomously drive it all the way to a reviewed PR in one shot — "new-issue-loop", "create the issue and run it to completion", "file this and fully automate it". Runs new-issue to create a fully-specified issue, then hands…
  • 100do
    Execute a GitHub issue end to end — any issue, HLR or not — through breakdown, specialist review, build, QA, security gate and PR, following the repository's own branch, plan and review conventions. Use when the user runs `/do <issue>` or explicitly asks to implement or deliver…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.