Przejdź do treści
Biblioteka skilli
AI i agenci · Planowanie

spec-writer

/spec-writer

Zamienia surowy pomysł w plan projektu dla agentów AI: specyfikację, zasady, architekturę i fazy budowy.

Licencja
MIT
Ostatnia zmiana repozytorium
03.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
11
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 03.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 surowy pomysł w plan projektu dla agentów AI: specyfikację, zasady, architekturę i fazy budowy.

Oryginalny opis (EN)

Turns a raw idea into a complete, build-ready project plan that AI coding agents can follow. Interviews the user one question at a time, researches similar products when web search is available, then writes the project spec (docs/SPEC.md), the agent rules file (AGENTS.md), architecture and SOLID rules (docs/ARCHITECTURE.md) and a phase-by-phase build plan with acceptance criteria, manual tests and optional ready-made prompts (docs/PHASES.md). Use this skill when the user has an idea or product to build but no spec yet, or asks for a project plan, specification, PRD, roadmap, phases, architectu

Jak działa

  1. How you talk (always)
  2. Inputs and outputs (file contract)
  3. Step 0. Resume and existing files
  4. Step 1. Interview the idea (one question at a time)
  5. Step 2. Research similar products (when possible)
  6. Step 3. Decisions
  7. Step 4. Architecture and SOLID rules
  8. Step 5. Requirements checklists
  9. Step 6. Data, interfaces and structure
  10. Step 7. UI system (only if there is a UI)
Sekcje z nagłówków SKILL.md, w oryginale · 94 linii, 1 435 słów
Podgląd SKILL.md
---
name: spec-writer
description: Turns a raw idea into a complete, build-ready project plan that AI coding agents can follow. Interviews the user one question at a time, researches similar products when web search is available, then writes the project spec (docs/SPEC.md), the agent rules file (AGENTS.md), architecture and SOLID rules (docs/ARCHITECTURE.md) and a phase-by-phase build plan with acceptance criteria, manual tests and optional ready-made prompts (docs/PHASES.md). Use this skill when the user has an idea or product to build but no spec yet, or asks for a project plan, specification, PRD, roadmap, phases, architecture, competitor analysis for a new product, or "prompt engineering" to prepare a build. Use it before spec-kit-builder whenever the project has no spec documents, even if the user only says "I want to build X".
---

# Spec Writer

Turn an idea into a plan an AI coding agent can execute without guessing. You write documents; you do not write product code.

## How you talk (always)

- Ask which language the user prefers in your first message (or use the language they already write in). Reply in that language, in simple words. Explain any technical term in one short sentence the first time.
- ONE question at a time, then stop and wait. Never send a list of questions. Offer 2 to 4 numbered options with your recommendation when it helps, plus "other".
- Before each stage say in one or two lines what it is and why it matters. After each stage say what you wrote and what comes next.
- Be honest. Never invent competitors, features, prices, versions or statistics. If you cannot verify something, say so and mark it "to verify" in the document.
- Documents the agent will read are written in English by default (more reliable for coding agents), unless the user asks for another language. Explanations to the user stay in the user's language.
- Never write secrets, passwords or tokens into any file.

## Inputs and outputs (file contract)

- **Reads (all optional):** existing `docs/*`, `AGENTS.md`, notes the user gives you.
- **Writes:** `docs/SPEC.md`, `AGENTS.md` (and `CLAUDE.md`), `docs/ARCHITECTURE.md`, `docs/PHASES.md`, `docs/BUILD-STATE.md`.
- **Required fields you must write so the next skills can work:** in `PHASES.md` every phase has Goal, Acceptance, How, Manual tests, Status and **UI surfaces** (names of the screens or components the phase needs, or `none`); in `AGENTS.md` a "Definition of done" with real commands; in `SPEC.md` the sections shown in `templates/SPEC.template.md`.
- **Next skills:** `ui-designer` or `ui-prompt-writer` (if there is a UI), then `spec-kit-builder`. If the next skill finds a field missing, it will send the user back to you, so fill every field.

## Step 0. Resume and existing files

