Przejdź do treści
Biblioteka skilli
Zarządzanie i produkt · Planowanie

work

/work

Przyjmuje dowolną prośbę o zmianę i kształtuje ją w pozycję pracy, sortując ją na poprawkę, funkcję lub sondę.

Repozytorium
skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
22.09.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 22.09.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

Przyjmuje dowolną prośbę o zmianę i kształtuje ją w pozycję pracy, sortując ją na poprawkę, funkcję lub sondę.

Wyzwalacze z opisu

new work itemI want to add…herechange requestshape thislet

Argumenty

/work <optional change description, idea, or pasted example>
Oryginalny opis (EN)

Single entry point of the slice-driven workflow: take any change request, idea, improvement, or outcome description, triage it (chore / feature / probe), and shape it into a work item under work/. Trigger whenever the user says "/work", "new work item", "I want to add…", "here's an idea", "change request", "shape this", "let's plan this change", or hands over any description of something the project should do or become. Also trigger when the user pastes an example, API sketch, or file-format vision and asks to turn it into work. Do NOT trigger for pure questions about existing work items ("wha

Jak działa

  1. Prerequisites
  2. Step 1: Triage
  3. Step 2: Ground against settled decisions
  4. Step 3: Shape (dialogue, kept short)
  5. Step 4: File and stop
  6. Staleness rule
Sekcje z nagłówków SKILL.md, w oryginale · 56 linii, 1 021 słów
Podgląd SKILL.md
---
name: work
description: >
  Single entry point of the slice-driven workflow: take any change request, idea, improvement,
  or outcome description, triage it (chore / feature / probe), and shape it into a work item
  under work/. Trigger whenever the user says "/work", "new work item", "I want to add…",
  "here's an idea", "change request", "shape this", "let's plan this change", or hands over
  any description of something the project should do or become. Also trigger when the user
  pastes an example, API sketch, or file-format vision and asks to turn it into work. Do NOT
  trigger for pure questions about existing work items ("what's next?", "list work") — answer
  those directly with the scripts.
argument-hint: <optional change description, idea, or pasted example>
model: opus
allowed-tools: Read, Glob, Grep, Edit, Write, Agent, Bash
---

# Work — Triage and Shape a Change

> For the full workflow this skill belongs to, see [workflow-overview.md](../_shared/workflow-overview.md).

The user's argument, if any: `$ARGUMENTS` — the incoming change description (prose, an idea, or a pasted example/sketch), or the id/name of an existing `captured` item to shape; start triage from it directly. If empty, run `../_shared/scripts/board.sh` (relative to this skill's directory) and check for `captured` items (follow-ups filed by `/build`/`/harvest` that still need shaping): if there is exactly one, pick it up and shape it — its filed body is the incoming change description; if there are several, show the list and shape the lowest-id one unless the user redirects; only if none exist, ask what change the user wants to shape.

You are the single gate through which every change enters a slice-driven project. Your job: triage the incoming description, then shape it into a filed work item — cheaply. Shaping takes minutes, not days; anything that would take longer is a sign you're settling questions that only code can settle.

## Prerequisites

`INTENT.md` should exist (run `/intent` first on a fresh project). If it doesn't and the user wants to proceed anyway, note that invariants/vocabulary grounding is unavailable and continue.

## Step 1: Triage

Type the incoming change with one question: **"Could this just be built and judged, or is there a decision that can't be made without evidence?"**

- **chore** — no unknown at all (e.g. "add structured logging to the server"). Mechanical, however large.
- **feature** — outcome known, path mostly known (e.g. "when started with `--admin <port>`, the server opens a local admin API"). The default type.
- **probe** — a *named decision* is blocked and can't be grounded without running code, AND being wrong about it would be expensive to reverse. If the user can't name the decision it unblocks, it is not a probe — it's a feature or chore.

Bias deliberately toward **feature/chore**: uncertainty alone doesn't earn a probe; cheap-to-reverse calls get a provisional decision (via `/decide`) and real code. State your triage call in one sentence and let the user veto it.

## Step 2: Ground against settled decisions

Before shaping, spawn the `decision-briefer` subagent with the change description and the subsystems it touches. It returns the decisions that constrain this work. **Never re-ask what a grounded decision already settles** — this is the workflow's re-litigation guard. If the change as described cuts against a grounded decision, surface that now: the user either adjusts the change or brings evidence to reopen (route through `/decide`).

For anything beyond a trivial chore, also spawn the `work-scout` subagent for codebase reconnaissance (relevant files, conventions, risks) so the breakdown is implementation-aware. Skip the scout for chores whose touchpoints are obvious.

## Step 3: Shape (dialogue, kept short)

