Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

task-spec

/task-spec

Zamienia opis zadania w plik specyfikacji, dzieli go na numerowane części i pyta o luki, zapisując odpowiedzi przy właściwych częściach.

Licencja
MIT
Ostatnia zmiana repozytorium
02.11.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 02.11.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 opis zadania w plik specyfikacji, dzieli go na numerowane części i pyta o luki, zapisując odpowiedzi przy właściwych częściach.

Wyzwalacze z opisu

put this in the tasksnew taskadd this taskput it in tasksthe requirement changed
Oryginalny opis (EN)

Turn a task description into the spec file for it under context/tasks/. Breaks the description into numbered parts, asks about the gaps instead of guessing, and records each answer as a note on the part it belongs to. Use when the user hands over a new task, a requirement, a ticket or a feature description, when they say "put this in the tasks", or when a requirement on an existing task changes. Triggers on "/task-spec", "new task", "add this task", "put it in tasks", "the requirement changed".

Jak działa

  1. 1. Find the file
  2. 2. Divide the description into parts
  3. 3. Ask about the gaps — do not guess
  4. 4. Write the file
  5. 5. Log it, then show it
  6. When the requirement changes later
Sekcje z nagłówków SKILL.md, w oryginale · 261 linii, 1 737 słów
Podgląd SKILL.md
---
name: task-spec
description: >
  Turn a task description into the spec file for it under context/tasks/. Breaks
  the description into numbered parts, asks about the gaps instead of guessing,
  and records each answer as a note on the part it belongs to. Use when the user
  hands over a new task, a requirement, a ticket or a feature description, when
  they say "put this in the tasks", or when a requirement on an existing task
  changes. Triggers on "/task-spec", "new task", "add this task", "put it in
  tasks", "the requirement changed".
---

# Task spec

Write the task down before writing any code. The file is the spec; the code follows it.

This skill **only writes the spec**. It does not implement, does not touch `app/`, does
not run migrations. If the user wants both, write the spec, show it, and let them say go.

---

## 1. Find the file

```bash
ls context/tasks/ 2>/dev/null || echo "(no tasks folder yet)"
```

Name the file by **subject**, kebab-case, never by number: `innovation-publish.md`,
`proposal-status.md`. `task1.md` tells a reader nothing in a month.

- **A file already covers this subject** — update that file. Do not create a second one.
  Changing a requirement means editing the part it belongs to, in place.
- **Nothing covers it** — create it.
- **Unsure whether it is the same subject** — ask. Two half-specs on one subject is worse
  than one long file.

If `context/tasks/` does not exist, create it. It lives inside `context/`, which is
gitignored, so nothing here reaches a commit or a PR.

### Inspect the existing implementation

Before dividing the requirements or asking questions, inspect the relevant existing code.

- Identify the affected models, schemas, endpoints, hooks, services, database constraints,
  and tests.
- Understand the current behavior without assuming it is the desired behavior.
- Use the actual implementation to answer questions that the code can settle.
- Identify technical claims that need verification.
- Do not modify application code or run migrations during this step.

Read the `context/` files that bear on the task as well — `api-contract.md`, `database.md`
and `decisions.md` — and treat a contradiction between them and the code as something to
report, not to silently resolve.

---

## 2. Divide the description into parts

Read the whole description first. Then split the **requirement** into numbered parts.

A part is one rule that can be true or false on its own, and that someone could verify by
itself. Split on behaviour, not on grammar:

> "published_at is filled only if available_on_network is true, else null, and the same
> for approved_at with the status"

is **two** parts, not one — they are two columns driven by two different conditions, and
either can be right while the other is wrong.

Rules for splitting:

- One rule per part. If a part needs the word "and" to join two behaviours, split it.
- Keep the user's own wording where it is already precise. Do not restate it in your own
  words to sound tidier — their phrasing is the requirement.
