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

# Starter skills and the build

> The skills outerlayer init installs: templates your team edits, and maintained skills that follow the CLI. How to change the build and spec procedures for your repository.

`outerlayer init` installs two classes of skill. This page lists them and shows how to change what a build and a spec do in your repository.

| Class | Where it is | Who changes it |
| - | - | - |
| Template | `.agents/skills/` in the repository | Your team. The CLI never overwrites your edits. |
| Maintained | `~/.agents/skills/` on each machine | The CLI. Each skill follows the installed CLI version. |

The first line after a skill's frontmatter says which class the skill is.

`init` also writes a policy file and one starter check. See [Set up agent instructions and skills](https://docs.outerlayer.ai/agent-context.md#set-up).

## Templates

`init` copies each template once. If a template's folder already exists, `init` leaves it as it is.

* `build` holds your repository's changes to the build process. See [The build skill](#the-build-skill).
* `spec` holds your repository's settings and changes to the spec procedure. See [The spec skill](#the-spec-skill).
* `writing-specs` holds the discipline a spec follows.
* `writing-tests` holds the standard a test meets. Add your own test commands and rules to it.

To get the current CLI's version of a template you have not edited, run `outerlayer init --update`. See [Update the files init wrote](https://docs.outerlayer.ai/reference/cli-capture.md#update-the-files-init-wrote).

`.agents/skills/writing-specs/references/agents-snippet.md` holds optional writing rules for agents. `init` adds them nowhere. To hold every agent to them, paste the file's text into your root `AGENTS.md`.

## The build skill

Your `build` skill starts `outerlayer-build`, the maintained skill that holds the build process. It takes a work item through five phases: Intake, Criteria, Implement, Pull request and Evidence. At the start of each phase it reports the step on the item's Overview tab.

> [!WARNING]
>
> Commit `.agents/skills/build/`. A `.gitignore` rule such as `build/` also matches it. A runner then refuses the build with ``the build has no `build` skill``. `outerlayer doctor` names the rule.

In the Criteria phase, the build records the item's criteria. A list that the item already has stands, even when the issue's criteria differ. See [Record the criteria](https://docs.outerlayer.ai/attach-evidence.md#record-the-criteria).

A build does not review its own change. On a runner build, [the built-in code review](https://docs.outerlayer.ai/code-review.md) does that after the push. A build also does not wait for CI. See [When a GitHub check fails](https://docs.outerlayer.ai/automations.md#when-a-github-check-fails).

When a build changes a repository that has no `.outerlayer/setup.sh`, the build writes one and commits it in its pull request. See [Repositories with no script](https://docs.outerlayer.ai/build-setup.md#repositories-with-no-script).

### Change the build for your repository

Write each change in your `build` under `## Changes for this repository`. Put it under a `###` heading with the name of the phase it applies to. The starter `build` holds no change.

This example adds a step to one phase and sets one value:

```markdown theme={"system"}
## Changes for this repository

### Implement

Run `yarn db:migrate` before the first test run.

Use `yarn lint && yarn test` as the gate command.
```

A change can do three things:

* Add a step to a phase.
* Turn off a step that `outerlayer-build` marks optional.
* Set one of these values:

| Value | What it sets | Default |
| - | - | - |
| Gate command | The checks a build runs before every push. | The checks and tests your instructions name. |
| Planning model | The model for a planning step you add. | The model the session runs on. |
| Implementing model | The model that implements. | The model the session runs on. |
| Branch prefix | The prefix of the branch a local build creates. | `feat/` |
| Agent budget | The most agents one run may start. | 60 |

A change cannot loosen the build's fixed rules, such as reporting only observed status and filing no issues. When a change conflicts with `outerlayer-build`, `outerlayer-build` wins.

The build has no Review phase, so it does not apply a change listed under Review. The build's final report lists the changes it applied, each conflict, and each change it did not apply.

## The spec skill

Your `spec` skill starts `outerlayer-spec`, the maintained skill that holds the spec procedure. [Write a spec with /spec](https://docs.outerlayer.ai/write-a-spec.md) describes each step.

Your `spec` holds two sections. `## Settings` sets the values below. `## Changes for this repository` lists your changes, each under a `###` heading with the name of the step it applies to.

The steps are Scope, Draft, Verdict, Size, Reader pass, Checkpoint, File and Build.

| Setting | What it sets | Default |
| - | - | - |
| Repository | The repository an issue is filed in. | `/spec` asks when the target lists more than one. |
| Criterion id | The form of a criterion's id. | Any stable id you choose. |
| Criteria cap | The most criteria one spec holds. | 24 |
| Reader pass model | The model the reader pass agent runs on. | The model the session runs on. |
| Build options | The answers the Build step offers. | On a host, yourself, or not yet. |

A change can add work to a step, set a setting, or turn off the Size step. A change cannot loosen a rule of `outerlayer-spec`. When the two conflict, `outerlayer-spec` wins, and `/spec` names the conflict before you approve.

### A spec skill that holds the whole procedure

A `spec` that does not name `outerlayer-spec` holds its own copy of the procedure. It keeps working, but it gets no changes to the procedure. `outerlayer doctor` warns, and prints the short `spec` to start from.

| Your `spec` | What to do |
| - | - |
| You never edited it | Run `outerlayer init --update`, then commit. The CLI replaces the file with the short `spec`. |
| You edited it | Start from the short `spec` that `doctor` prints. Move each edit under the step it applies to. |

Before you commit the short `spec`, upgrade the CLI on every machine. Each person then runs `outerlayer init --local` once, which installs `outerlayer-spec`.

## Maintained skills

The CLI keeps the maintained skills once per machine, in `~/.agents/skills/`, with a link to each in `~/.claude/skills/`. A repository carries none of them. Two teammates on different CLI versions each get the skills that match their own CLI.

* `outerlayer-build` holds the build process, which `build` tells the agent to follow.
* `outerlayer-spec` holds the spec procedure, which `spec` tells the agent to follow.
* `outerlayer-evidence` says when and how to attach proof to a change.
* `outerlayer-amend` answers the review threads waiting on an agent, resolves merge conflicts and fixes failed GitHub checks on a pull request.
* `outerlayer-findings` says when and how to record a problem an agent hit in the factory.
* `outerlayer-cli` says what a work item is, and how an issue becomes a pull request.
* `outerlayer-run` does one run of a schedule automation. It reads the repository and reports what it finds. It never changes code.
* `outerlayer-revise` revises the text of a draft spec that a member sent to an agent. It never changes code.
* `outerlayer-review` reviews one commit of a work item's pull request and reports each problem that must be fixed. It never changes code.

`outerlayer init`, `outerlayer init --local` and `outerlayer claude` write any maintained skill that is missing. Every other `outerlayer` command updates the ones already there to its own version.

Do not edit a maintained skill. The next `outerlayer` command overwrites your edit. You cannot turn one off: `outerlayer claude` restores a folder you delete.

A cloud session on a machine with no CLI gets no maintained skills.

## Check the skills

Run `outerlayer doctor`. It checks your `build` and `spec` skills, the maintained skills on the machine, and `.gitignore` rules that match a skill folder. It prints the fix for each problem. [Setup and doctor commands](https://docs.outerlayer.ai/reference/cli-capture.md#outerlayer-doctor) lists every check.

## Next steps

[Policy and validators](https://docs.outerlayer.ai/policy-and-validators.md) sets which checks a pull request must pass.


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