> ## Documentation Index
> Fetch the complete documentation index at: https://www.minitap.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Skills

> Teach Mini the procedures that put your app in the state a scenario needs, like a test backend call or a debug menu, and link them to scenarios.

A skill is a procedure Mini reuses to reach a state your app's own screens can't give it: call your test backend, set a feature-flag cookie, get past a staging site's password, pay in a sandbox. You write it once in **Test suite → Skills**, and every scenario that needs it benefits. When the procedure changes, you fix it in one place.

```markdown theme={"theme":{"light":"github-light","dark":"vesper"}}
# What this sets up
Creates a test user with a funded wallet through the staging test backend.

Base URL: https://staging.example.com
Every call sends `Authorization: Bearer $SHOP_TEST_API_KEY`.

1. POST /test/users with {"balance": 100}. Keep the email and password it returns.
2. Sign in to the app with them.

If the call returns 409, the user already exists: reuse it.
```

Mini can use every skill on every scenario. It reads each skill's description, and loads the full instructions only when a scenario needs them. Link a skill to a scenario to have Mini load it before the scenario starts.

![Skills page with its explanation and example skills such as Log in with the emailed code and Reach checkout with one item in the cart, and a New skill button](https://mintcdn.com/minitap-30239763/QCLbAMcddko_3eZy/minitest/images/app/skills.png?fit=max\&auto=format\&n=QCLbAMcddko_3eZy\&q=85\&s=a66bc54a3e937b442db6e0aa41bc0681)

Test suite → Skills, with examples before your first skill.

## Skill, knowledge or criteria?

A skill **arranges** state. It never decides a verdict: Mini still checks the outcome in your app's screens. Write a skill when the know-how:

* acts on something outside the app under test, like an API, an admin console, a cookie, a deep link only test builds accept, or a device setting;
* is something only your team knows, like a magic sandbox value, a debug-menu path or how static OTP codes work on staging;
* is reused by several scenarios, or has gotchas a newcomer would miss, like ordering or error codes.

What the product is and how to get around it belongs in [Knowledge](https://www.minitap.ai/docs/minitest/setup/knowledge.md). What one scenario checks belongs in its [acceptance criteria](https://www.minitap.ai/docs/minitest/suite/anatomy.md#acceptance-criteria).

Write one skill per system or capability, like `shop-test-backend` or `shop-admin-console`, rather than one per scenario or per endpoint. Split a skill when its description can no longer say "Use when…" in one sentence.

## Create a skill

Go to **Test suite → Skills** and click **New skill**. Any member of your workspace can create and change skills.

| Field | What to put in it |
| - | - |
| **Name** | Lowercase and hyphens, up to 64 characters, ideally prefixed with your app or system: `shop-test-backend`. Linked scenarios follow a rename. |
| **When should Mini use this?** | One sentence starting with "Use when…" or "Use to…". Mini decides from this alone whether to load the skill, so name the situations, not the steps. |
| **Platforms** | **All**, or the platforms the procedure is for. Mini only loads the skill there. Restrict it only when the procedure really differs, like a deep link that exists on iOS only. |
| **Instructions** | Markdown Mini follows step by step: base URL, authentication, each call with its payload and what to keep from the response, how to hand the result to the app, known errors, cleanup. |

### Secrets in a skill

Never write a key, a password or a token in the instructions. Under **Secrets**, click **Add secret**, give it an `UPPER_SNAKE_CASE` **Name** and paste the **Value**. The value is encrypted, stored when you save the skill, and never shown again, even to you. In the instructions, write `$NAME`: Mini gets the value as an environment variable, never in its prompt.

The instructions list **Secrets the instructions read**, and flag a `$NAME` that no secret defines, or a secret the instructions never read.

On workspaces with a **Secrets** page, a skill can also use the app's own secrets: write `{{secret:NAME}}` and Mini sees only the name. See [Secrets and test files](https://www.minitap.ai/docs/minitest/setup/secrets-and-files.md#secrets).

## Link a skill to a scenario

Open the scenario, go to its **Setup** tab and click **+ Link skill** under **Skills**. Mini loads linked skills before the scenario starts, which suits a skill the scenario can't start without, like seeding the user it signs in as. Unlinked skills stay available: Mini loads them during the run when it decides it needs them.

## Versions, history and maintenance

Every change to a skill creates a new version. **History** lists every change: who made it, from where, and when. Entries can't be edited or deleted. **Restore…** on an earlier version creates a new one with that version's name, description, platforms and instructions. Secrets and scenario links aren't versioned and stay as they are.

When a setup step fails because the procedure drifted, like an endpoint that now asks for a new field, Mini doesn't edit the skill. It proposes the fix with its evidence, and the skill shows **Update proposed by maintenance**. Review it, then **Accept**, **Edit before accepting** or **Dismiss**. Only members of your workspace can accept or dismiss an update, and an update written against an older version can no longer be accepted.

## Delete a skill

Open the skill and click **Delete…**. If scenarios link it, the dialog lists them: without the skill, their setup may fail. Mini stops using the skill from the next run, any update waiting for review is discarded, and the skill's history stays readable.

## Skills from the CLI

The `app-skill` commands manage your app's skills. Don't mix them up with `minitest skill`, which prints the agent skill that teaches a coding agent to use the CLI.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
minitest --json --app <app_id> app-skill list
minitest --json --app <app_id> app-skill create shop-test-backend \
  --description "Use to create test users with a funded wallet." \
  --instructions-file ./shop-test-backend.md
printf '%s' "$KEY" | minitest --app <app_id> app-skill secret set shop-test-backend SHOP_TEST_API_KEY
minitest --json --app <app_id> scenario-binding set-app-skills <scenario_id> --skill shop-test-backend
```

| Task | Command |
| - | - |
| Read one | `app-skill get <name>` |
| Edit | `app-skill update <name> [--description …] [--instructions-file f.md] [--platform ios \| --all-platforms]` |
| See versions and changes | `app-skill history <name>` |
| Restore a version | `app-skill restore <name> --version 2` |
| Propose a fix for review | `app-skill propose <name> --reason "…" --instructions-file f.md` |
| List or remove secrets | `app-skill secret list <name>`, `app-skill secret unset <name> <SECRET_NAME>` |
| Delete, unlinking scenarios | `app-skill delete <name> --unlink-scenarios --yes` |

`secret set` reads the value from stdin, so it never lands in your shell history. `set-app-skills` replaces the scenario's whole set of linked skills, and `--clear` unlinks them all.

## Next steps

> [card] [Knowledge](https://www.minitap.ai/docs/minitest/setup/knowledge.md)
>
> What Mini knows about your product before it starts.

> [card] [Secrets and test files](https://www.minitap.ai/docs/minitest/setup/secrets-and-files.md)
>
> Values Mini types without seeing them, and files it uploads.

> [card] [What a scenario is](https://www.minitap.ai/docs/minitest/suite/anatomy.md)
>
> Criteria, tags, files, accounts and skills on one scenario.

> [card] [Mini maintains your suite](https://www.minitap.ai/docs/minitest/suite/mini-maintains-your-suite.md)
>
> How Mini keeps scenarios in step with your app.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.