Skip to content
Back to search

superpowers-openspec-team-skills

一套带有记忆和自学习的harness-team-skills企业级编程技能组合库 针对superpowers+openspec 进行按需组合使用,适用于个人与团队协作进行AI编程

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/syz-coder--superpowers-openspec-team-skills/badge.svg)](/listings/syz-coder--superpowers-openspec-team-skills)

HTML

<a href="/listings/syz-coder--superpowers-openspec-team-skills"><img src="/api/listings/syz-coder--superpowers-openspec-team-skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

1. Pick the right install target

- Codex: install a bundle into `.codex/skills/` - OpenCode: install a bundle into `.opencode/skills/` or your OpenCode config skill directory - Cursor: install repository rules and `AGENTS.md` into the target project - Claude Code: install command files and `CLAUDE.md` into the target project

2. Install a bundle

Match the installed bundle to the workflow you plan to activate. Do not install `openspec-superpowers` and then try to trigger `superpowers-openspec-superpowers`, or the runtime rules may not match the prompt.

If you want the recommended workflow, install `superpowers-openspec-superpowers`.

Windows PowerShell examples:

.\scripts\install-codex.ps1 -Bundle superpowers-openspec-superpowers
.\scripts\install-opencode.ps1 -Bundle superpowers-openspec-superpowers
.\scripts\install-cursor.ps1 -Bundle superpowers-openspec-superpowers -ProjectRoot <project-root>
.\scripts\install-claude-code.ps1 -Bundle superpowers-openspec-superpowers -ProjectRoot <project-root>

macOS or Linux examples:

sh "./scripts/install-codex.sh" --bundle superpowers-openspec-superpowers --codex-home "$HOME/.codex"
sh "./scripts/install-opencode.sh" --bundle superpowers-openspec-superpowers --opencode-home "$HOME/.config/opencode"
sh "./scripts/install-cursor.sh" --bundle superpowers-openspec-superpowers --project-root <project-root>
sh "./scripts/install-claude-code.sh" --bundle superpowers-openspec-superpowers --project-root <project-root>

If the target project already has a `CLAUDE.md` and you want to merge the bundle instructions into it instead of replacing it, use:

.\scripts\install-claude-code.ps1 -Bundle superpowers-openspec-superpowers -ProjectRoot <project-root> -MergeClaudeMd
sh "./scripts/install-claude-code.sh" --bundle superpowers-openspec-superpowers --project-root <project-root> --merge-claude-md

If you want the OpenSpec -> Superpowers workflow, install `openspec-superpowers`.

Windows PowerShell examples:

.\scripts\install-codex.ps1 -Bundle openspec-superpowers
.\scripts\install-opencode.ps1 -Bundle openspec-superpowers
.\scripts\install-cursor.ps1 -Bundle openspec-superpowers -ProjectRoot <project-root>
.\scripts\install-claude-code.ps1 -Bundle openspec-superpowers -ProjectRoot <project-root>

macOS or Linux examples:

sh "./scripts/install-codex.sh" --bundle openspec-superpowers --codex-home "$HOME/.codex"
sh "./scripts/install-opencode.sh" --bundle openspec-superpowers --opencode-home "$HOME/.config/opencode"
sh "./scripts/install-cursor.sh" --bundle openspec-superpowers --project-root <project-root>
sh "./scripts/install-claude-code.sh" --bundle openspec-superpowers --project-root <project-root>

If the target project already has a `CLAUDE.md` and you want to merge the bundle instructions into it instead of replacing it, use:

.\scripts\install-claude-code.ps1 -Bundle openspec-superpowers -ProjectRoot <project-root> -MergeClaudeMd
sh "./scripts/install-claude-code.sh" --bundle openspec-superpowers --project-root <project-root> --merge-claude-md

3. Activate the workflow explicitly

Activate the same workflow family that you installed above.

- Codex:

Use $superpowers-openspec-superpowers-workflow for this feature.

- OpenCode:

Use the superpowers-openspec-superpowers-workflow skill for this feature.

