# Options, tools and generators

> When nobody has decided yet, get three real directions behind a picker; when prompting keeps missing, build the tool that makes the thing; when all you have is a vibe, build a generator.

Module: Directing your agent · Level: intermediate · 8 min · https://school.agents.org.in/foundations/agents/options-and-tools

You ask for a project card. You get one. You aren't sure it's right, so you ask for "a few more options". You get three cards that are the same card in three shades of grey.

That is not exploring. It is waiting.

*[Interactive demo: Three directions, one named axis each, the worst real content, a picker that is chrome. Try keys 1–3.]*

## Three directions behind a picker

When the decision hasn't been made, the fastest way to make it is to see the answers side by side, working. The skill calls this the prototype picker (Three to five genuinely different, working versions of one piece on a throwaway page, switched with a small dark pill. You pick; the decision gets written down; the page gets deleted), from Emil Kowalski's practice.

If you *have* decided, skip it. A picker holding three answers to a settled question wastes the run.

  **Step: Never touch production code.** The variants live on a throwaway page (`/proto/project-card`) that nothing imports.

  **Step: Real materials, worst content.** Your real fonts, tokens and components, filled with the content that breaks things: the longest real name, 1,284 members, the empty state. Pretty placeholders make every variant look fine.

  **Step: A named axis each.** Density, personality, layout, motion, interaction model. Name them "Quiet", "Editorial", "Dense", never "Option A". If you can't name the axis, it's one idea in three tints.

  **Step: Every variant fully works.** Real hover, real motion, real states. No "imagine this part".

  **Step: The picker is chrome.** A small dark pill at the bottom, never styled like your product. Number keys switch, `?v=2` in the address keeps the choice.

## Numbers go on sliders

Any number you would hardcode in a prototype is a decision not made yet. Duration, easing, blur, radius: put each on a slider, with a range wide enough to be wrong on both sides, and its value printed beside it.

Then the conversation changes. Instead of "a bit faster?", a teammate opens your link with `?v=2&dur=180` already in it and drags the slider themselves.

## The output is a decision

**The only thing that survives a prototype run is the decision, written down.** Including what you rejected and why, which is the part everyone skips and the part that saves the next meeting.

```md
Project card — decided from /proto/project-card
- Dense: density high; 13.5px name, 12px meta
- Rejected: Editorial (long names wrap to three lines); Quiet (fewer per screen)
```

Then the winner gets built properly and the prototype page is **deleted**. A picker that outlives the run is exactly the dead code rule one was there to prevent.

**Explore before deciding (paste into your agent):**

```text
I haven't decided how the empty inbox should look.
Build three directions on a throwaway route, each on a named axis.
Use our real components and the worst real content (long subject lines, 0 and 1 messages).
Put any timing or size on a slider. Add the dark picker pill, keys 1–3.
Then stop and let me pick. Don't choose a favourite.
```

## When prompting keeps missing: build a tool

Some things you can describe but can't get by asking: a chart's density, a shadow that has to match a reference, a texture that feels right. Each prompt lands "close". You rewrite. It lands close again.

That loop is a slot machine. The fix is to stop pulling the lever and build the small tool (When prompting for something keeps landing 'close but not quite', build the small tool that makes it instead, with every taste decision on a knob you adjust by eye) that makes the thing, with every judgment on a knob you turn by eye.

First, diagnose *why* prompting misses:

| The gap | The tool |
|---|---|
| A judgment only your eye can make (density, balance) | a dial-in tool: every taste value on a control |
| It must match something that exists | a matching tool: the target shown beside the output, at real size |
| Right pixels, wrong format | a converter |
| It can only be judged in a state that's slow to reach | a stage: a route that jumps straight to that state |

Then pitch it in four lines before any code: the gap, the tool, the controls, the export. That is the cheapest moment to be corrected.

> **Save writes a file.** The tool's save button writes the whole configuration as a file in the project, and the real artifact imports that file. Saving *is* shipping the decision.

The same move works for checking. If you keep checking one thing by hand (nested radii, the tab order), build a small inspector you can drop onto any page. A one-off check stays a checklist row.

*(After one round of "closer, but not quite", the diagnosis is done. Propose the tool.)*

## When all you have is a vibe: a generator

"Warm. Kind of old-timey. Hand-done." There is no target here, only a mood. Prompting for finished pictures will circle the nearest cliché forever.

The way out has two halves. **Research** turns the vibe into rules: what process made this look (a printing method, a tool, an era), what that process did to colour and texture, and what its recurring patterns are called. Compress that into 5 to 10 rules you can strike or keep *before* any code exists.

Then build a seeded generator (A small program that makes a picture from its settings plus a random seed, so one click gives a new variation and saving the settings lets you make the keeper again forever): the picture is a pure function of its settings, a click gives a new variation, every taste decision is a knob, and save writes the settings so the keeper can be made again forever.

**From a vibe to a generator (paste into your agent):**

```text
I want card backgrounds that feel like old risograph prints. I can't describe it better than that.
First research the process: what made that look, what it does to colour and texture, what the patterns are called.
Give me 5–10 rules as constraints and let me edit them.
Then build a seeded generator on a /lab route: click for a new seed, a knob for every taste value, save writes the JSON.
```

| You have | Reach for |
|---|---|
| A few nameable directions, undecided | the picker |
| A clear target the prompt keeps missing | a tool |
| Only a mood | research, then a generator |

**Check yourself:** You've rejected two rounds of prompted variants of the same illustration idea. What does the skill say to do next?

- [ ] Ask for a third round with more adjectives
- [x] Stop and propose research plus a seeded generator
- [ ] Pick the closest one and ship it
- [ ] Build a prototype picker with Option A, B and C

*Why:* Two rejected rounds means you are searching a space, not requesting an item. Research turns the vibe into rules, and a generator lets you search by clicking instead of prompting.

## In the skill

- https://school.agents.org.in/skill/meta/prototype-picker.md
- https://school.agents.org.in/skill/meta/build-a-tool.md
- https://school.agents.org.in/skill/meta/vibe-to-generator.md