- A part that is an example, not a rule, goes under the rule it illustrates.
- Do not invent parts the user did not ask for. If you think one is missing, that is a
  question for step 3, not a part to add.

---

## 3. Ask about the gaps — do not guess

For each part, ask yourself what a developer would have to decide that the description
does not say. Only the ones that **change the work** become questions.

Ask with AskUserQuestion, batched — at most 4 at a time, and fewer is better. Each
question needs real options, not "what do you want".

Things that are almost always worth asking:

| Gap | Why it matters |
|---|---|
| What happens on the **reverse** transition | "set X when Y is true" rarely says what happens when Y goes false |
| **Repeat** of the same action | does the second call overwrite, hold, or refuse |
| Who may do it | an endpoint with no guard is a different task |
| The **error** a refusal gives | a status code is part of the contract |
| Existing rows | a new required field needs a backfill answer |
| Which layer owns it | a rule can sit in the schema, a hook, a route or a constraint, and the choice is the design |

Things **not** worth asking: anything with an obvious default, anything the codebase
already answers, and anything you can look up. Look first, ask second.

Record every answer as a note on the part it belongs to:

```markdown
2. `approved_at` holds a date only while `status` is `APPROVED`.
   **Note (2026-10-27):** on any other status the date is wiped, not kept. The column
   holds the current state, not a history. Asked and confirmed.
```

Date the note and say it was confirmed, so a later reader knows it is a decision and not
your assumption.

**A gap the user does not answer stays open.** Write `_Not yet defined._` under that part.
Never fill it with a guess that reads like a requirement.

### Classify unanswered questions

Classify each unresolved question:

- **Blocking:** The answer changes the required behavior or implementation and must be
  resolved before implementation.
- **Non-blocking:** The answer can be deferred without affecting the currently agreed
  scope.

Do not invent answers to blocking questions.

Record unresolved questions in the specification with their classification.

### Define acceptance criteria

For each requirement, define observable acceptance criteria before implementation.

Acceptance criteria must describe how to verify the expected behavior, including relevant:

- Successful operations.
- Invalid operations and expected errors.
- Reverse transitions.
- Repeated operations.
- Database state and API response consistency.

Do not invent behavior while writing acceptance criteria. Ask the user when a decision is
missing.

Acceptance criteria describe what must be tested. They are not evidence that testing has
passed.

Only record actual executed results in the `Verified` section.

---

## 4. Write the file

Use the following six sections, in this order. Keep them in this shape so every task file
reads the same:

```markdown
# <Subject>

<One line: what this task is for, in the user's terms.>

## Current requirement

1. <part>
2. <part>
   **Note (<date>):** <answer to a question that was asked>
3. <part>
   _Not yet defined._

## Open questions

- **Blocking** — <question>. Blocks part <n>.
- **Non-blocking** — <question>. Does not affect the agreed scope.

## Acceptance criteria

| # | Part | Given / When | Expected |
|---|---|---|---|
| 1 | <n> | <the call, and the state it starts from> | <status code, response field, row state> |

## Where it lives

| Thing | Where |
|---|---|
| <route / rule / column / migration> | <file, or symbol> |

## Not done

- <what is deliberately out of scope, and what it blocks>

## Verified

_Not yet implemented._
```

Notes on each section:

- **Current requirement** holds only what must be true **now**. Not history, not how it
  got here. If a requirement changes, edit the part; the change log records the change.
- **Open questions** carries every unresolved one with its classification, and names the
  part it blocks. An empty section is written as `_None._`, not deleted — a reader has to
  be able to tell "nothing open" from "nobody asked".
- **Acceptance criteria** says how each part will be checked, written before the code.
  Each row names the part it covers, so a part with no row is a part nobody planned to
  verify. These are intentions. They are **not** results.
- **Where it lives** identifies existing code confirmed by inspection, and the expected
  changes. Record actual file paths and symbols where known. Clearly distinguish verified
  existing locations from proposed changes. Update this section during implementation if
  the actual changes differ.
