Skip to content
Skills Library
AI & agents · Automation

phase-create

/phase-create

Use when the user (or the advisor) wants to design and register a NEW optional pipeline phase conversationally — "add a phase that does X". Interviews for goal-type, trigger signal, report sections, and verdict; synthesizes a phase.json + persona; registers them via `evolve phases create`; self-corrects from the command's JSON envelope. The Go binary is the single enforcement point, so this flow works from any LLM CLI.

Repository
evolve-loop ↗
Licence
Apache-2.0
Last repository change
27.10.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
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

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

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Use when the user (or the advisor) wants to design and register a NEW optional pipeline phase conversationally — "add a phase that does X". Interviews for goal-type, trigger signal, report sections, and verdict; synthesizes a phase.json + persona; registers them via `evolve phases create`; self-corrects from the command's JSON envelope. The Go binary is the single enforcement point, so this flow works from any LLM CLI.

Triggers from the description

add a phase that does X

Arguments

/phase-create <what the phase should do>
Original author description

Use when the user (or the advisor) wants to design and register a NEW optional pipeline phase conversationally — "add a phase that does X". Interviews for goal-type, trigger signal, report sections, and verdict; synthesizes a phase.json + persona; registers them via `evolve phases create`; self-corrects from the command's JSON envelope. The Go binary is the single enforcement point, so this flow works from any LLM CLI.

How it works

  1. What a phase IS here
  2. Stage 1 — Interview (one question at a time)
  3. Stage 2 — Synthesize
  4. Stage 3 — Register and self-correct
  5. Mint promotion
  6. Plugin distribution
Original SKILL.md headings · 98 lines, 630 words
SKILL.md preview
---
name: phase-create
description: Use when the user (or the advisor) wants to design and register a NEW optional pipeline phase conversationally — "add a phase that does X". Interviews for goal-type, trigger signal, report sections, and verdict; synthesizes a phase.json + persona; registers them via `evolve phases create`; self-corrects from the command's JSON envelope. The Go binary is the single enforcement point, so this flow works from any LLM CLI.
argument-hint: "<what the phase should do>"
---

# Phase Create — conversational phase registration (ADR-0038)

You turn a phase *idea* into a registered, advisor-selectable pipeline phase. All
validation, collision-checking, scaffolding, and index rebuilding live in
`evolve phases create` — your job is to design a good spec, call the command,
and self-correct from its JSON envelope. Never write `.evolve/phases/` or
`agents/` files directly; the command is the only sanctioned writer.

## What a phase IS here

A phase is pure declarative config: a `phase.json` descriptor (the contract)
plus a persona markdown (the prompt). No executable code. User phases are
always `optional:true`, `kind:"llm"`, and can never displace the
build→audit→ship spine — the same gates and policies apply to every phase.

## Stage 1 — Interview (one question at a time)

Establish, in order:

1. **Purpose** — one sentence: what does the phase produce? (becomes `description`)
2. **Archetype** — `plan` (decides/scopes before build) or `evaluate` (verifies
   after build). User phases are never `build`/`control`.
3. **Goal types** — which cycles is it for? `categories`: subset of
   bugfix | feature | refactor | security | performance | release | docs.
4. **Trigger** — the objective signal that should make the advisor SELECT it
   (becomes `when_to_use`, ≤140 chars, and ideally a `routing.insert_when`
   condition on a real signal like `scout.goal_type` or `build.diff_loc`).
5. **Report shape** — 2–3 required `## section` headings for its report
   (`classify.require_sections`); evaluate phases should opt into a verdict
   (`verdict_on_pass: "PASS"`) and, when they do, into the failure-signal
   contract (`require_failure_context: true`, ADR-0039): a FAIL/WARN verdict
   sentinel must then carry `failure: {class, defects[], evidence_paths[]}` —
   the contract gate teaches the exact line and re-dispatches on omission.
6. **writes_source?** — does it write files into the worktree? (true ⇒ sandbox
   role-gate; most evaluate phases are read-only.)
7. **Position** — `after` which phase? (empty = the pre-audit slot.)

Skip questions the user's request already answers. Check the existing catalog
first — `evolve phases list` (or `.evolve/phase-inventory.json`) — and tell the
user when an existing phase already covers the need (SELECT over MINT applies
to humans too).

## Stage 2 — Synthesize

Draft the `phase.json` (kebab-case name; `optional:true`; `kind:"llm"`; the
metadata trio `description` / `when_to_use` / `categories`; typed
`inputs`/`outputs` incl. signals; `classify`; `routing`; `after`) and a persona
markdown. Model the persona on `agents/evolve-bug-reproduction.md`: frontmatter
(name/description/model/tools/output-format), pipeline-position diagram,
numbered workflow, an **Output Contract** section naming the required headings,
and an anti-Goodhart note. Show both to the user for approval before
registering.

## Stage 3 — Register and self-correct

```bash
evolve phases create --spec - <<'SPEC'
{ ...the phase.json... }
SPEC
```

Pass the persona with `--persona <file>` (write it to a temp file first;
only one input may use stdin). The command prints ONE JSON envelope to stdout:

- `{"ok":true, "artifact":…, "required_sections":[…], "emits_verdict":…,
  "inventory_rebuilt":true}` — done. Report the derived contract to the user
  and note the advisor can SELECT the phase from the **next cycle start**.
- `{"ok":false, "errors":[…], "warnings":[…], "hint":…}` (exit 2) — fix every
  listed error in the spec and re-run. **At most 3 correction passes**; if
  still failing, show the user the errors verbatim and stop.

Treat `warnings` as advice worth fixing (unknown category, missing
require_sections) but not blockers.

## Mint promotion

To persist a good ephemeral mint from a routing plan, pass the mint JSON
(plus a `name`) instead of a spec:

```bash
evolve phases create --mint - <<'MINT'
{"name":"context-condense","prompt":"<persona>","tier":"balanced","writes_source":false}
MINT
```

The prompt becomes the persona body; tier becomes the model. Flesh out the
generated spec (categories, when_to_use, classify) afterwards via the normal
interview if the mint should become a first-class catalog citizen.

## Plugin distribution

A phase created here lands in `.evolve/phases/` (project-local). To ship
phases as a plugin bundle: put the same `<name>/phase.json` dirs in any
directory and add it to the colon-separated `paths.phase_roots` field in
`.evolve/policy.json`. Left-most root wins on name collision; built-ins always
win. Details: `docs/architecture/phase-plugin-system.md`.

Versions

The database has no other skills named phase-create.

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

Downloads in the last 30 days: 0 · ranking

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

Similar skills

  • 100setup
    Use when the user asks to configure evolve-loop, onboard, pick per-phase models, or learn how the pipeline works. Auto-detects available LLM CLIs/subscriptions, explains the pipeline concisely, then presents THREE ready-made config presets (Recommended/Economy/Max-quality) the…
  • 90plan-phase
    Plan the next unplanned phase in a task. Reads state.json to find the next not_started phase, then invokes Explorer to create a detailed implementation plan. Use when you need to create or revise a phase plan. Triggers on: '/plan-phase', 'plan the next phase', 'plan phase',…
  • 100create-skill
    **WORKFLOW SKILL** - Create and register a complete portable agent skill in a managed skills-repo.config.json repository or an existing skills repository. Produces focused instructions, documentation, deterministic tests, Vally evals, locked tooling, registration, and optional…
  • 100self-evolve
    Improve an existing skill or repository through isolated proposals, reproducible evaluation and evidence-based acceptance. Use for self-evolve or skill improvement.

Feedback and reports

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