- Cursor:

Use the superpowers-openspec-superpowers workflow for this feature.

- Claude Code:

/superpowers-openspec-superpowers-workflow
<describe the feature request>

For Cursor, `superpowers-openspec-superpowers` is routed by repository rules after installation. It is not a native slash command, so the project must already contain the matching `AGENTS.md` and `.cursor/rules` files from the `superpowers-openspec-superpowers` bundle.

4. Use memory when you need cross-session continuity

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 485 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Superpowers + OpenSpec Team Skills
  2. Structured workflow packs for AI coding assistants, with built-in conversation memory, project memory, and learning-oriented collaboration patterns.
  3. This repository helps teams stop agents from jumping straight into code. It provides reusable workflows for clarification, spec writing, implementation, verification, archive, and optional repo-persisted memory, so AI coding support can become a durable collaboration capability instead of a one-off chat response.
  4. Important: these workflows are explicit opt-in. They should run only when the user names the workflow or when repository policy requires it.
  5. Chinese readers: [Chinese README](README.cn.md)
  6. ## Start Here
  7. Use this README in three layers:
  8. 1. Decide whether you need this repository at all.
  9. 2. Choose one workflow family and one target tool.
  10. 3. Follow the matching install and activation path.
  11. If you only need the fastest orientation, read these sections first:
  12. - [What This Repository Is](#what-this-repository-is)
  13. - [Workflow Packs](#workflow-packs)
  14. - [How To Choose](#how-to-choose)
  15. - [Quick Start](#quick-start)
  16. - [Task Confirmation and Continuations](#task-confirmation-and-continuations)
  17. - [Installing Multiple Bundles](#installing-multiple-bundles)
  18. ## At A Glance
  19. | Need | Use |
  20. | --- | --- |
  21. | Superpowers -> OpenSpec -> Superpowers workflow | `superpowers-openspec-superpowers` |
  22. | OpenSpec -> Superpowers workflow | `openspec-superpowers` |
  23. | Superpowers-only implementation discipline | `superpowers-feature` |
  24. | OpenSpec artifacts only | `openspec-feature` |
  25. | After delivery, preserve lessons, update project memory, and help the next session resume cleanly | `superpowers-learning` |
  26. ## Choose By Tool
  27. | Tool | Install shape | Best activation pattern | Main caveat |
  28. | --- | --- | --- | --- |
  29. | Codex | `.codex/skills/` | Explicit skill name such as `$superpowers-openspec-superpowers-workflow` | Multiple bundles are usually safe |
  30. | OpenCode | `.opencode/skills/` or `~/.config/opencode/skills/` | Explicit skill request such as `Use the superpowers-openspec-superpowers-workflow skill` | Refresh OpenCode if newly installed skills do not appear immediately |
  31. | Cursor | `AGENTS.md` + `.cursor/rules/` in the target repo | Explicit text request in chat | Mixed bundles can create routing ambiguity |
  32. | Claude Code | `CLAUDE.md` + `.claude/commands/` in the target repo | Explicit slash command | `CLAUDE.md` follows the most recent install |
  33. ## Choose By Outcome
  34. If your goal is primarily:
  35. - shipping a feature with one workflow: go to [Workflow Packs](#workflow-packs)
  36. - exploring before locking requirements: go to [Workflow Packs](#workflow-packs)
  37. - preserving session outcomes after delivery so the next session can resume with the right context: go to [Use memory when you need cross-session continuity](#4-use-memory-when-you-need-cross-session-continuity) and `superpowers-learning`
  38. - understanding installation differences by tool: go to [Tool-Specific Behavior](#tool-specific-behavior)
  39. - avoiding wrong bundle and workflow combinations: go to [Installing Multiple Bundles](#installing-multiple-bundles)
  40. ## Common Mistakes First
  41. Before installing or testing a workflow, keep these rules in mind:
  42. - Do not treat these workflows as always-on defaults. They are explicit opt-in.
  43. - Install the bundle that matches the workflow you plan to trigger.
  44. - In Cursor, repository rules are part of the runtime. Reopen the project after installing or replacing a bundle.
  45. - In the two combined workflows, `tasks.md` confirmation is not the same thing as OpenSpec apply. The workflow should pause, wait for confirmation, then continue with the defined handoff.
  46. ## What This Repository Is
  47. This is not just a prompt collection. It is a workflow skill system for AI coding assistants.
  48. Its value is in turning AI coding from a temporary conversation into a repeatable, traceable, and reusable way of working:
  49. - workflow: guide the assistant to understand first, then implement, instead of editing code immediately
  50. - memory: carry project background, current state, key decisions, and known issues across sessions
  51. - learning: capture lessons after meaningful work so useful patterns can be reused later
  52. - collaboration boundaries: give both individual developers and project teams a more stable way to work with AI
  53. If you want AI to do more than generate a few code snippets, and instead participate in clarification, specification, implementation, verification, archive, and knowledge capture, this repository is designed for that style of engineering collaboration.
  54. This project has two layers:
  55. - `team-skills/`: source workflow definitions maintained by the project
  56. - `dist/`: installable bundles adapted for Codex, OpenCode, Cursor, and Claude Code
  57. If you are using the project, start with `dist/` and `scripts/`.
  58. Do not copy a single entry workflow out of `team-skills/` unless you are intentionally extending the source definitions.
  59. ## Who This Is For
  60. This repository works for both individual developers and project teams:
  61. - individual developers who want AI to remember project context instead of re-explaining everything every session
  62. - small teams that want shared workflow discipline, consistent terminology, and clearer delivery boundaries with AI
  63. - evolving codebases that need AI to inherit prior decisions and stage status across longer-running work
  64. Use this repository if you want your AI coding tool to:
  65. - clarify before implementation
  66. - lock behavior before risky changes
  67. - implement with tests and verification
  68. - finish with a clean archive or closeout step
  69. - preserve durable project context across sessions
  70. - build up longer-term memory and reusable lessons over time
  71. ## Common Scenarios
  72. - solo project work where you want AI to remember the project background, current phase, and latest progress
  73. - feature delivery where you want AI to sort out requirements and specs before coding
  74. - maintenance in older or more complex repositories where AI should understand first and modify second
  75. - team collaboration where different people should get more consistent workflow behavior and output structure from AI
  76. - knowledge capture where decisions, lessons learned, and stable patterns should remain available for future sessions
  77. ## Workflow Packs
  78. Five workflow families are included:
  79. - `superpowers-openspec-superpowers`: start wide with Superpowers, lock the agreed truth with OpenSpec, then come back to Superpowers to build, verify, and archive with confidence
  80. - `openspec-superpowers`: start with OpenSpec artifacts, then continue with Superpowers for implementation, verification, and archive
  81. - `superpowers-feature`: Superpowers-only design, planning, TDD, and verification
  82. - `superpowers-learning`: not a primary delivery workflow, but a post-delivery enhancement layer used after other workflows to update project memory, preserve durable lessons, and help the next session pick up from the right state
  83. - `openspec-feature`: create OpenSpec proposal, design, specs, and tasks before implementation
  84. Source workflow docs:
  85. - [OpenSpec + Superpowers Workflow](team-skills/openspec-superpowers-workflow/README.md)
  86. - [Superpowers -> OpenSpec -> Superpowers Workflow](team-skills/superpowers-openspec-superpowers-workflow/README.md)
  87. - [Superpowers Feature Workflow](team-skills/superpowers-feature-workflow/README.md)
  88. - [Superpowers Learning Workflow](team-skills/superpowers-learning-workflow/README.md)
  89. - [OpenSpec Feature Workflow](team-skills/openspec-feature-workflow/README.md)
  90. Each source workflow also includes a machine-readable `workflow.yaml`.
  91. ## How To Choose
  92. - Choose `superpowers-openspec-superpowers` when you want Superpowers exploration first, OpenSpec locking second, and Superpowers execution last.
  93. - Choose `openspec-superpowers` when you want OpenSpec artifacts first, then Superpowers delivery steps.
  94. - Choose `superpowers-feature` when you want disciplined engineering without OpenSpec change artifacts.
  95. - Choose `superpowers-learning` when delivery is already done and you want to write back the durable outcomes of this session so the next session can resume with the right context.
  96. - Choose `openspec-feature` when you only want change artifacts before implementation begins.
  97. `superpowers-learning` needs a different mental model from the delivery workflows above. It is best treated as an enhancement layer that follows `superpowers-feature`, `superpowers-openspec-superpowers`, or `openspec-superpowers` after meaningful work is finished. Its job is to review what happened in the session, separate stable project facts from temporary task noise, update `.superpowers-memory/`, and capture reusable lessons that may later become skills, checklists, or knowledge-base material.
  98. Recommended long-running pattern:
  99. 1. Run one delivery workflow.
  100. 2. Finish implementation and verification.
  101. 3. Run `superpowers-learning` to write stable facts, current state, session notes, and reusable lessons back into project memory.
  102. ## Explicit Activation
  103. These workflows should activate only when:
  104. - the user explicitly names the workflow
  105. - the user explicitly asks for this workflow style
  106. - repository policy explicitly requires it
  107. They should not become the default background behavior of your AI tool.
  108. Example:
  109. ```text
  110. Use $superpowers-openspec-superpowers-workflow for this feature.
  111. ```
  112. ## Quick Start
  113. ### 1. Pick the right install target
  114. - Codex: install a bundle into `.codex/skills/`
  115. - OpenCode: install a bundle into `.opencode/skills/` or your OpenCode config skill directory
  116. - Cursor: install repository rules and `AGENTS.md` into the target project
  117. - Claude Code: install command files and `CLAUDE.md` into the target project
  118. ### 2. Install a bundle
  119. Match the installed bundle to the workflow you plan to activate. Do not install `openspec-superpowers` and then try to trigger `superpowers-openspec-superpowers`, or the runtime rules may not match the prompt.
  120. If you want the recommended workflow, install `superpowers-openspec-superpowers`.
  121. Windows PowerShell examples:
  122. ```powershell
  123. .\scripts\install-codex.ps1 -Bundle superpowers-openspec-superpowers
  124. .\scripts\install-opencode.ps1 -Bundle superpowers-openspec-superpowers
  125. .\scripts\install-cursor.ps1 -Bundle superpowers-openspec-superpowers -ProjectRoot <project-root>
  126. .\scripts\install-claude-code.ps1 -Bundle superpowers-openspec-superpowers -ProjectRoot <project-root>
  127. ```
  128. macOS or Linux examples:
  129. ```bash
  130. sh "./scripts/install-codex.sh" --bundle superpowers-openspec-superpowers --codex-home "$HOME/.codex"
  131. sh "./scripts/install-opencode.sh" --bundle superpowers-openspec-superpowers --opencode-home "$HOME/.config/opencode"
  132. sh "./scripts/install-cursor.sh" --bundle superpowers-openspec-superpowers --project-root <project-root>
  133. sh "./scripts/install-claude-code.sh" --bundle superpowers-openspec-superpowers --project-root <project-root>
  134. ```
  135. If the target project already has a `CLAUDE.md` and you want to merge the bundle instructions into it instead of replacing it, use:
  136. ```powershell
  137. .\scripts\install-claude-code.ps1 -Bundle superpowers-openspec-superpowers -ProjectRoot <project-root> -MergeClaudeMd
  138. ```
  139. ```bash
  140. sh "./scripts/install-claude-code.sh" --bundle superpowers-openspec-superpowers --project-root <project-root> --merge-claude-md
  141. ```
  142. If you want the OpenSpec -> Superpowers workflow, install `openspec-superpowers`.
  143. Windows PowerShell examples:
  144. ```powershell
  145. .\scripts\install-codex.ps1 -Bundle openspec-superpowers
  146. .\scripts\install-opencode.ps1 -Bundle openspec-superpowers
  147. .\scripts\install-cursor.ps1 -Bundle openspec-superpowers -ProjectRoot <project-root>
  148. .\scripts\install-claude-code.ps1 -Bundle openspec-superpowers -ProjectRoot <project-root>
  149. ```
  150. macOS or Linux examples:
  151. ```bash
  152. sh "./scripts/install-codex.sh" --bundle openspec-superpowers --codex-home "$HOME/.codex"
  153. sh "./scripts/install-opencode.sh" --bundle openspec-superpowers --opencode-home "$HOME/.config/opencode"
  154. sh "./scripts/install-cursor.sh" --bundle openspec-superpowers --project-root <project-root>
  155. sh "./scripts/install-claude-code.sh" --bundle openspec-superpowers --project-root <project-root>
  156. ```
  157. If the target project already has a `CLAUDE.md` and you want to merge the bundle instructions into it instead of replacing it, use:
  158. ```powershell
  159. .\scripts\install-claude-code.ps1 -Bundle openspec-superpowers -ProjectRoot <project-root> -MergeClaudeMd
  160. ```
  161. ```bash
  162. sh "./scripts/install-claude-code.sh" --bundle openspec-superpowers --project-root <project-root> --merge-claude-md
  163. ```
  164. ### 3. Activate the workflow explicitly
  165. Activate the same workflow family that you installed above.
  166. - Codex:
  167. ```text
  168. Use $superpowers-openspec-superpowers-workflow for this feature.
  169. ```
  170. - OpenCode:
  171. ```text
  172. Use the superpowers-openspec-superpowers-workflow skill for this feature.
  173. ```
  174. - Cursor:
  175. ```text
  176. Use the superpowers-openspec-superpowers workflow for this feature.
  177. ```
  178. - Claude Code:
  179. ```text
  180. /superpowers-openspec-superpowers-workflow
  181. <describe the feature request>
  182. ```
  183. For Cursor, `superpowers-openspec-superpowers` is routed by repository rules after installation. It is not a native slash command, so the project must already contain the matching `AGENTS.md` and `.cursor/rules` files from the `superpowers-openspec-superpowers` bundle.
  184. ### 4. Use memory when you need cross-session continuity
  185. Optional memory scaffold:
  186. ```powershell
  187. .\scripts\install-superpowers-memory.ps1 -ProjectRoot <project-root>
  188. ```
  189. Optional tool integration:
  190. ```powershell
  191. .\scripts\install-superpowers-memory-integration.ps1 -Tool all -ProjectRoot <project-root>
  192. ```
  193. When a project contains `.superpowers-memory/`, workflows can read and update files such as:
  194. - `PROJECT_CONTEXT.md`
  195. - `CURRENT_STATE.md`
  196. - `DECISIONS.md`
  197. - `KNOWN_FAILURES.md`
  198. - `session-journal/`
  199. Use `superpowers-learning` after meaningful work if you want to write back the durable outcomes of the session, update project memory, and make the next session easier to resume.
  200. ## Requirements
  201. - OpenSpec CLI for workflows that create or inspect OpenSpec changes
  202. - A real project repository where the agent can write docs, plans, code, tests, and verification output
  203. - Optional: a `.superpowers-memory/` folder for repo-persisted memory
  204. ## Repository Layout
  205. ```text
  206. team-skills/ source workflow definitions
  207. dist/ tool-specific distributable bundles
  208. scripts/ install and maintenance scripts
  209. templates/ memory templates and helper content
  210. docs/ supporting documentation
  211. ```
  212. ## Build vs Install
  213. There are two kinds of scripts in this repository:
  214. - `install-*`: for end users installing bundles into AI tools or target projects
  215. - `build-dist.ps1`: for maintainers rebuilding and validating `dist/`
  216. If you change workflow sources or bundle structure, run:
  217. ```powershell
  218. .\scripts\build-dist.ps1
  219. ```
  220. ## Tool Support
  221. - Codex: best fit for native skill-based usage
  222. - OpenCode: native skill-style usage through `.opencode/skills/` or the configured OpenCode skills directory
  223. - Cursor: uses repository rules and `AGENTS.md`
  224. - Claude Code: uses command files and `CLAUDE.md`
  225. - Other tools: can be added later by creating new adapters under `dist/`
  226. ## Advanced Usage
  227. ### Installer Notes
  228. Native shell installers support these common flags:
  229. - `--bundle <name>`: choose which bundle to install
  230. - `--project-root <path>`: set the target repository root for Cursor, Claude Code, or memory installation
  231. - `--codex-home <path>`: set the Codex home directory for Codex installs
  232. - `--opencode-home <path>`: set the OpenCode config directory for OpenCode installs
  233. - `--dry-run`: preview what would be written without copying files
  234. - `--backup`: back up existing target files before overwrite
  235. - `--merge-claude-md`: for Claude Code installs, merge the bundle `CLAUDE.md` into an existing project `CLAUDE.md` instead of replacing it
  236. - `--force`: skip overwrite confirmation
  237. - `--check-dependencies`: check runtime requirements such as `openspec` without installing files
  238. PowerShell installers expose the same ideas through parameters such as `-Bundle`, `-ProjectRoot`, `-CodexHome`, `-OpenCodeHome`, `-DryRun`, `-Backup`, `-MergeClaudeMd`, `-Force`, and `-CheckDependencies`.
  239. Available installer scripts:
  240. - `scripts/install-codex.sh`
  241. - `scripts/install-codex.ps1`
  242. - `scripts/install-opencode.sh`
  243. - `scripts/install-opencode.ps1`
  244. - `scripts/install-cursor.sh`
  245. - `scripts/install-cursor.ps1`
  246. - `scripts/install-claude-code.sh`
  247. - `scripts/install-claude-code.ps1`
  248. - `scripts/install-superpowers-memory.sh`
  249. - `scripts/install-superpowers-memory.ps1`
  250. - `scripts/install-superpowers-memory-integration.sh`
  251. - `scripts/install-superpowers-memory-integration.ps1`
  252. ### Tool-Specific Behavior
  253. - Codex installs bundles into `.codex/skills/` and is the closest fit for native skill-style usage.
  254. - OpenCode installs bundles into `.opencode/skills/` or the configured OpenCode skills directory and can load the same `SKILL.md` packages natively.
  255. - Cursor installs repository rules plus `AGENTS.md`. Use explicit text requests in chat instead of expecting a native slash command.
  256. - Claude Code installs `.claude/commands/` files plus `CLAUDE.md`. Prefer invoking the generated slash command so the command file is applied consistently.
  257. ### Installing Multiple Bundles
  258. Multiple bundles are supported, but the behavior is different in each tool.
  259. - Codex: lowest risk. Bundles install as separate skill directories, so `openspec-superpowers-workflow` and `superpowers-openspec-superpowers-workflow` can coexist. The main requirement is to explicitly name the workflow you want.
  260. - Claude Code: medium risk. Slash-command files under `.claude/commands/` can coexist, but `CLAUDE.md` is a shared top-level file and the most recently installed bundle will overwrite it.
  261. - Cursor: highest risk. Bundle installs copy both `AGENTS.md` and `.cursor/rules/` into the target project. `AGENTS.md` is overwritten by the last install, while rule files may accumulate side by side. That means multiple bundles can coexist, but routing behavior depends on the final combination of files in the project.
  262. Recommended practice:
  263. - For Codex, installing multiple bundles is generally fine.
  264. - For Claude Code, multiple bundles are workable if you mainly rely on explicit slash commands and understand that `CLAUDE.md` follows the last installation.
  265. - For Cursor, prefer one primary workflow bundle per project unless you are intentionally managing the final `AGENTS.md` and `.cursor/rules/` layout yourself.
  266. Recommended activation examples:
  267. - Codex: `Use $superpowers-openspec-superpowers-workflow for this feature.`
  268. - OpenCode: `Use the superpowers-openspec-superpowers-workflow skill for this feature.`
  269. - Cursor: `Use the superpowers-openspec-superpowers workflow for this feature.`
  270. - Claude Code: `/superpowers-openspec-superpowers-workflow`
  271. For Cursor, if the project has multiple workflow bundles, older rule files, or any routing ambiguity, use this stricter example:
  272. ```text
  273. Use $superpowers-openspec-superpowers-workflow for this feature.
  274. Start with Superpowers exploration first. Do not start with openspec-propose or the default OpenSpec workflow.
  275. Then move to OpenSpec to generate proposal, design, spec, and tasks.
  276. After OpenSpec tasks are generated, show them to me and wait for my confirmation before implementation.
  277. Do not suggest /opsx:apply.
  278. ```
  279. ### Task Confirmation and Continuations
  280. The two combined workflows, `openspec-superpowers-workflow` and `superpowers-openspec-superpowers-workflow`, support a staged handoff after OpenSpec task generation.
  281. `task_confirmation_mode` controls what happens after OpenSpec `tasks.md` is generated:
  282. - `required`: always stop and wait for user confirmation
  283. - `optional`: show the task list and wait by default, unless the user explicitly asks for direct execution
  284. - `off`: continue directly into implementation planning without pausing
  285. Default behavior is `optional`.
  286. In the default flow:
  287. 1. Generate and review OpenSpec artifacts.
  288. 2. Show `tasks.md` and wait for confirmation.
  289. 3. After confirmation, pause again and ask whether to continue execution development.
  290. 4. After execution and verification, optionally pause again for review or archive continuation.
  291. Useful continuation commands:
  292. - `continue-dev`
  293. - `continue-review`
  294. - `continue-archive`
  295. If your environment supports Chinese trigger text, the corresponding shortcuts may also be available there, but the English commands above are the safest cross-environment examples.
  296. Suggested prompts:
  297. ```text
  298. After OpenSpec tasks are generated, show them to me and wait for my confirmation before implementation.
  299. ```
  300. ```text
  301. After I confirm OpenSpec tasks, ask whether to continue execution development.
  302. ```
  303. ### Bundle Model
  304. This repository distributes user-facing workflow packs as bundles, not as single folders copied out of the source tree.
  305. Current bundle families:
  306. - `dist/codex/bundles/`
  307. - `dist/cursor/bundles/`
  308. - `dist/claude-code/bundles/`
  309. Each bundle contains only the files expected by the target tool.
  310. ### Maintainer Context
  311. The source workflows under `team-skills/` are intentionally more modular than the installable bundles.
  312. That distinction exists because:
  313. - source workflows are for maintainers
  314. - bundles are for end users
  315. If you change source workflows, metadata, or bundle structure conventions, rebuild `dist/` with:
  316. ```powershell
  317. .\scripts\build-dist.ps1
  318. ```
  319. ## Documentation
  320. - [English README](README.md)
  321. - [Chinese README](README.cn.md)
  322. - [English Memory Guide](MEMORY.md)
  323. - [Chinese Memory Guide](MEMORY.cn.md)
  324. - [English Verification Guide](VERIFY.md)
  325. - [Chinese Verification Guide](VERIFY.cn.md)
  326. - [English Source Workflow Overview](team-skills/README.md)
  327. - [Chinese Source Workflow Overview](team-skills/README.cn.md)
  328. - [English Source Workflow Install Notes](team-skills/INSTALL.md)
  329. - [Chinese Source Workflow Install Notes](team-skills/INSTALL.cn.md)
  330. - [English Source Workflow Usage Guide](team-skills/USAGE.md)
  331. - [Chinese Source Workflow Usage Guide](team-skills/USAGE.cn.md)
  332. ## Community
  333. - [CONTRIBUTING.md](CONTRIBUTING.md)
  334. - [SECURITY.md](SECURITY.md)
  335. - [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md)
  336. - [CHANGELOG.md](CHANGELOG.md)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.