Skip to content
Skills Library
DevOps & cloud · Automation

wizard

/wizard

Use when a procedure has steps only a human can take: clicking through a third-party dashboard, provisioning a domain or DNS record, generating an API key, setting a CI secret, or running a one-off cutover. Reach for it mid-task too, the moment you hit a step you cannot pass yourself: a login wall, a two-factor prompt, a dashboard with no API. Generates an interactive bash script that opens each URL, says what to click, captures each value, writes it into .env and GitHub secrets, confirms before anything irreversible, and shows how many stages are left. Triggers on: 'walk me through setting up

Licence
MIT
Last repository change
26.09.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
3
Scripts
1
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 26.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 1 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/template.sh

What it does and when to use it

Use when a procedure has steps only a human can take: clicking through a third-party dashboard, provisioning a domain or DNS record, generating an API key, setting a CI secret, or running a one-off cutover. Reach for it mid-task too, the moment you hit a step you cannot pass yourself: a login wall, a two-factor prompt, a dashboard with no API. Generates an interactive bash script that opens each URL, says what to click, captures each value, writes it into .env and GitHub secrets, confirms before anything irreversible, and shows how many stages are left. Triggers on: 'walk me through setting up

Arguments

/wizard [the procedure] [--commit]
Original author description

Use when a procedure has steps only a human can take: clicking through a third-party dashboard, provisioning a domain or DNS record, generating an API key, setting a CI secret, or running a one-off cutover. Reach for it mid-task too, the moment you hit a step you cannot pass yourself: a login wall, a two-factor prompt, a dashboard with no API. Generates an interactive bash script that opens each URL, says what to click, captures each value, writes it into .env and GitHub secrets, confirms before anything irreversible, and shows how many stages are left. Triggers on: 'walk me through setting up

How it works

  1. The library is not yours to edit
  2. Step 1: Scope it from the repo, not from the user
  3. Step 2: Trace each stage to a real path
  4. Step 3: Author the stages
  5. Step 4: Verify statically, then hand off
  6. Step 5: If it was a credential, deposit it where it will be found again
  7. Invariants
Original SKILL.md headings · 143 lines, 1,240 words
SKILL.md preview
---
name: wizard
description: "Use when a procedure has steps only a human can take: clicking through a third-party dashboard, provisioning a domain or DNS record, generating an API key, setting a CI secret, or running a one-off cutover. Reach for it mid-task too, the moment you hit a step you cannot pass yourself: a login wall, a two-factor prompt, a dashboard with no API. Generates an interactive bash script that opens each URL, says what to click, captures each value, writes it into .env and GitHub secrets, confirms before anything irreversible, and shows how many stages are left. Triggers on: 'walk me through setting up', 'I need to configure X in the dashboard', 'set up the credentials for', 'script the DNS steps', 'a checklist I can run', 'make this setup repeatable'. Not for steps the agent can perform itself, which it should just perform, and not for investigating what a service needs (use groundwork)."
argument-hint: "[the procedure] [--commit]"
user-invocable: true
license: MIT
---

# wizard: a script for the steps only a person can take

Some procedures cannot be automated because the blocker is not capability, it is a browser
session, a two-factor prompt, or a dashboard nobody has an API for. Those steps get done by
hand, badly, at intervals long enough that the person has forgotten them, and re-explained to
an agent every single time.

A **wizard** is a bash script that walks the human through exactly those steps: one screen at a
time, opening each URL, saying what to click, capturing what comes back, and writing it where
it belongs. The knowledge stops living in a chat log.

**Do not generate one for work you can do yourself.** An agent that writes a wizard for
something it could have run is handing the user a chore. The test is whether a human is
genuinely in the loop.

## The library is not yours to edit

`scripts/template.sh` already solves the part that is tedious and easy to get wrong: stage
progress, confirmation gates, cross-platform URL opening including WSL, hidden entry for
secrets, idempotent `.env` upserts, `gh secret` and `gh variable` writes, and a closing summary.

Everything above the `# ---- STAGES ----` marker is identical in every wizard. That sameness is
the point: a reviewer reads the stages and trusts the rest. **Never hand-edit the library.**
Your job is to scope the procedure and author its stages.

## Step 1: Scope it from the repo, not from the user

Read before you ask. Asking a user to list their own setup steps produces the steps they
remember, which are the ones they did not need a wizard for.

- **For setup**: `.env`, `.env.example`, `.env.*`, the README, `docker-compose*`, framework
  config, and `.github/workflows/*`. Every `secrets.*` and `vars.*` reference in a workflow is
  a value this wizard has to produce.
- **For a migration or cutover**: the current state, the target state, and every irreversible
  action between them. The irreversible ones decide where the confirmation gates go.
- **In this fleet specifically**: `docs/operations/publishing.md` is the canonical ordering for
  a repo, Pages, and DNS publish, and `tooling/dns/` holds the Namecheap records. A wizard for
  publishing follows that runbook rather than a remembered command.

Then show the user the ordered stages and the value each produces, and let them add, drop, or
reorder before you write a line.

**Done when** every stage is named in order, and for each captured value you know where the
human gets it, where it is written (`.env`, a GitHub secret, both, or nowhere), and whether it
is secret.

## Step 2: Trace each stage to a real path

Write the exact journey: which URL, what to do there, where the value is shown, which variable
it fills. "Dashboard, then Developers, then API keys, then Reveal test key, then copy."

Where you do not know the current UI, **say so and check**. An invented menu path is worse than
no wizard: the user follows it, does not find the button, and now distrusts every other stage.
`groundwork` is the skill for finding out what a service actually requires, and its dated
requirements doc is the right input to this step.

**Done when** every stage traces to instructions a stranger could follow.

## Step 3: Author the stages

