██╗██████╗ ██████╗
██╔╝██╔══██╗██╔═══██╗
██╔╝ ██║ ██║██║ ██║
██╔╝ ██║ ██║██║ ██║
██╔╝ ██████╔╝╚██████╔╝
╚═╝ ╚═════╝ ╚═════╝
One install. Multiple environments. All the workflows.
Quick Start • Workflows • Commands • Configuration • Environments • How It Works
slashdo commands emphasize high-quality software engineering over token conservation — expect thorough reviews, multi-agent scans, and verification loops rather than shortcuts.
With npm/npx:
npx slash-do@latestWithout npm (curl):
curl -fsSL https://github.com/raw/atomantic/slashdo/main/install.sh | bashThat's it. slashdo detects your installed AI coding environments and installs commands to each one. Then, inside your assistant:
/do:help
Command syntax: examples below use Claude Code's
/do:<command>(e.g./do:pr). Codex uses$do-<command>; Antigravity CLI (agy/gemini), OpenCode, and Grok Build use/do-<command>.
Real end-to-end examples of how the commands compose. Every flag shown here is optional — the bare command always works.
You've been coding with your assistant and want it committed, pushed, and PR'd — /do:pr commits, pushes, opens a PR (GitHub gh or GitLab glab, auto-detected from the remote), and runs an unconditional self-review. Add an external reviewer and merge automatically once green: /do:pr --review-with codex --merge. See Review loop and Auto-merge.
/do:plan-task investigates the codebase, drafts a decision-complete issue (problem, context, approach, acceptance criteria), shows it to you for approval, and files it in the repo's tracker:
/do:plan-task add a --json flag to the export command
/do:plan-task <idea> --yes # skip the approval gate (still stops on a blocking open question)
/do:plan-task <idea> --enhance-with codex,grok # sharpen the draft through a second/third agent before the gate
--enhance-with <list> (same agent[model] grammar as --review-with) sharpens the draft through a sequential agent pipeline before the approval gate — you still approve the final text.
For a GitHub/GitLab issue such as #123, ship it immediately with /do:next #123 — the command claims it, implements it in an isolated worktree, opens a reviewed PR/MR that closes the issue, merges, and cleans up. With Jira, pass the key instead (for example /do:next PROJ-123); the PR/MR references the Jira key without a code-host Closes #… directive. Add --plan to approve a written implementation plan first.
/do:replan keeps the backlog honest; /do:next drains it — both work with a supported GitHub/GitLab issue tracker or Jira project. GitHub and GitLab use their authenticated gh/glab CLI; Jira uses the Jira CLI and configured project key:
/do:replan # triage: close done/stale issues, file new opportunities
/do:next # claim + ship the next open item
/do:next --swarm=4 # or ship up to 4 independent issues in parallel
On a shared or public tracker, add --collaborators so your agent only claims issues filed by a current repo collaborator (or --self for the stricter @me-only variant). See Work tracking.
/do:better --review-with claude,codex # full DevSecOps audit → per-category PRs → review loop → merge
/do:simplify # refactor-only pass: architecture, DRY, cognitive load — behavior unchanged
/do:review --strict # deep code review of the current branch's changes
/do:review https://git.example.com/o/r/pull/12 # review a PR on any GitHub host — fixes pushed if writable, else inline
/do:review https://gitlab.example.com/g/sub/p/-/merge_requests/7 # same for a GitLab MR (gitlab.com or self-managed)
/do:depfree --heavy # remove unnecessary dependencies by writing replacement code
/do:scan ~/Downloads/sketchy-repo # read-only malware/safety audit of an unfamiliar directory
Note: these only run their review loop and auto-merge when you pass (or have saved) --review-with — without it PRs are left open for manual review.
/do:config --review-with=claude,codex # every review-capable command now uses these reviewers
/do:config --merge # bare /do:pr auto-merges once reviews + CI are green
/do:config --review-models codex=o3 # pin the model a reviewer runs on
/do:config --project --review-with=none # ...except this repo: no external reviewers here
/do:config # show global, per-project, and effective values
See Configuration.
All commands live under the do: namespace:
| Command | What it does |
|---|---|
/do:push |
Commit and push all work, logging it per the project's own changelog convention |
/do:pr |
Commit, push, and open a PR/MR with self-review. External reviewers only when listed (Review loop); --merge auto-merges once green (Auto-merge) |
/do:pr-better |
Run a full do:better audit on the current branch, commit fixes directly, then open a single PR |
/do:fpr |
Fork PR — push to fork, PR against upstream |
/do:rpr |
Resolve PR/MR review feedback with parallel agents |
/do:release |
Create a release PR with version bump and changelog |
/do:review |
Deep code review of changed files, a local branch, a PR, or a GitLab MR (--strict/--nuclear raise the bar) |
/do:better |
Full DevSecOps audit with multi-agent scan, remediation, and per-category PRs |
/do:better-swift |
SwiftUI DevSecOps audit with multi-platform coverage (iOS, macOS, watchOS, tvOS, visionOS) |
/do:simplify |
Refactor-only audit — architecture, DRY, simplification, cognitive load (details) |
/do:scan |
Read-only safety audit of an unfamiliar directory — malware patterns, network calls, vulnerable deps |
/do:depfree |
Audit dependencies, remove unnecessary ones, write replacement code (--heavy for a deeper pass) |
/do:goals |
Generate GOALS.md from codebase analysis — --prd generates PRD.md instead (details) |
/do:prd |
Generate a detailed PRD.md from codebase analysis (/do:goals --prd) (details) |
/do:plan-task |
Investigate the codebase, draft a decision-complete issue, get approval, file it in the tracker |
/do:replan |
Audit/triage the issue tracker — close completed issues, suggest new work (Work tracking) |
/do:next |
Claim the next tracker issue, implement it in an isolated worktree, ship a reviewed PR. --swarm[=N] ships several in parallel (Work tracking) |
/do:omd |
Audit and optimize markdown files against best practices |
/do:config |
View or set saved defaults so future commands can omit their flags (Configuration) |
/do:update |
Update slashdo to latest version |
/do:help |
List all available commands |
/do:simplify is /do:better --simplify-only: the same pipeline narrowed to refactoring, architecture, DRY, simplification, and cognitive load; security, runtime bugs, performance, and test authoring are out of scope. Every fix must be observably behavior-preserving — the existing test suite passes unmodified as the proof. See docs/simplify.md for the audit-agent roster and scoping gates.
/do:simplify # audit → refactor PRs → review loop
/do:simplify --scan-only # just show me what's costing me
/do:simplify --review-with claude src/ # scope to a path, run a reviewer, auto-merge on clean
/do:pr-better --simplify-only # fold a refactor pass into the feature PR you're building
Every /do:better flag works here — --interactive, --scan-only, --no-merge, and the whole review loop set.
/do:goals --prd (shorthand: /do:prd) runs the same discovery pipeline as /do:goals but writes a requirements-level PRD.md instead of a strategic GOALS.md, with stable FR-/NFR-/NR- requirement IDs that persist across --refresh runs. See docs/prd-mode.md for what PRD.md contains and how discovery mines tests for implicit requirements.
/do:goals --prd # generate PRD.md autonomously
/do:prd --interactive # same, with a validation pass on requirements, guardrails, and metrics
/do:prd --refresh # re-scan and update an existing PRD.md, preserving requirement IDs
/do:pr, /do:release, /do:pr-better, /do:review, /do:better, /do:better-swift, /do:simplify, /do:depfree, and /do:rpr share one review system: pick the reviewer(s) with --review-with; companion flags control how the loop runs. No reviewer is ever hardcoded — omit the flag and no external review runs (self-review still does). Implementation details live in docs/review-loop.md.
| Slug | What runs | Model pinnable? |
|---|---|---|
codex |
Codex CLI, headless, local | yes |
claude |
Claude Code CLI, headless, local | yes |
agy |
Antigravity CLI (agy binary; aliases gemini, antigravity) |
yes |
grok |
Grok CLI, headless, local | yes |
pi |
Pi CLI, tool-free with the complete diff inlined — review-only | yes |
cursor |
Cursor Agent CLI, headless (cursor-agent, alias cursor) |
yes |
opencode |
OpenCode CLI, headless (aliases zen, opencode-zen) |
yes |
ollama |
Local Ollama model, review-only. Bare ollama auto-selects your most capable installed model |
yes |
cmd[<invocation>] |
Escape hatch for any other harness — your own shell command, review prompt on stdin. Command line or global config only, never a repo's .slashdo.json (docs/review-loop.md) |
n/a |
@<login> |
Any user or App/bot on the project's code host (e.g. @octocat on GitHub, @jane.doe on GitLab) — slashdo requests their review on the PR/MR and fixes what it surfaces |
no |
copilot |
Legacy. GitHub's cloud Copilot review (GitHub only); still supported when named, but never auto-selected | no |
Reviewers run in the order listed — nothing is ever added implicitly.
/do:pr --review-with codex,agy # run several — each sees the prior's fixes
/do:pr --review-with cursor[gpt-5]~effort=max # pinned model + reasoning effort
/do:pr --review-with opencode[provider/model] # supported provider/model configured in OpenCode
/do:pr --review-with pi~effort=low~max=1 # Pi, reviewed tool-free with a capped budget
/do:pr --review-with codex,ollama~opt # ollama is optional — can't block the merge
- Model pinning (
<agent>[<model>]): pin per run, or save defaults with/do:config --review-models codex=o3,claude=opus,cursor=gpt-5,opencode=provider/model. An explicit bracket always wins. - Optional reviewers (
~opt): findings still get fixed, but an inconclusive result never blocks--merge. A hard error still does. - Per-reviewer iteration caps (
~max=<n>): caps that reviewer's review→fix→re-review cycles (default 3,ollamahas its own cap).0= loop-until-clean, bounded by a 10-iteration guardrail. - Per-reviewer reasoning effort (
~effort=<level>, one oflow/medium/high/xhigh/max): e.g.cursor[gpt-5]~effort=max,opencode[provider/model]~effort=high— a saved--review-models cursor=…default pairs with a barecursor~effort=…. Falls back to prompt guidance where a reviewer has no matching control.
All three suffixes chain in any order and are shell-safe. ~max is ignored (with a warning) in --review-mode parallel. None affects reviewer identity, so ollama~effort=high and ollama dedupe to one pass.
| Flag | Default | What it does |
|---|---|---|
--review-with <list> |
none | Comma-list of reviewers, run in order. Each entry may carry ~opt, ~max=<n>, and/or ~effort=<level> |
--review-iterations <n> |
1 |
Cap review-and-fix cycles for a copilot/@<login> pass. 0 = loop-until-clean (10-iteration guardrail). Local CLIs use ~max=<n> instead |
--review-mode <series|parallel> |
series |
series: each reviewer sees prior fixes. parallel: all run concurrently, deduped union applied once (faster; ~max and stop-mode ignored) |
--review-stop-on-findings |
off | Stop after the first reviewer that fixes ≥1 finding. Exclusive with --review-stop-on-clean |
--review-stop-on-clean |
off | Stop after the first reviewer that reports zero findings |
--reviewer-applies |
off | Let the reviewer edit the tree itself instead of the orchestrator applying its findings. Only codex supports this; every other reviewer is forced back to review-only |
The merge gate. Commands that merge (e.g. /do:release, /do:pr --merge) require the multi-reviewer aggregate status to be clean — or partial, if you explicitly opted into a stop-mode short-circuit. A dirty or inconclusive aggregate blocks the merge, even if other passes returned clean.
Command-specific behavior: /do:review runs its own focused self-review lenses first, then any --review-with agents as additional reviewers. /do:better//do:better-swift//do:simplify//do:depfree run the chosen reviewers as the post-PR loop — omitting --review-with skips the loop and the auto-merge. /do:rpr resolves existing review threads from any author, requesting a new one only if you name a reviewer; it accepts only --review-with/--reviewer-applies and drops @<login> entries with a notice.
By default /do:pr opens the PR and hands it back for manual merge. Pass --merge to merge automatically once both gates are green: the review loop returns a mergeable status and required CI checks pass.
/do:pr --merge # merge when green, repo's preferred merge method
/do:pr --merge=squash # merge + pin the method in one token
/do:pr --review-with codex --merge # external review first, then merge when green
/do:pr --no-merge # leave open, overriding a saved merge default
| Flag | Default | What it does |
|---|---|---|
--merge |
off — PR left open | After review and CI pass, merge the PR. Eligible only when the review aggregate is clean (or partial under an explicit stop-mode) |
--merge=<method> |
— | --merge plus pin the method: squash, rebase, or merge |
--merge-method <method> |
repo's allowed method | Pin the method without restating --merge. Unset: slashdo prefers squash, then merge, then rebase |
--no-merge |
— | Leave the PR open for this run, overriding a saved merge default |
It never merges on a non-clean review aggregate, before checks pass, or over branch protection. Save the behavior once with /do:config --merge — /do:pr defaults to leaving the PR open, /do:next defaults to merging its own claim's PR (--no-merge opts out). See docs/auto-merge.md for how CI-awaiting and the saved defaults interact per command.
slashdo tracks todo items in your project's issue tracker — GitHub or GitLab, auto-detected via an authenticated gh/glab (Enterprise/self-managed included); other trackers such as Jira are tracked in #372. /do:replan triages issues, /do:next claims them, /do:plan-task files them, and the audit commands file deferred findings as labeled issues. The stable item ID is the issue number (e.g. #42). Legacy PLAN.md? Run /do:replan once to migrate its items to labeled issues and retire the file.
/do:replan # triage the tracker (close done/stale, file new work)
/do:next # claim + ship the oldest eligible open issue
/do:next #42 # cherry-pick a specific issue
/do:next --swarm #12 #14 #15 # swarm exactly the issues you name
/do:next --collaborators --trusted-authors howlingmime,Joebok
/do:next --model light # only claim work hinted as cheap to run
| Flag | Default | What it does |
|---|---|---|
--issues-label <name> |
plan |
The label that scopes which issues are plan items |
--model <tier>[,…] |
off — any tier | (/do:next) Claim only issues hinted model:light/medium/heavy. none matches untiered issues |
--effort <level>[,…] |
off — any level | (/do:next) Claim only issues hinted effort:low/medium/high/xhigh/max. none matches unlabelled issues |
--self / --no-self |
off — any author | (/do:next) Claim only issues you filed (@me). Explicit #<num> for someone else is refused |
--collaborators / --no-collaborators |
off — any author | (/do:next) Claim only issues filed by a live repo collaborator, union --trusted-authors. Fail closed if that list can't be fetched |
--trusted-authors <list> |
empty | (/do:next) Extra logins unioned into the collaborators gate. No effect when --collaborators is off. none clears |
Claim only collaborator-authored issues (--collaborators) checks the live collaborator list from the host API, unioned with the Extra trusted authors list (--trusted-authors, e.g. howlingmime,Joebok). --self is the stricter @me-only variant.
/do:next is label-agnostic by default — --issues-label scopes the commands that file or triage plan items, but a bare /do:next claims the oldest open issue regardless of label. Pass --issues-label <name> (or save it) to restrict auto-pick to a curated queue.
Dispatch hints (model: + effort:) let issues carry a recommendation for how to run the work; /do:plan-task infers them, /do:next --model/--effort filter the queue, and --swarm[=N] dispatches each worker at its own issue's tier (default 3 agents, clamped 1..6) — name the issues yourself with --swarm #12 #14 #15. GitLab writes them as scoped labels (model::light, double-colon). See docs/work-tracking.md for the full rationale, the epic-aware claiming rule, and swarm's scheduling/wave behavior.
Rather than passing flags every time, save them once and let future commands pick them up automatically.
/do:config --review-with=claude,codex,cursor[gpt-5]~effort=max,opencode[provider/model],ollama[qwen2.5-coder:32b]
/do:config --review-models codex=o3,claude=opus,cursor=gpt-5,opencode=provider/model
/do:config --issues-label plan
/do:config --merge --merge-method squash
/do:config --self
/do:config --collaborators
/do:config --trusted-authors howlingmime,Joebok
/do:config # show what's saved and what's effective
| Usage | What it does |
|---|---|
/do:config (or --show) |
Print the current global + per-project defaults and the effective merged values |
/do:config --review-with=… [--review-iterations=N] [--review-mode=…] […] |
Save review-loop defaults (validated with the same rules the review commands use) |
/do:config --review-models <agent>=<model>,… |
Save the default model per reviewer. Merges key-by-key — setting one agent leaves the others intact; an empty value (codex=) clears one |
/do:config --issues-label=<name> |
Save the label that scopes which issues are plan items (default plan) |
/do:config --self|--no-self |
Save the self-only issue gate for /do:next |
/do:config --collaborators|--no-collaborators |
Save the collaborators-only issue gate for /do:next (union --trusted-authors) |
/do:config --trusted-authors <list> |
Save extra trusted authors unioned into the collaborators gate; none clears |
/do:config --merge|--no-merge [--merge-method=squash|rebase|merge] |
Save /do:pr's auto-merge default (and method) |
--project |
Read/write a per-repo .slashdo.json instead of the global config; per-project values override global ones key by key |
--unset <key> |
Clear one saved default |
--reset |
Clear all saved defaults in the chosen scope |
Precedence (highest first): explicit flag → per-project .slashdo.json → global ~/.claude/.slashdo-config.json → built-in default. --review-with none and the --no-* forms (--no-merge, --no-self, --no-collaborators) override a saved true for one run.
A typical split: personal preferences go global, repo policy goes in a committed .slashdo.json — /do:config --review-with=codex --merge everywhere, /do:config --project --collaborators --trusted-authors howlingmime,Joebok for one repo. See docs/config.md for how a project default masks an inherited global one.
slashdo runs on GitHub (cloud and Enterprise Server) and GitLab (cloud and self-managed). It auto-detects your code host from the origin remote, and the issue tracker defaults to that same host. Jira is also supported as a tracker (via an authenticated jira CLI) for every tracker-backed command — /do:next, /do:replan, /do:plan-task, /do:goals, and deferred-finding filing — while PRs/MRs stay on the code host. A remote slashdo cannot identify as GitHub or GitLab aborts with an "unsupported code host" error rather than guessing. Override the auto-detected host or tracker with /do:config --code-host github|gitlab or --tracker github|gitlab|jira — save globally or per-repo with --project. See /do:config for details and how to pass --jira-project when using Jira.
Note: some reviewers are host-scoped — copilot runs only on GitHub.
Each environment formats commands appropriately for its host assistant:
| Assistant / Environment | Invocation Syntax | Installed Path | Format |
|---|---|---|---|
| Claude Code | /do:<command> |
~/.claude/commands/do/ |
YAML frontmatter + subdirectories |
| Codex | $do-<command> |
~/.codex/skills/ |
SKILL.md per-command directories |
Antigravity CLI (agy/gemini) |
/do-<command> |
~/.gemini/antigravity-cli/skills/ |
Agent Skills (SKILL.md) |
| OpenCode | /do-<command> |
~/.config/opencode/commands/ |
YAML frontmatter + flat naming |
| Grok Build | /do-<command> |
~/.grok/skills/ |
SKILL.md per-command directories |
slashdo auto-detects which environments you have installed. Or specify manually:
npx slash-do@latest --env claude # just Claude Code
npx slash-do@latest --env opencode,antigravity # multiple environmentsnpx slash-do@latest # auto-detect + install all
npx slash-do@latest --env claude # target specific environment
npx slash-do@latest --list # show commands and install status
npx slash-do@latest --dry-run # preview changes
npx slash-do@latest --uninstall # remove installed commands
curl -fsSL https://github.com/raw/atomantic/slashdo/main/uninstall.sh | bash # curl uninstall
npx slash-do@latest push pr release # install specific commands onlyA filtered install also pulls in whatever it delegates to (prd → goals, pr-better → better + pr) so a wrapper never points at a missing command.
Source (commands/do/*.md)
|
v
+------------------+
| Transformer | Converts format per environment:
| | - YAML frontmatter (Claude, OpenCode)
+------------------+ - Agent Skills / SKILL.md + bundled lib/ (Antigravity, Codex, Grok Build)
|
v
+------------------+
| Installer | Diff-based: only writes changed files
| | Tracks version for update notifications
+------------------+
|
v
~/.claude/commands/do/push.md
~/.config/opencode/commands/do-push.md
~/.gemini/antigravity-cli/skills/do-push/SKILL.md
~/.codex/skills/do-push/SKILL.md
~/.grok/skills/do-push/SKILL.md
Integrating slashdo's commands into a host that isn't one of the five bundled environments? See Embedding command prompts in CONTRIBUTING.md for the renderer API.
On install, slashdo asks whether to auto-update (default: yes, Claude Code only). When enabled, the SessionStart hook checks npm for a newer version and installs that exact version (never the mutable @latest tag) with lifecycle scripts disabled. When disabled, or when npm isn't on PATH (the npm-free install.sh path), the statusline shows an update hint instead:
npx slash-do@latest # update from your terminal
npx slash-do@latest --auto-update # enable auto-update
npx slash-do@latest --no-auto-update # disable it/do:update # update from inside your AI coding assistant
The preference is stored in ~/.claude/.slashdo-config.json ({ "autoUpdate": true }).
Issues and PRs are welcome — see CONTRIBUTING.md for the project structure, local dev/test workflow, and PR conventions.
MIT