Goal Workflow skill
goal-workflow
19 skills for Claude Code: PRD, spec, GitHub Issues, batch implementation with review and pull request merging, plus refactoring and diagrams
- 293 ★ on the repository
- Last commit
- MIT
Broad access
Why this level
- `/ship-it` commits, pushes a branch, creates a pull request, merges it and closes the issue on GitHub under your `gh` token
- `/loop-it` implements and merges several issues in a row without stopping for manual review
- Some skills reach out: text-to-speech sends text to api.marswave.ai with a key, and icons load from itshover.com
Install
- Works in
Manual install
npx skills add smallnest/goal-workflowInstalls every skill in the set. The repository also carries the .claude-plugin/plugin.json and marketplace.json manifests.
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- `/ship-it` commits, pushes a branch, creates a pull request, merges it and closes the issue on GitHub under your `gh` token
- `/loop-it` implements and merges several issues in a row without stopping for manual review
- Some skills reach out: text-to-speech sends text to api.marswave.ai with a key, and icons load from itshover.com
This is third-party code. Review the repository files before installing.
What it does
Goal Workflow is a Claude Code plugin that links 19 skills into a chain from requirements to a merged pull request: `/prd`, then optional `/prd-to-spec`, `/to-issues`, the `/loop-it` loop and inside it `/review-it` and `/ship-it`. `/prd` asks clarifying questions, a number scaled to the task's complexity, produces a document for review and saves it to `tasks/prd-feature-name.md`. `/to-issues` slices a PRD or spec into vertical slices that can each be demonstrated on their own and creates tasks on GitHub or locally. `/loop-it` takes the open GitHub issues, sorts them by dependency, implements each in the main context, runs it through `/review-it` and hands it to `/ship-it`. State lives in `.loop-state.json`, so after a crash the loop resumes from the checkpoint. `/review-it` calls the agent's built-in review (`/review` in Claude Code, `codex review` in Codex), checks each finding against the code and repeats until no justified findings remain. `/ship-it` commits the files of the current issue, pushes the branch, creates a PR with `gh`, merges it and closes the issue with a comment. Outside the main chain sit `/graph` with parallel nodes in separate git worktrees, `/note-it` for implementation notes, `/walkthrough`, `/understand`, `/refactor`, `/smell`, `/modern-go`, `/insight-diagram` and several helper skills.
Who it is for. For developers who want to take Claude Code the whole way from a feature description to a merged pull request in a GitHub repository and are ready to let the agent work through a batch of issues in a row.
Good fit when
- A feature is large and must be broken into a PRD, tasks and an execution order instead of one request
- The repository has accumulated open GitHub issues and the agent should implement them in turn, honoring dependencies
- You need a loop that survives a session crash and resumes from a checkpoint
- The tasks are independent and suit parallel execution as graph nodes in separate worktrees
- Fresh agent changes need to be reviewed as a web page with a file tree and an explanation for each fragment
- A Go project needs modern-syntax rules and a code smell catalog
Not a fit when
- The repository is not on GitHub or `gh` is not authenticated: `/loop-it` and `/ship-it` work through `gh` and stop at the first check
- A person must do the merge after their own review: `/ship-it` creates the PR, merges it and closes the issue on its own
- The change is small or fits in one context window: `/to-issues` itself advises using a single `/goal` in that case
- You need an English-only set without Chinese passages: some skills, for example `/loop-it`, are written in Chinese
Example request
/prd export orders to CSV with a date filter, and once I confirm the document, break it into tasks with /to-issuesLimitations
- The chain is built around GitHub and `gh`: authentication is checked before the loop, and merging runs into branch protection and required reviews, which `/ship-it` does not bypass.
- In `/loop-it` implementation happens inside the agent itself: the skill states plainly that no callable `/goal` command exists in that environment.
- It is better to add `.loop-state.json` to `.gitignore`: if Git tracks it, the skill only warns about it.
- `/listenhub-tts` needs the `LISTENHUB_API_KEY` variable, and requests go to api.marswave.ai. `/article-icons` loads icons from itshover.com.
- The texts of many skills are mixed: English descriptions with Chinese instructions and triggers. The README is in English and Chinese.
- Plugin version 1.0.0, MIT license.
How to disable. Run `npx skills remove smallnest/goal-workflow` or delete the folders of the skills you need from ~/.claude/skills or the project's .claude/skills. The .loop-state.json file and the documents in tasks/ and docs/ stay in the repository, so delete them yourself. PRs the skill already created, merged branches and closed issues stay on GitHub.
FAQ
What does /loop-it do after a failure on an issue?
The skill classifies the error and applies a recovery step with a capped number of attempts, for example a rebase on origin/main for a merge conflict. When attempts run out, it marks the issue in `.loop-state.json` and moves on, and on restart it reads the file and skips what is done. There are at most two review rounds per issue.
Where do the skills put documents?
`/prd` writes to `tasks/prd-feature-name.md`, `/note-it` keeps per-issue notes in `docs/issue#XXXX.html`, and `/walkthrough` assembles `walkthrough.md` with a change summary, verification steps and proof. All files stay in your repository.
How does `/to-issues` slice the work?
By the tracer bullet principle: each issue takes a thin path through all layers at once and can be demonstrated on its own. The skill treats horizontal issues such as "only a database table" as a slicing mistake. Each issue is written so that a fresh session without the PRD can finish it.
Which agents does `/review-it` support?
The skill table lists Claude Code with `/review`, Codex with `codex review`, OpenCode with `/review`, DeepSeek TUI and Antigravity CLI with `/code-review`. Review output is treated as advice: the skill checks each finding against the code, rejects far-fetched ones and repeats until no accepted findings remain.
What does `/understand` show?
The `understand.py` script builds a two-column page: the tree of changed files on the left and the selected highlighted diff on the right. A side panel shows the related requirement and an explanation for each fragment, with pseudocode and a call tree below on request.
Discussion
No questions or reviews yet.
Related
SkillsA plugin with three skills for large development work: project analysis, phased tasks tracked as GitHub Issues, parallel agents and code review
A Claude Code plugin: 39 commands for PRs, review, commits and specs, nine expert roles and hooks, in eight language versions
HumanLayer Skills
HumanLayer skills
Seven HumanLayer skills for Claude Code and Codex: the rpi research, design and implementation loop, visual PRs, CLAUDE.md rewrites and agentic loops
A dev process built from composable skills for Claude Code and Codex: plan, implement, review, test, commit and PR
A Claude Code plugin: Claude does the task, then a stop hook starts an independent Codex review and Claude fixes the findings in the same session
A Claude Code plugin marketplace by Frad LEE: Git and GitFlow, GitHub, refactoring, memory, research, image generation and interface work
Comparison with similar tools
Entries that share the main search query, and how they differ.
| Entry | Official | Repository stars | Main difference |
|---|---|---|---|
| Goal Workflow (this entry) | no | 293 | |
| CCPM | no | 8,415 | PRD, epics and tasks synced to GitHub Issues with parallel agents in git worktrees, without a merge loop |
| prd-taskmaster | no | 606 | a plugin that scores a PRD with deterministic checks, builds a task graph and confirms the result with a token |
| Continuous Claude | no | 3,947 | a shell loop for Claude Code with iteration, pull request and merge, without PRD and task stages |
README in short
The description is short: a diagram of the chain from `/prd` to `/ship-it` with an infographic, one-command install, a table of commands with one-line explanations and a link to the full guide in docs/index.html in English and Chinese. Behavior details live in the SKILL.md files themselves, and the repository also holds the plugin and marketplace manifests, diagram scripts and HTML templates.
README badge
Original SKILL.md
---
name: loop-it
description: "Automated issue loop with checkpoint/resume: fetch open GitHub issues → dependency-aware topological sort → implement each issue end-to-end → review with /review-it → ship with /ship-it → repeat. Persists state to .loop-state.json for crash recovery. Triggers on: loop-it, loop issues, auto implement, 批量实现, 循环实现, 实现所有issue, 恢复循环, resume loop."
user-invocable: true
allowed-tools:
- Bash(gh:*)
- Bash(git:*)
- Bash(cat:*)
---
# loop-it — 带检查点恢复的自动化 Issue 实现循环
Fetch all open GitHub issues, resolve dependency order, implement each through the full pipeline (内联实现 → `/review-it` → `/ship-it`), persist progress to state file, and resume from checkpoint on crash.
> **⚠️ 关键前提：实现步骤由 agent 内联自主完成，不依赖任何外部 `/goal` 命令。**
> 本环境中不存在可调用的 `goal` 命令或 skill。因此「实现 issue」这一步**必须由 agent 内联完成**：直接读取该 issue 的标题与正文（含其引用的 PRD/SPEC 与验收条件），自主完成"理解需求 → 写/改代码 → 跑测试与 lint → 满足全部验收条件"的闭环，持续工作直到该 issue 的验收条件全部满足且测试/构建通过。**不要**尝试用 Skill 工具调用 `goal`（会报 `goal is a UI command, not a skill`），也**不要**因为找不到 `/goal` 而中止循环。`/review-it`、`/ship-it` 仍是真实 skill，经 Skill 工具调用。**loop-it 循环中不调用 `/note-it`。**
---
## Overview
```
前置检查 → 读取状态文件 → Fetch Issues → 构建依赖图 → 拓扑排序
|
┌───────────────────────────────────────────────────────────┘
|
v
┌──────────────── 单 Issue 循环 ────────────────┐
| |
| 从检查点恢复？—— 跳过已完成/失败的 |
| |
| 分支准备 (checkout main, pull, create branch) |
| | |
| Skip/Blocked? ── 是 → 标记 skipped/blocked, 写检查点 |
| | |
| 否 |
| | |
| 内联实现 → 出错？→ 分类 → 恢复 → 重试 |
| | | |
| | 失败 → 检查点, 下一个 |
| | |
| /review-it → 有问题？→ 修复 → 重跑 review |
| | |
| /ship-it → 出错？→ 分类 → 恢复 |
| | |