Copy the template, replace the example stage with one `stage` per step in dependency order, and
set `TOTAL_STAGES`.

```bash
cp "$FORGE/skills/wizard/scripts/template.sh" scripts/setup-<thing>.sh
```

Helpers, and the bar each one sets:

| Helper | Use it for | The rule |
|---|---|---|
| `stage "<title>"` | Each step | Clears the screen. One focused task per stage, so nothing scrolls away |
| `say` / `step` | Instructions | The literal click path, not a summary of it |
| `open_url <url>` | Every URL | Open it **before** asking for the value it produces |
| `ask` / `ask_secret` | Capturing input | `ask_secret` for anything that must not land in scrollback |
| `write_env K V` | Persisting | Every value the project needs at runtime |
| `set_secret` / `set_var` | CI | Only the values CI actually reads |
| `confirm "<what>"` | Before irreversible actions | Deleting, cutting over, publishing, spending money |

## Step 4: Verify statically, then hand off

**Do not run it end to end.** It opens browsers and blocks on human input; an agent driving it
either hangs or answers the prompts itself, which proves nothing.

```bash
bash -n scripts/setup-<thing>.sh && shellcheck scripts/setup-<thing>.sh
chmod +x scripts/setup-<thing>.sh
```

Then trace it on paper: every value from step 1 is captured, lands where step 1 said it would,
and every `set_secret` name matches a `secrets.*` reference in CI **exactly**. A near-miss on a
secret name is the defect this check exists for, because CI reports it as an empty string
rather than an error.

A wizard is **ephemeral by default**: built for one run, written to `scripts/`, deleted when
the job is done. Commit it only when the procedure recurs, and then link it from the README so
the next person runs the script instead of asking an agent.

## Step 5: If it was a credential, deposit it where it will be found again

A wizard that walks someone through minting an API key, an OAuth session, an SSH key or an IP
whitelist has just produced the only thing anyone will want the next time it expires: the real
steps, the trap that cost you twenty minutes, and how to tell it worked. That knowledge dies in
the script unless it is deposited.

The fleet has a home for it, `echeance-site`, which tracks credential expiry and feeds
`llms.txt` so a future agent session reads it too:

```bash
python3 ./scripts/add-tutorial.py entry.json --check   # from projects/echeance-site
python3 ./scripts/add-tutorial.py entry.json
make llms
```

The entry is one JSON object: `id`, `title`, `service`, `applies_to` (`api-key`,
`oauth-session`, `ssh-key`, `ip-whitelist`), `signals`, `steps`, `verify`, `revoke`, `insights`,
and optional `links`. The writer refuses a duplicate id, a missing field, and, because the file
is published, anything shaped like a token, an IP address or an email address.

Two rules that decide whether the deposit is worth making:

- **Only steps you actually walked.** A stage the person completed in front of you is a step. A
  stage you inferred from a vendor page is not, and belongs in `insights` as what the docs
  claim, or nowhere.
- **`insights` is where the value is.** The steps are re-derivable from the dashboard; the trap
  is not. "Create the replacement before revoking the old one" is worth more than the click
  path, and it is the line nobody writes down.

Skip this entirely when the wizard was not about a credential. Most are not.

## Invariants

- **Never generate a wizard for work the agent can do.** A human in the loop is the entry
  condition, not a style choice.
- **Never edit the library above the marker.** Stages are yours; the machinery is not.
- **Open the URL before asking for its value.** The other order makes the user hunt.
- **`confirm` before anything irreversible**, and name what is about to happen in the prompt.
- **Never invent a menu path.** Check it, or ask, or say the step is unverified in the script
  itself.
- **A credential procedure ends in `echeance-site`, not only in the script.** The trap you
  hit is the part nobody writes down, and it is the part the next expiry needs.
Files in this package (3)
  • SKILL.md 8 KB
  • agents/openai.yaml 1 KB
  • scripts/template.sh 7 KB

Versions

RepositoryScoreLicence
This page · lucianoadonis/neorgon-forge100MIT
omriariav/amq-squad100MIT
JamalLyons/Agent-Skills100MIT
akillness/jeo-skills100MIT
zenobi-us/dotfiles100MIT
niekcandaele/claude-helpers100MIT
ctxpipe-ai/ctxpipe100MIT
mattpocock/skills100MIT
Pluneto/skills100MIT

Database snapshot: 13.11.2026 · package version fcd94bc88881 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 2 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100human-step-wizard
    Generate an interactive, resumable bash wizard that walks a person through steps only a human can do. Use when a task needs dashboard credentials, DNS or change approval, key rotation, or a manual traffic cutover.
  • 100manual-steps
    Generate an interactive bash wizard that walks a human through steps only they can perform. Use when provisioning infrastructure, setting up credentials or CI secrets, walking an unfamiliar third-party dashboard, or running a one-off migration or cutover. Don't invoke this for…
  • 100mig-my-turn
    Walk the developer through steps only they can run, such as a server, a dashboard, DNS or a secret, one step at a time, naming the machine for each command. Use when a task needs access the agent lacks, for a manual deploy, a cutover or go-live, production checks, or for /mig-my-turn.
  • 100setup-wizard-script
    Use when setup or migration needs human steps in dashboards or browsers: generate a bash wizard that walks each stage, hides secret entry, writes .env and Gitea or GitHub CI secrets.
  • 100setup-wizard
    Write an interactive shell script that walks a person through manual steps only they can do, such as creating accounts, copying credentials or setting CI secrets. The script opens each page, says what to click, and saves the pasted values. Not the h2xd repo setup. Use when a…
  • 100walk-me-through
    Use when a step truly needs a human: credentials, dashboards, provisioning, one-off cutovers. Never for what an agent can do. Show the script before anyone runs it.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.