Create the item first so there's always a file: run `../_shared/scripts/work-new.sh <type> <slug> <title>` (relative to this skill's directory) and then fill the body via Edit. (When shaping an existing `captured` item, skip creation and work on its file.) Items are born `captured`; step 4 flips them to `shaped`. Sharpen **only what's needed to build**:

- **Outcome** — one or two sentences, the user's words tightened.
- **Examples** — if the user supplied sketches (API shapes, file formats, CLI transcripts, pseudo-code), paste them **verbatim** as the leading artifact; they outrank prose. Examples are first-class: a concrete example is often the best possible shaping input.
- **Evidence of done** — externally observable checks, checkbox list.
- **Decisions touched** — existing decisions this relies on (from the lookup), plus any new calls made during shaping. Every new call goes through `/decide` as `provisional` — shaping never grounds anything.
- **Tasks** (features only) — an ordered markdown checkbox list (`- [ ] …`, one task per line; `/build` ticks each to `- [x]` and stamps its commit SHA as it lands), each task independently testable and sized for one TDD session, **walking-skeleton first**: task 1 always produces something runnable end-to-end, however thin. Co-edit with the user; they reorder and veto. Chores get a task list only if genuinely multi-step.
- **Results** — leave empty; `/build` and `/harvest` fill it.

**When an ungroundable question surfaces mid-shaping**, offer exactly two exits: (a) decide provisionally via `/decide` and move on, or (b) if expensive-to-be-wrong, create a probe item scoped to exactly that decision (`work-new.sh probe …`, set the feature's `blocked_by` to the probe's id) and point the user at `/slice`. Never let the dialogue debate an ungroundable question — that is the failure mode this workflow exists to kill.

## Step 4: File and stop

Once shaping is complete, flip the item to actionable: `../_shared/scripts/work-status.sh <id> shaped`. This flip is the shaping gate — `work-next.sh` only hands out `shaped` items, so a `captured` item can never reach `/build` unshaped.

For probes triaged at step 1: fill `decision:` in the frontmatter with the decision the probe unblocks, keep the Tasks section to the probe plan (what to build, what observation settles the decision), and point the user at `/slice`.

**Externally blocked items:** if the work can't start until something outside the project happens (an upstream release, a third-party fix, an external decision), file it and immediately flip it with `../_shared/scripts/work-status.sh <id> blocked` — never leave it `shaped`, or `work-next.sh` will hand it to `/build`. State the unblock condition, and how to check it, in the first line of `## Outcome` (link the upstream issue/release page). `blocked_by` stays internal-ids-only; the external condition lives in that Outcome line.

Shaping and building are decoupled — do **not** start building. Queuing several `/work` items before any `/build` is normal. Close by showing `../_shared/scripts/board.sh` output (which also lists the open decisions) and, if relevant, noting which item `../_shared/scripts/work-next.sh` would pick. If any items are `blocked` on an external condition, list each with its unblock condition so the user gets a natural re-check prompt.

## Staleness rule

Nothing shaped here is permanent: decisions made during shaping are provisional, and `/build` re-checks an item's Decisions touched against the current decision log when it picks the item up. Keep shaping cheap accordingly — a stale item is cheap to refresh, not a sunk cost.

Wersje

RepozytoriumWynikLicencja
Ta strona · mtrense/skills100MIT
arxdsilva/ai-loops100MIT
minanyang/10x-agent100MIT
cwinvestments/memstack100MIT
Khouini/trunks-spec100MIT
x-cmd/x-cmd100Apache-2.0
HubSpot/agent-cli-skills100Apache-2.0
OutlineDriven/outline-driven-development100Apache-2.0
Weaverse/.agents96MIT

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

  • 96new-work-item
    Tworzy i zakresuje nowe zadanie w folderze work/items repozytorium, gdy pojawia się prośba bez wpisu.
  • 100shape-it
    Zamienia pomysł na produkt, MVP lub funkcję w plan i backlog pionowych plasterków z kryteriami akceptacji.
  • 96backlog
    Dodaje nowy pomysł na funkcję do backlogu produktu, gdy użytkownik chce zapisać ulepszenie lub prośbę.
  • 96backlog
    Dodaje nowy pomysł na funkcję do backlogu produktu, gdy użytkownik chce zapisać ulepszenie lub prośbę.
  • 100contract-first
    Zamienia prośbę o funkcję, zmianę zachowania lub usunięcie w uzgodniony kontrakt zachowania, zanim ktokolwiek napisze kod.
  • 95backlog
    Prowadzi listę odłożonych zadań w katalogu docs/backlog, po jednym pliku na pozycję: czyta, dopisuje i porządkuje.

Uwagi i zgłoszenia

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