# One command, many verbs

> Learn how /design-engineering reads its first word, what happens with no word at all, which aliases mean the same verb, and the short verbs that route a job and stop.

Module: The /design-engineering toolkit · Level: beginner · 8 min · https://school.agents.org.in/design/toolkit/meet-the-toolkit

Type `/design-engineering` into your agent and press Enter, with nothing after it. Nothing runs.

That's on purpose. Watch what it does instead.

*[Interactive demo: No verb, no guessing: a menu that leads with what fits, then a wait.]*

## One entry, one word

The skill has a single slash command (A command you type into an agent starting with /, like /design-engineering. It runs a skill or a built-in action instead of being read as a normal message). Everything else is the first word you type after it, the verb (The first word after /design-engineering, like review, polish or motion. It picks which procedure the skill follows), followed by a target: a file, a folder, a symptom in quotes.

```bash
/design-engineering review src/PricingCard.tsx
```

The skill reads that first word and looks it up in its dispatch table (The table at the top of the skill that maps each verb (and its aliases) to the file with its procedure. The skill reads your first word and looks it up there). If it's a verb, it opens that verb's command file (The written procedure behind one verb: its posture, what to read in order, the steps, what to return and where to hand off. Each one works on its own) and follows it exactly. Each command file is a whole procedure on its own: what to read, in what order, what to return, where to hand off.

> **In plain words.** Think of the verb as the name of a recipe. `review` is one recipe, `polish` another. The words after it are the ingredients: which file to work on.

## The four rules of dispatch

  **Step: A verb (or its alias).** Open its command file. The rest of your words are the target.

  **Step: A plain request.** "Why does this card feel flat" isn't a verb, so the router runs: it finds your design contract, works out the phase, and names one or two owners.

  **Step: No words, but a design request already in the chat.** Treat that request as the plain request.

  **Step: No words, no request.** Show the menu, lead with the 2–3 verbs that fit what's in front of it, and wait.

What "fits" means: a diff on your branch leads with `review`; a `.design` file leads with `tokens`; a video file leads with `film review`; launch week leads with `ship`. **A bare command never auto-runs a verb.** A wrong guess spends a whole pass, and surprises nobody wants.

If two verbs fit your words, it asks once. If none fits and the job isn't design (backend logic, data, build tooling), it says no skill applies.

## Which verb? Describe it

You don't need to memorise the table. Describe your situation in your own words and see which verb answers it.

*[Interactive demo: Your words in, the verb and its exact command out. Try the examples or type your own.]*

## Aliases: other names for the same verb

Most verbs answer to a second or third name, an alias (Another name the same verb answers to, like critique for review or launch for ship, so whichever word comes to you first works), so whatever word comes to you first works.

| Verb | Also answers to |
|---|---|
| `review` | `review-ui`, `critique` |
| `polish` | `finish` |
| `motion` | `motion-audit`, `animate` |
| `mobile` | `native-feel` |
| `break` | `worst-case`, `break-ui` |
| `tells` | `unslop`, `scan-ai-tells` |
| `a11y` | `accessibility` |
| `tokens` | `contract`, `apply-design-md` |
| `ship` | `prep`, `prod`, `launch` |
| `film` | `film-review`, `video` |
| `stage` | `faux-ui`, `demo`, `bento`, `product-shot` |
| `help` | `menu`, `?` |

## The short verbs

A handful of verbs are small: each hands the job to one owner and stops where that owner says stop.

| Verb | Does | Stops after |
|---|---|---|
| `options` | three to five real directions behind a picker | your pick |
| `name` | the precise word for a thing | one line, no code |
| `which` | who owns a job, and why | three lines; it doesn't do the job |
| `pick` | one maintained library for a task | one recommendation, or "a few lines of code would do" |
| `diagram` | whether to draw at all, and where | the figure or the canvas |
| `agentation` | the fix loop for browser annotations | one annotation at a time |
| `pov` | fork your taste file, or draft a gotcha | your yes, never an overwrite |

`options` has its own small modes once you've seen the first three:

  **Step: riff.** Three more directions near the one you liked.

  **Step: tune.** A control panel on the kept direction, and nothing else.

  **Step: mix.** Parts of the other variants carried onto your chosen base, as a list of portable features.

  **Step: keep.** Write the decision down, delete the harness, keep the worst-case data.

**Three small verbs (paste into your agent):**

```text
/design-engineering name "the menu grows out of the button that opened it"
/design-engineering which "a toast that screen readers never announce"
/design-engineering options riff
```

*(`pick` reads your package.json first. It never adds a rival to something you already have.)*

## Every verb keeps its posture

Each verb names a posture (Which of four jobs a request is: Build (make it), Judge (assess it, no edits), Decide (make a call first) or Name (give the word). It fixes the shape of the answer) and holds it. `review`, `tells` and `a11y` judge: they report and never edit unless you ask afterwards. `polish`, `mobile` and `ship` fix. `break` is an adversary that reports and *stops*. `name` answers and stops.

And every verb applies your two override files, gotchas and pov, plus your project's design contract, which outranks both.

**Check yourself:** You type /design-engineering with no words. You're on a branch with four changed files. What happens?

- [ ] It runs review on the branch automatically
- [x] It shows the menu, leads with review and one or two others, and waits
- [ ] It runs every verb in order
- [ ] It errors, because a verb is required

*Why:* A bare command never auto-runs anything. It shows the menu, leads with the verbs that fit what's in front of it (a diff suggests review), and waits for you.

## In the skill

- https://school.agents.org.in/skill/commands/MOC-commands.md
- https://school.agents.org.in/skill/commands/cmd-small.md