Plugin reference · v0.59.0
Every skill and agent, in one place.
A complete inventory of what's inside the Sulis plugin: seven specialist agents
and 49 skills, organised by the stage they belong to. Most founders won't need
to read this — Sulis routes you through the right ones automatically. This page is here when
you want to know what Sulis can actually do.
The stages
Every piece of work moves through six stages. Each stage has one entry-point skill
— the one Sulis runs when you arrive at that stage. Additional supporting skills
handle deeper work inside the stage. The mapping below is the canonical view.
Look around before building. Sulis reads the existing repo — what's there, what conventions are
in use, what's load-bearing — so design and build don't reinvent or contradict what's already done.
Entry point
/sulis:recon
Finds out what's already in the repo at the start of a change.
Supporting skills
/sulis:discover-project
Sets up Sulis for a project by minting its project record. Run once per repo when adopting Sulis.
/sulis:discover-context
Captures what already exists in a codebase before work begins.
/sulis:refresh-context
Re-checks the project context index after the codebase has changed.
/sulis:show-context
Shows the current project context index without changing anything.
Write down what the work should do, at the right depth. A guided conversation produces a
requirements document covering functional needs, non-functional needs, edge cases, and
misuse scenarios.
Entry point
/sulis:specify
Writes down what a piece of work should do, at the right depth.
Supporting skills
/sulis:requirements-validation
Checks a specification for completeness and reports gaps.
/sulis:critical-thinking
Applies the Critical Thinking Standard to the task at hand.
/sulis:requirements-templates
Templates used by the requirements analyst, not run directly.
/sulis:codebase-mapping
Maps an existing codebase so requirements work can build on what's there.
/sulis:map-architecture
Maps a product's building blocks and how they depend on each other.
/sulis:index-specifications
Rebuilds the index of all specifications in the project.
Turn the "what" into a "how". The architect translates requirements into a technical blueprint,
then breaks the blueprint into independent, shippable tasks. Greenfield work uses
/sulis:design; brownfield work (changing existing code)
uses /sulis:audit.
Entry point · Greenfield
/sulis:design
Turns a spec into a technical blueprint and a to-do list of tasks.
Entry point · Brownfield
/sulis:audit
Reviews existing code before you change it and drafts the fixes to close the gaps.
Supporting skills
/sulis:draft-architecture
Turns a requirements document into a technical blueprint.
/sulis:plan-work
Turns a blueprint into a to-do list of independent, shippable tasks.
/sulis:analyse-codebase
Scans an existing codebase and reports its structure, complexity, and risks.
/sulis:codebase-audit
Audits existing code for gaps and drafts the fixes to close them.
/sulis:harden-codebase
Implements the accepted hardening fixes, each backed by a test.
/sulis:suggest-split
Splits a too-large pull request into smaller ones and gives you the commands.
Build it, one task at a time. Each task follows the same atomic lifecycle: write the failing
test first, write the minimum code to pass, refactor, commit. Nothing's "done" until it's
shipped to your branch.
Entry point
/sulis:run-all
Builds and ships every ready task in the to-do list.
Supporting skills
/sulis:run-wp
Builds and ships a single task.
/sulis:retry
Resets a blocked task and runs it again from scratch.
Is it safe and sound before shipping? Sulis verifies the design was honoured, the eight
quality checks all pass, and the security review found nothing critical. Critical findings
fix before ship; concerns get queued.
Entry point
/sulis:review
Checks whether a finished change is safe and sound before shipping.
Verifying the work
/sulis:verify-architecture
Checks that shipped work matches the design and reports gaps.
/sulis:code-review
Reviews a pull request or branch and reports what to fix before merging.
/sulis:code-health
Runs a full health check across your code and reports what needs attention.
/sulis:address-findings
Turns code-health findings into an ordered to-do list of fixes.
The eight quality checks
/sulis:check-build
Checks whether your project builds and flags anything broken.
/sulis:check-tests
Runs the tests and flags anything that used to work but now doesn't.
/sulis:check-security
Checks whether anything in the code could harm users or the business.
/sulis:check-reliability
Checks whether the code handles failure gracefully.
/sulis:check-readability
Checks whether the code is clear and easy to read.
/sulis:check-maintainability
Checks whether the code will be easy to change later.
/sulis:check-polish
Checks whether the project feels finished and professional.
Retrofitting older work
/sulis:backfill-code-review
Runs code review retroactively on work that shipped without it.
/sulis:backfill-gates
Runs security review retroactively on work that shipped before the gate existed.
/sulis:codebase-assess
Deprecated — use /sulis:code-health instead.
Land the finished work. Merge the change branch into dev,
clean up the worktree, capture lessons. The artifacts stay yours — every commit on your
branch, every spec in your repo. Stage 5 has no dedicated supporting skills; the
cross-cutting /sulis:change command handles it.
Entry point
/sulis:change ship
A sub-command of /sulis:change — see Cross-cutting below.
Cross-cutting
Skills that work at any stage. They don't belong to a parent stage — you reach for them
when you need to know where you are, switch register, or hand the journey to someone else.
Knowing where you are
Reading the state of your work without changing it.
/sulis:start
Resumes an existing journey where you left off.
/sulis:status
Shows the current journey state in plain English.
/sulis:dashboard
Shows every piece of work you have in flight and how far along each is.
/sulis:inbox
Shows everything waiting on you, in one list.
/sulis:wp-status
Shows what's done, in-flight, blocked, and pending for a change.
Your backlog
Capturing ideas and seeing what's in flight, without committing to a change yet.
/sulis:capture
Jots down an idea the moment you have it — why it matters and what it'd take — so nothing good gets lost.
/sulis:backlog
Shows what you're thinking about, what you've committed to, and what's already built — your living backlog.
Working with changes
The lifecycle of a single piece of work, from start to ship.
/sulis:handoff
Records the hand-off note when passing you to a specialist.
/sulis:jargon
Switches Sulis between plain-English and technical replies for the session.
/sulis:release-train
Drafts the release pull request that ships everything on dev to production — read-only, opens nothing without your say-so.
After you ship
Carrying lessons forward so the next piece of work is better than the last.
/sulis:retro
Run at the end of a session to capture what got in the way — friction, steers, missing context — and routes each finding to where it'll actually get acted on.
/sulis:capture-lessons
Captures the lessons from a piece of work as durable GitHub issues + a digest.
/sulis:resolve-lessons
Proactively drains the lesson backlog — drafts, schedules, and ships a fix per actionable lesson, with a plan-then-approve gate.
Help shape Sulis
Sulis is in alpha — your feedback shapes what ships next. This skill makes it easy to send a redacted issue straight to the maintainers, no email or form-filling.
/sulis:feedback
Sends a redacted feedback issue to the open-source Sulis repo so the maintainers hear what's working and what isn't.
For plugin authors
If you're extending Sulis rather than using it, these three skills are your toolkit.
Most founders will never need them.
/sulis:add-skill
Authors a new Sulis skill through a guided, standards-backed flow.
/sulis:add-agent
Authors a new Sulis agent through a guided, standards-backed flow.
/sulis:consolidate-into-sulis
Folds a separate plugin into the Sulis plugin using the proven recipe.
The team
Sulis is one entry point. Behind it sit eight specialists — each owns a stage of the work
and answers to Sulis. You never call a specialist directly; Sulis brings them in at the
right moment and translates their output back into plain English for you.
Sulis
sulis
The concierge. Owns the journey end-to-end — gathering requirements, designing the architecture, writing and reviewing the code, and shipping it. Talks to you in plain English. Translates the specialists back.
Owns: the journey end-to-end
How you reach it: claude --agent sulis:sulis
Context cartographer
sulis:context-cartographer
Maps the docs, decisions, and conventions already in a project so later tools build on them. Produces one artifact per project: .context/{project}/INDEX.md.
Opportunity analyst
sulis:opportunity-analyst
Pressure-tests the why behind an idea, one question at a time, until the job it does is clear enough to build the right thing. The agent that asks "what problem are we actually solving?" before any specifying starts.
Requirements analyst
sulis:requirements-analyst
Interviews you one question at a time to produce a clear requirements document. One conversation, capturing functional needs, non-functional needs, edge cases, and misuse scenarios.
Engineering architect
sulis:engineering-architect
Turns requirements into a hardened technical design and breaks it into buildable tasks. Also runs the verification pass after build: did the shipped code match the design?
UX designer
sulis:ux-designer
Designs and owns the visual contract for any user-facing surface. Runs the inspiration probe, produces a real-token HTML mockup, verifies accessibility, and facilitates your sign-off before any screen is built.
Executor
sulis:executor
Builds one task end-to-end — tests first, then code, then commit and push. Per task: red, green, refactor, lint, review, ship. The most autonomous specialist; Sulis dispatches a fresh executor for each ready task.
Security reviewer
sulis:security-reviewer
Audits a codebase for security and viability risks and reports what to fix before shipping. Produces a viability report with severity per finding: critical, concern, advisory, or pass.
Orchestrator
sulis:orchestrator
Reference specification for the task-dispatch loop, kept for documentation. Not run directly — Sulis uses its loop inline when shipping a batch of tasks.
Status: reference only, not invoked
Numbers reflect plugin v0.99.0. Surface evolves between alpha releases — commands sometimes rename, supporting skills get added. The
GitHub repo has the live source of truth, and the changelog records every move between versions.