- **Not done** is for what is out of scope on purpose. Name what it blocks — "no approve
  route, so `approved_at` is unreachable over HTTP" is useful; "TODO: approve" is not.
- **Verified** is for measurements, with dates, and only after the thing has been run.
  Never pre-fill it. "Should work" never goes in it.

---

## 5. Log it, then show it

Add an entry to `context/context-change-log.md`, newest at the top, with
**Changed / Why / Impact**. Say which questions were asked and what was decided — the
answers are the part worth keeping.

Then show the user the file in chat: the numbered parts, the open questions with their
classification, and any `_Not yet defined._` lines. Ask whether to start building. Do not
start on your own.

### What approval does and does not authorize

- Approval of the specification authorizes implementation of the agreed scope.
- Unresolved **blocking** questions must be answered before implementation.
- Unresolved **non-blocking** questions do not prevent implementation if they do not
  affect the agreed scope.
- If implementation reveals a conflict with the approved specification, **stop and ask**
  before changing the requirements.

Approval is permission to build what the spec says. It is not permission to decide the
things the spec left open.

---

## When the requirement changes later

Same skill, same file:

1. Edit the part. Keep the number if the rule is the same rule changed; renumber only if
   parts were added or removed.
2. Add a dated note saying what it is now. Do not leave the old wording in place as if it
   were still true.
3. If the change invalidates something in **Verified**, strike that line — a measurement
   of the old behaviour is not evidence for the new one.
4. Log the change.

That last point matters for a reason worth stating exactly, because the obvious version of
it is wrong. A moving requirement does not quietly turn a correct claim into a wrong one.
What it does is make an **unmeasured** claim look load-bearing, so it gets repeated with
more confidence than it ever earned.

The guard is this. **Never state a technical claim as verified without evidence.** Use
executable tests or direct inspection of the relevant source code, as appropriate. Use
existing tests only when they demonstrate the exact behavior. If a claim cannot be
verified, label it as an unverified assumption and do not treat it as a requirement.
Record actual execution results in `Verified` only after running the relevant test or
operation.

**Relevant** is the load-bearing word. Inspecting the code that implements the behavior is
evidence; inspecting a similar-looking case elsewhere and reasoning by analogy is not.
That is the exact shape of the mistake: a claim about what `session.merge` does was
inferred from a different hook that looked the same, when the relevant source was the
service's `update` and merge's own rule about the instance `__dict__`. Reading the right
file would have settled it in a minute. Reading a neighbouring one produced a confident
wrong answer that survived several turns.

Wersje

RepozytoriumWynikLicencja
Ta strona · hammoda711/task-spec-skill100MIT
ji-hun-git/how-to-use-ai100MIT

Migawka bazy z 13.11.2026 · wersja paczki 28f17aab8651 (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

  • 91create-tasks
    Generuje natywne zadania Claude Code z istniejącej specyfikacji, dzieląc ją na zadania implementacyjne.
  • 100spec-design
    Pisze artefakty OpenSpec design.md i tasks.md dla funkcji opartej na specyfikacji, czyli projekt techniczny i listę zadań.
  • 100spec-driven-development
    Zamienia zatwierdzony pomysł lub zgłoszenie w pliki specyfikacji, planu i zadań w repozytorium, po czym wykonuje je zadanie po zadaniu z dziennikiem postępów.
  • 100split-to-tasks
    Dzieli specyfikację na pliki zadań, po jednym na worktree, grupując zadania na gałęzie według bramek wdrożeniowych.
  • 82implement-spec
    Wykonuje zadania zatwierdzonej specyfikacji test-first, po jednym zadaniu na commit, z subagentami recenzji.
  • 100writing-tasks
    Tworzy plan wdrożenia wieloetapowego zadania przed dotknięciem kodu, dla specyfikacji lub wymagań.

Uwagi i zgłoszenia

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