Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

plan

/plan

Zamienia zatwierdzoną specyfikację w plan zadań z dokładnymi ścieżkami i sprawdzalną weryfikacją, zanim zacznie się implementacja, bez pisania kodu.

Repozytorium
vibekit ↗
Licencja
MIT
Ostatnia zmiana repozytorium
27.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Zamienia zatwierdzoną specyfikację w plan zadań z dokładnymi ścieżkami i sprawdzalną weryfikacją, zanim zacznie się implementacja, bez pisania kodu.

Oryginalny opis (EN)

Use when a spec is approved and implementation has not started: turns it into a task-by-task plan with exact paths and checkable verification. No code here.

Jak działa

  1. HARD-GATE
  2. The spec is settled
  3. Refusals
  4. Plan document
  5. Task shape
  6. You may not write a value you have not observed
  7. No placeholders
  8. Self-review
  9. User review gate
  10. Handoff
Sekcje z nagłówków SKILL.md, w oryginale · 105 linii, 974 słów
Podgląd SKILL.md
---
name: plan
description: "Use when a spec is approved and implementation has not started: turns it into a task-by-task plan with exact paths and checkable verification. No code here."
trigger: Spec approved, implementation not yet started
gate: hard
---

# plan

Turn an approved spec into an implementation plan. No code is written here.

## HARD-GATE

Do NOT implement anything until a plan file exists and the user has approved it.

The gate has one precondition, and it is checkable rather than asserted: a spec file exists carrying `status: approved` in its frontmatter. If there is none, stop and invoke `brainstorm`. A plan built on a draft is a plan built on something the user may still change.

## The spec is settled

Read it, do not re-litigate it. Questions it already answered are not asked again. A defect found in it goes back to the user as a question: never a silent edit, because the approved artefact is what the user signed.

## Refusals

- **Spec spans independent subsystems.** Say so before writing any task. One plan per subsystem, each producing working software on its own.
- **A requirement has no possible verify clause.** Not a licence to write a weak one. Either the task boundary is wrong and splits, or the requirement is unobservable and goes back to the user as a question.

## Plan document

Write to `docs/plans/YYYY-MM-DD-<topic>.md`, then commit: that file alone.

```
# <topic>: Implementation Plan

**Spec:** docs/specs/<file>.md
**Goal:** one sentence
**Architecture:** two or three sentences

## Global constraints
- <one line each, values copied verbatim from the spec>
```

Global constraints are the spec's project-wide requirements: version floors, dependency limits, naming rules. Stated once, they are implicitly part of every task, so no task restates them and no task author has to remember them.

## Task shape

```
### Task N: <name> → verify: <predicate>

**Files:**
- Create: `exact/path`
- Modify: `exact/path:12-40`

- [ ] Step 1: <one action>
- [ ] Step 2: Run `<command>`
- [ ] Step N: Commit

```

A task is the smallest unit worth a fresh reviewer's gate. Fold setup, config and documentation into the task whose deliverable needs them. Split only where a reviewer could reject one task while approving its neighbour. Each task ends with an independently testable deliverable and one commit.

Steps that change code carry the actual code. A step that runs a command names the command and stops there.

## You may not write a value you have not observed

Every value this plan states, a number, a path, a count, a cross-reference, must be one you observed. You read it, you ran it, or you chose it as a threshold. A value you recalled is a guess, and a guess in a plan is a defect a fresh implementer pays for: they follow the plan exactly, hit a contradiction, and stop.

Two ways to satisfy it. Derive the value before writing it, usually one command and a few seconds. Or state the property instead of the value: "every new case passes" rather than "three cases pass".

**A clause is the strictest case.** A `→ verify:` clause states a predicate: something checkable by a reader of the plan, before anything runs. Not a transcript.

**Predicates:** exit status, pass or fail, a file exists, a match count at or above a threshold, an HTTP status.

**Not predicates:** a quoted message, a specific count, a diff, a sample of output. Each is a claim about a future you have not seen. When one is wrong, the executing agent cannot tell whether the code failed or the plan lied, and it will assume the code.

A number is not itself the tell. Three forms carry one legitimately: an exit status, an HTTP status, and a threshold in either direction (at least 1 match, under 120 lines). Any other number in a clause is a predicted value. A threshold is derivable because you chose it. A predicted value is not, because the runtime chooses it.

Spelling a number out does not launder it. "The four cases pass" is a count, and the first plan written under this rule got that count wrong.

Naming your command in a code span is not quoting. Backticks delimit what to run. Straight quotes are how a predicted transcript gets in.

If a specific value is genuinely load-bearing, the task's first step **observes it**, and the clause refers to the observation instead of a guess.

A clause must be satisfiable by the task it belongs to. If you cannot say what would make it true, the task boundary is wrong, not the clause.

**Outside a clause the rule still holds, and there is no allowlist.** A line count in a task title, a path in a Files block, a version in Global constraints, a reference to another task by number: each is a value, so each was read, run, or chosen. None may be recalled.

## No placeholders

`TBD`, `TODO`, "add error handling", "similar to Task N", and any reference to a function no task defines are plan failures, not shorthand. Repeat the code: tasks get read out of order.

## Self-review

1. **Spec coverage.** Every requirement maps to a task. Add any that is missing.
2. **Placeholders.** Scan for the patterns above. Fix them.
3. **Clauses.** Scan every `→ verify:` for a quoted string, or a number outside the three permitted forms. Both are predicted output. Fix them.
4. **Provenance.** For every number, path, count and cross-reference in the plan, name where it came from. "I ran it" and "I read it" pass. "I knew it" is a guess: derive it, or state a property instead.

Fix inline. No re-review.

## User review gate

Send exactly this, verbatim:

> Plan written and committed to `<path>`. Please review it and let me know if you want to make any changes before we start implementing.

Wait. On requested changes, make them and re-run self-review.

## Handoff

The only next skill is `exec`, once the user has approved the plan. Never invoke an implementation skill from here.

Wersje

RepozytoriumWynikLicencja
Ta strona · rizukirr/vibekit100MIT
mlophez/polix-ai100Apache-2.0
jeremylongshore/tons-of-skills-marketplace100MIT
duronext/jig100MIT
rjmurillo/ai-agents100MIT
rjmurillo/ai-agents100MIT
rjmurillo/ai-agents100MIT
xoai/sage100MIT
JoDi-27/JoDi-SDD100MIT

Migawka bazy z 13.11.2026 · wersja paczki 518dd1afac0c (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100writing-plans
    Tworzy plan wdrożenia wieloetapowego zadania z małymi zadaniami i dokładnymi ścieżkami plików, zanim zacznie się praca nad kodem.
  • 100plan-work
    Zamienia zatwierdzoną specyfikację w plan oparty na prawdziwym kodzie, z projektem, maszynami stanów i sprawdzalnymi plasterkami, bez pisania kodu.
  • 100write-plan
    Zamienia zatwierdzoną specyfikację brainstorm-beagle w plan wdrożenia z krokami TDD po 2 do 5 minut, dokładnymi ścieżkami i poleceniami, przed napisaniem kodu.
  • 84writing-plans
    Tworzy szczegółowy plan implementacji wieloetapowego zadania z małymi krokami, dokładnymi ścieżkami plików i przykładami kodu.
  • 100writing-plans
    Tworzy plan wdrożenia wieloetapowego zadania z małymi zadaniami, dokładnymi ścieżkami plików i kompletnymi przykładami kodu.
  • 100blueprinting
    Rozbija wybrane podejście na szczegółowy plan implementacji z drobnymi zadaniami, dokładnymi ścieżkami i krokami weryfikacji, zanim zacznie się kodowanie.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.