Look for `docs/BUILD-STATE.md`, `docs/SPEC.md`, `AGENTS.md`, `docs/PHASES.md`, `docs/ARCHITECTURE.md`.
- If some exist, read them, tell the user in 3 lines what is already there, and ask whether to continue, improve, or start over. Never overwrite an existing file without asking; propose a backup copy (`.bak`) first.
- Record progress in `docs/BUILD-STATE.md` (format in the builder skill; you own the "Spec writing" lines) after every stage so you can resume.

## Step 1. Interview the idea (one question at a time)

Follow `references/interview-guide.md`. Skip anything the user already told you. Collect: name and one-liner, the problem, the users, market and language, platform and technology, how it will be distributed or sold, must-haves, non-goals, hard rules, and how the user wants to work (will they use Spec Kit? which AI agent?).

If the user does not know the technology, propose 2 or 3 options with one-line trade-offs and a recommendation.

## Step 2. Research similar products (when possible)

Follow `references/research-guide.md`. If you have a web search tool, find 5 to 8 similar products or open-source projects, extract their features, pricing model and weak points, and write a comparison table with source links. If you have no search tool, say so and ask the user to name 3 to 5 competitors, or skip with the user's consent. Then list the gaps and ask the user which differentiators to adopt (one question, multi-choice).

## Step 3. Decisions

Turn what you learned into numbered decisions (D1, D2, ...): platform and minimum versions, storage, rendering or processing approach, external services policy, privacy, licensing/distribution responsibility, language and localization, testing approach, and anything where two reasonable options exist. For each important decision give the recommendation and the reason. Ask the user to approve in small groups (at most 5 at a time, one question per group: "approve all / change number X").

## Step 4. Architecture and SOLID rules

Follow `references/architecture-guide.md`. Propose layers suited to the stack, the allowed dependency direction, the SOLID mapping with concrete interfaces of THIS project, supplementary rules, size limits, and how the rules will be enforced automatically (an architecture test or lint rule for the stack). Ask for approval. Do not copy a layer table that does not fit the stack; adapt it.

## Step 5. Requirements checklists

Ask which of these apply and write specific requirements for each that does: security and privacy, performance budgets, accessibility, localization and right-to-left, offline/error behavior, observability/logging, compatibility matrix, data retention. One question per area, or one multi-select question if the user is a beginner.

## Step 6. Data, interfaces and structure

Only what the project needs: folder structure, naming conventions, data model (entities and fields), public interfaces (API endpoints, commands, events, hooks), configuration keys, extension points. Keep these concrete (names, types), not vague.

## Step 7. UI system (only if there is a UI)

Write the UI section of `docs/SPEC.md` using EXACTLY these labeled lines so the UI skills can run automatically without asking anything: `Style feeling`, `Brand colors`, `Density`, `Modes`, `Text direction`, `Languages`, `Fonts` (with license note), `Accessibility target`, `Devices`, `UI path`, `References`. Add main screens, key flows in one line each and empty/error/loading states below them. Fill every line, using the interview answers or a stated assumption. Do not design the screens here. Then ask ONE question about the UI path: 1) the coding agent designs it (`ui-designer` skill, recommended), 2) prompts for an external design tool such as Google Stitch or Figma (`ui-prompt-writer` skill), 3) decide later. Record the answer in `docs/SPEC.md` and in the phase plan.

## Step 8. Plan the phases

Split the work into 6 to 16 phases ordered by dependency:
- Phase 0: project setup and quality tools. Phase 0b (if architecture rules exist): the automatic architecture check.
- Then vertical slices: each phase delivers something the user can see or test.
- If there is a UI: a "UI foundation" phase (brief, flows, design system, app shell) BEFORE the UI-heavy feature phases. It is not a Spec Kit feature; it is run with `ui-designer` or `ui-prompt-writer`, and its outputs live in `docs/ui/`.
- Late phases: hardening (security, performance, localization), packaging and release.
Each phase must be small enough to finish and test in one working session. Use `templates/PHASES.template.md` for the block format. Every phase has: goal in plain words, what/why, acceptance criteria, out of scope, technical build list, manual tests (exact clicks/commands), a **UI surfaces** line (the screens or components the phase needs, or `none`; the UI skills later add IDs like `[S2]`), decisions that need the user, and a size (S/M/L).
Ask whether the user will use Spec Kit. If NOT, also write a "Direct prompt" per phase (self-contained, includes files to read, build list, acceptance, and what to report). If yes, skip direct prompts; the builder skill derives the Spec Kit inputs from the fields.
Show the phase list (titles + one line) first and get approval before writing details.

