Skip to content
Back to search

skills

Agentic Development skills behind the JS Mastery workflow

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/jsmastery-pro-skills/badge.svg)](/listings/jsmastery-pro-skills)

HTML

<a href="/listings/jsmastery-pro-skills"><img src="/api/listings/jsmastery-pro-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.

Uses [npx skills](https://github.com/vercel-labs/skills). Pick your agent:

# Claude Code (installs into .claude/skills, then restart Claude Code)
npx skills@latest add jsmastery-pro/skills -a claude-code

# Generic .agents/skills, read by Codex and other agents
npx skills@latest add jsmastery-pro/skills

Works on any Agent Skills client (Claude Code, Cursor, Codex, Gemini CLI, and [more](https://agentskills.io/clients)). Commit the installed skills folder to share the workflow with your team.

Each skill's instructions live in its `SKILL.md`, which is what every client reads. The `agents/openai.yaml` beside it is interface metadata only (the name, blurb, and opening prompt Codex shows in its agent picker); it carries no logic of its own.

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 · 121 lines

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

  1. # Engineering Workflow Skills
  2. A set of [Agent Skills](https://agentskills.io) that take a change from a vague idea to shipped, verified, documented code, for any AI coding agent. One skill per phase. Run only the ones a change needs, in any order.
  3. The state lives in files (a scope, specs, AGENTS.md, tests), not in a chat session. So work survives across sessions, picks up where it left off, and works for a whole team.
  4. ```
  5. idea → /scope → /audit → /architect → /develop → /check verify → /test → /check review → /document → /sync
  6. ```
  7. Run `/debug` anytime something breaks. Run a bare `/scope` anytime to see where things stand.
  8. > 📖 **Want the full picture?** Read the **[Workflow Guide](docs/workflow-guide.md)** — a plain-language walkthrough of every skill, the files that carry the work, who owns what, and one idea followed all the way from scope to shipped.
  9. ## The skills
  10. | Skill | What it does |
  11. |---|---|
  12. | `scope` | Turns a product idea into a living, coarse scope and keeps it current as you ship. |
  13. | `audit` | Writes the AGENTS.md context files every other skill reads. |
  14. | `architect` | Makes a load bearing decision and writes it as a build spec in `docs/specs/`. |
  15. | `develop` | Builds a feature, UI or backend, from its spec. Gates to `/architect` if a decision is owed. |
  16. | `check` | Confirms a change before merge. `/check verify` runs the real app; `/check review` reads the code on a second model. |
  17. | `test` | Writes a test suite for the code you just changed. |
  18. | `document` | Writes the PR text, changelog, release note, or postmortem from the real diff. |
  19. | `sync` | Keeps AGENTS.md, the scope, and spec statuses current after a change. |
  20. | `debug` | Finds and fixes the root cause of a bug, then hands a regression test to `/test`. |
  21. Hardening (systems level failure mode analysis) is temporarily removed and will return as a system design specialization.
  22. ## Install
  23. Uses [npx skills](https://github.com/vercel-labs/skills). Pick your agent:
  24. ```bash
  25. # Claude Code (installs into .claude/skills, then restart Claude Code)
  26. npx skills@latest add jsmastery-pro/skills -a claude-code
  27. # Generic .agents/skills, read by Codex and other agents
  28. npx skills@latest add jsmastery-pro/skills
  29. ```
  30. Works on any Agent Skills client (Claude Code, Cursor, Codex, Gemini CLI, and [more](https://agentskills.io/clients)). Commit the installed skills folder to share the workflow with your team.
  31. Each skill's instructions live in its `SKILL.md`, which is what every client reads. The `agents/openai.yaml` beside it is interface metadata only (the name, blurb, and opening prompt Codex shows in its agent picker); it carries no logic of its own.
  32. ## Where to start
  33. **New product (greenfield):** `/scope` the idea, then `/architect` the stack, then scaffold the project, then `/audit` to seed AGENTS.md from the real project, then the feature loop. The stack is decided and the project scaffolded before `/audit` runs, so it reads a real project, not an empty one.
  34. **Existing codebase (brownfield):** `/audit` first so every skill understands your project, then `/scope` the next slice on top of what exists, then the feature loop.
  35. **Any single change:** run only what it needs. A bug goes straight to `/debug`. A small change can be `/develop` then `/check verify`.
  36. **Monorepo:** everything scopes to the target workspace, which has its own AGENTS.md, scope, stack, and commands.
  37. ### The feature loop
  38. ```
  39. /architect → /develop → /check verify → /test → /check review → /document → /sync
  40. ```
  41. At the end of `/scope` you also pick a **workflow depth** for the project (override per feature anytime): `Prototype` (just `/develop`, self-checked, for throwaway work), `Alpha` (adds `/check verify`), `Beta` (adds `/test`), or `GA` (adds a fresh-model `/check review` and `/document`). The depth is a *suggested* checking tail after `/develop`, never a track you're locked onto: you're in charge, you run or skip any step and mark a feature `done` when you decide it is. The one thing the workflow asks — at every depth — is that a load-bearing decision gets written down (`/architect`), not that any check be run.
  42. `/scope` fixes what to build. `/architect` designs how, as a spec whose acceptance criteria are the contract; every later step traces back to that contract. `/develop` gates on the spec: if building would mean inventing an undecided design, provider, or data model, it stops and routes you to `/architect`. You can override and build anyway, but the override is not free: the assumption is recorded as an `Assumed` spec in `docs/specs/` and flagged on the feature until `/architect` ratifies it. The flag doesn't block you from marking `done` — it's a standing reminder that a decision still owes ratification, so it never gets silently lost in chat.
  43. The gate is layered, not magic: `/architect` names the source of every value a feature must produce (so gaps surface at design time), `/develop` checks that coverage again before building, and at Beta+ `/architect` recommends running an independent cross-model critic over the spec for decisions it never settled (you decide, and you decide on any gaps it finds). It's a strong, defense-in-depth gate that catches the vast majority — not an absolute guarantee, no prompt can be. Behavioral correctness is caught by the `/check verify` and `/test` layers.
  44. ## What gets written, and where
  45. | Artifact | Path | Owner |
  46. |---|---|---|
  47. | Scope | `docs/scope/` | scope |
  48. | Specs | `docs/specs/` | architect |
  49. | Context files | AGENTS.md (plus a thin CLAUDE.md pointer) | audit, kept current by sync |
  50. | Design system | `design.md` (art direction; token values live in CSS) | develop |
  51. | Review findings | `docs/reviews/` | check |
  52. | Tests | your test dirs | test |
  53. | App code | your source tree | develop |
  54. | Human docs | PR body, CHANGELOG.md, `docs/releases/`, `docs/postmortems/` | document |
  55. If `docs/` is a published docs site, these move to `.workflow/` so they do not ship with your site. Because state lives in files, each skill suggests `/clear` at handoffs, so a fresh session reads from disk again and long chats do not pile up cost.
  56. ## Skill reference
  57. For each skill: what it does, and when to run it.
  58. **scope**: Turns an idea into a living, coarse plan of what to build, in order.
  59. When: to start a new product or plan the next slice. Greenfield: run it first. Brownfield: it enrolls what already exists, then plans the new work. Monorepo: writes one scope per workspace.
  60. **audit**: Writes the AGENTS.md context files that give every skill your project's stack, commands, and conventions.
  61. When: brownfield, run it first. Greenfield, run it after the stack is chosen and the project is scaffolded. Monorepo: gives each workspace its own nested AGENTS.md.
  62. **architect**: Runs a deep design conversation and writes the decision as a build spec.
  63. When: a load bearing choice is unmade (a stack, a data model, a provider, a page design), or `/develop` says a decision is owed. Greenfield: it decides the stack first. Monorepo: reads the target workspace's stack.
  64. **develop**: Builds a feature, UI or backend, from its spec, runs migrations, and advances the scope.
  65. When: after the decision exists. It gates to `/architect` if a design is owed. Monorepo: builds inside the target workspace using its commands.
  66. **check**: Confirms a change before merge, in two modes.
  67. When: `/check verify` after `/develop` to run the real app and prove the feature works against the spec; `/check review` before a PR for a senior review on a different model than wrote the code. Any project type.
  68. **test**: Writes a senior test suite for your uncommitted change and saves your framework choice.
  69. When: after building a feature or fixing a bug. Monorepo: resolves the framework per package.
  70. **document**: Writes the human facing prose (PR, changelog, release note, postmortem) from the real diff.
  71. When: a finished change needs writing up. Any project type.
  72. **sync**: Reconciles AGENTS.md, the scope, and spec statuses to what the repo now shows.
  73. When: the last step around merge. Monorepo: reconciles the right workspace.
  74. **debug**: Runs a disciplined root cause loop and hands a regression test to `/test`.
  75. When: anytime something is failing, throwing, or behaving wrong. Not tied to project type.
  76. ## Learn more
  77. The **[Workflow Guide](docs/workflow-guide.md)** is the deep dive: how the scope, specs, AGENTS.md, and design system live and who is allowed to change them; the acceptance-criteria thread that ties every stage together; a full worked example from idea to shipped; the debug loop; and how the same flow runs on an existing codebase and in a monorepo.
  78. ---
  79. Built with the [Agent Skills](https://agentskills.io) open format.

Ratings and comments

Sign in to rate this skill.

Sign in

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