JSM Skills
Five slash commands for an agent: a plan before code, memory across sessions, review, failure triage and one UI registry
- 239 ★ on the repository
- Last commit
- MIT
Extended access
Why this level
- The skills write `memory.md` and `ui-registry.md` into the project, and the agent makes decisions from them
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/jsm-skillsDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- The skills write `memory.md` and `ui-registry.md` into the project, and the agent makes decisions from them
This is third-party code. Review the repository files before installing.
What it does
Five skills bring discipline to the places where an agent by default forgets context and rushes to code. Before work starts, `/architect` aligns terms with the developer, walks through the decisions that change the implementation and produces a plan that must be confirmed. No code is written until it is. `/remember save` compresses what matters into `memory.md` at the end of a session, and `/remember restore` brings the context back in a new session and asks for confirmation. Secrets never reach the memory: a placeholder like `[REDACTED_API_KEY]` stays instead. `/review` checks a finished feature against the plan, the project architecture and production readiness, fixes nothing and only lists findings. `/recover` first determines the type of failure and only then picks a response: a targeted fix, a hard session reset or a rethink of the foundation. After each interface component `/imprint` writes spacing, colors and radii into `ui-registry.md` so the next components match earlier ones. The `/imprint audit` mode looks for inconsistencies in an interface that already exists.
Who it is for. Developers and vibe coders who build a product with an agent and are tired of forgotten decisions, architecture drift and mismatched interface components.
Good fit when
- Before a new feature you want to discuss terms and contested decisions with the agent before it writes the first line of code
- Yesterday's session ended halfway and today the agent needs the plan, agreements and open questions back
- A feature works but it is unclear whether it drifted from the plan or broke architecture boundaries
- The agent has fixed the same error three times in a row and made it worse each time, so it is time to decide what to do with the session
- Buttons and cards in the app come out with different spacing and shades
Not a fit when
- A five-minute task such as fixing a typo, where discussing a plan takes longer than the work
- You need an automatic check in CI: `/review` is a dialogue inside a session and does not replace linters and tests
- A project without an interface, where `/imprint` and `ui-registry.md` have no use
Example request
/architect I need a profile settings page with avatar upload. Let's agree on terms and decisions first, then draw up a planLimitations
- The skills work only inside a dialogue and run nothing on their own. The result depends on the agent and on how detailed your answers are.
- Memory is stored in a plain `memory.md` file in the project. It is not encrypted, and checking its contents before a commit is up to you.
- `/review` only lists findings. Fixing them takes a separate command or manual work.
- The repository has no tests or examples, only five `SKILL.md` files and a description.
How to disable. Delete the `architect`, `remember`, `review`, `recover` and `imprint` folders from the agent's skills directory. The `memory.md` and `ui-registry.md` files stay in the project and are deleted by hand.
FAQ
How do I install JSM Skills in Claude Code?
Run `npx skills@latest add JavaScript-Mastery-Pro/jsm-agent-skill` and restart the agent. The installer puts all five skills into the chosen agent's skills directory.
Which agents do the skills work with?
Any agent that understands the `SKILL.md` format: Claude Code, Cursor, Windsurf, Codex and Cline. There are no agent-specific settings.
How do I carry context into a new session?
At the end of work run `/remember save`: the compressed state lands in `memory.md`. In a new session run `/remember restore`, and the agent loads it and asks whether to continue.
What does /recover do when the agent loops?
It asks what was expected, what happened and how many fix attempts there have been. Then it picks one of three: a targeted fix, a hard reset of the polluted session or a rethink of the foundation.
When should I run /imprint audit?
Before the first `/imprint` in a project that already has an interface but no `ui-registry.md`. The mode scans the codebase, finds inconsistencies and sets a baseline.
Discussion
No questions or reviews yet.
Related
SkillsNine JS Mastery skills take a change through phases: from idea and spec to verification, tests, release texts and a docs sync
Builder Skills
Skills for agents
A set of small skills from Builder.io for agent work habits: visual plans and diff recaps, docs-first checks, cross-agent review and clean status updates
jmo-skills: hackathon workflow skills
jmo-skills
A Claude Code plugin: project interviews that end in a spec, plain technical writing, UI polish, animation and handoffs to Codex
Eight personal skills by Julius Brussee: terse replies, interfaces, plan grilling, a task loop, review, text cleanup, context checks
A set of Claude Code skills for the dev workflow: worktree isolation, a service layer, evidence and review
Eight skills for engineering habits: think a plan through, find a bug's root cause, check a diff, read a source
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Repository stars | Main difference |
|---|---|---|---|
| JSM Skills (this card) | no | 239 | |
| Superpowers | no | 313,096 | a large library with brainstorming, TDD and subagents; JSM Skills is limited to five commands, including session memory and a UI registry |
| Agent Skills by Addy Osmani | no | 113,521 | 25 skills across the development lifecycle; JSM Skills is shorter and adds context saving between sessions |
README in short
The description explains the idea of discipline for an agent and lists five commands with when to run each. At the bottom sit a workflow diagram from plan to release and a link to the author.
README badge
Original SKILL.md
--- name: architect description: Think through what you are about to build like a senior engineer before writing any code. Surfaces decisions, aligns on language, and produces a clear implementation plan you confirm before anything starts. --- You are a senior engineer sitting with a developer before they start building. Your job is not to interrogate them — it is to think alongside them. To ask the questions a senior engineer would ask before letting someone start coding. To catch the things that seem obvious but aren't. To make sure both of you are building the same thing in your heads before either of you touches the code. This is a thinking session. Not a grilling session. ## Step 1 — Understand What's Here Before saying anything, take stock of what already exists: - Read the feature description the developer gave you - Read any context files, documentation, or existing code available - Build a clear picture of what needs to be built and what already exists Do not ask about anything already clearly answered by existing documentation. A good senior engineer does their homework before the meeting. ## Step 2 — Align on Language Every project has its own vocabulary. Before discussing implementation, make sure you and the developer mean the same thing by the same words. Identify 3-5 terms from the feature description that could be interpreted more than one way. Define each one based on what you understand from the context. Present them to the developer for confirmation. ``` Before we think this through — let me make sure we are speaking the same language: - "[Term]" — I understand this to mean [definition]. Is that right? - "[Term]" — I am treating this as [definition]. Does that match what you have in mind? Correct anything that is off before we go further. ``` Update your understanding immediately if the developer corrects a term. Do not continue until the language is aligned. ## Step 3 — Think Through the Decisions Together Now surface the decisions that would meaningfully change what gets built. Not every possible question — only the ones where the answer changes the implementation direction. A senior engineer knows the difference between a decision that matters and a detail that can be figured out during coding. Ask only what matters. For each decision: - Ask one question at a time - Share what you would do and why — give the developer something to react to, not a blank page to fill - Listen to their answer before moving to the next decision