## Step 9. Write the files

Use the templates in `templates/`. Create (ask first if a file exists):
- `docs/SPEC.md` - product, users, research summary, decisions, naming, structure, data, interfaces, requirements, UI, out of scope, open questions.
- `AGENTS.md` (and `CLAUDE.md` with the same text if the user uses Claude Code) - agent workflow rules, code rules, architecture rules block, definition of done (the exact commands to run).
- `docs/ARCHITECTURE.md` - layers, dependency rules, SOLID mapping, enforcement, "how to add a new variant" recipe.
- `docs/PHASES.md` - the phase blocks.
Write them from the approved decisions only. Do not invent content that was not agreed.

## Step 10. Quality review (always)

Run `references/quality-checklist.md` against what you wrote. Fix problems yourself. Typical checks: every feature in the spec appears in a phase; every phase has testable acceptance; no technology in "what" sections; names and paths are consistent across all files; no contradictions between decisions; every "to verify" item is listed in the open-questions section; commands in the definition of done really exist for the stack.
Then show the user a short summary (what files, how many phases, the 5 most important decisions, open items) and ask for final approval.

## Step 11. Hand off

Tell the user the next step: run the `spec-kit-builder` skill in the same project folder. If that skill is installed, offer to start it right away. Update `docs/BUILD-STATE.md` (spec writing = done).

## Rules for good documents

- Specific beats long: names, numbers, file paths, exact commands.
- One source of truth: facts live in SPEC.md; other files point to it.
- Separate WHAT/WHY (behavior, acceptance) from HOW (technology). The builder sends them to different Spec Kit steps.
- Every acceptance item must be checkable by a person or a command.
- Mark unverified facts as "to verify" and never present them as certain.
Pliki w paczce (11)
  • README.fa.md 4 KB
  • README.md 3 KB
  • SKILL.md 10 KB
  • references/architecture-guide.md 3 KB
  • references/interview-guide.md 3 KB
  • references/quality-checklist.md 2 KB
  • references/research-guide.md 2 KB
  • templates/AGENTS.template.md 1 KB
  • templates/ARCHITECTURE.template.md 1 KB
  • templates/PHASES.template.md 1 KB
  • templates/SPEC.template.md 2 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · Stanly-Antigravity/spec-driven-skills100MIT
andreibesleaga/gabbe100CC-BY-4.0
kambleakash0/agent-skills100MIT
florianbuetow/claude-code100MIT
drake-agent/dasks-kit90MIT
AlpacaLabsLLC/skills-for-architects85MIT

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

  • 100roadmap
    Dzieli PRD i architekturę na fazy dostaw z uporządkowanymi zadaniami, plikami w docs/roadmap, weryfikacją i kolejnością wdrożeń.
  • 100prd-to-plan
    Zamienia PRD w fazowy plan wdrożenia zapisany jako plik Markdown w repozytorium: rejestr wymagań, decyzje wspólne dla faz oraz uporządkowane fazy z kontrolami i poleceniami weryfikacji.
  • 100product-manager
    Zamienia surowy pomysł na aplikację w pytania wyjaśniające i zatwierdzony PRD, odpowiada agentom na pytania produktowe i obsługuje zmiany w trakcie budowy.
  • 100plan-development
    Zamienia pomysł na projekt lub funkcję w etapowy plan rozwoju, z pierwszą fazą szkieletową i kryteriami wyjścia z każdej fazy.
  • 95spec
    Zbiera wymagania projektu, bada problem i tworzy specyfikację oraz plan działania z niezależną recenzją.
  • 100spec-generator
    Przeprowadza wywiad o projekcie i tworzy gotowy SPEC.md oraz CLAUDE.md dla Claude Code, a opcjonalnie prywatną specyfikację.

Uwagi i zgłoszenia

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