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

project-kickoff

/project-kickoff

Prowadzi krok po kroku przez odkrywanie wymagań nowego projektu programistycznego, zanim wybierze się stos, i kończy zatwierdzonym dokumentem wymagań.

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

Brak sygnałów. Repozytorium zmienione 28.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

Prowadzi krok po kroku przez odkrywanie wymagań nowego projektu programistycznego, zanim wybierze się stos, i kończy zatwierdzonym dokumentem wymagań.

Wyzwalacze z opisu

I want to build an app that…help me plan a new projectI have an idea for a tool
Oryginalny opis (EN)

Requirements discovery for a new software project, before any tech stack or system design. Guides the user step by step through the core need, users, domain rules, data sources, scope and constraints, and ends with a confirmed docs/requirements.md. Use this whenever someone describes a new app, tool, website or product idea they want to build or plan ("I want to build an app that…", "help me plan a new project", "I have an idea for a tool"), even if they jump straight to asking for a tech stack or architecture. Don't use it for small one-off scripts, bug fixes, new features in an existing code

Jak działa

  1. Opening move
  2. Discovery flow
  3. Wrapping up
Sekcje z nagłówków SKILL.md, w oryginale · 152 linii, 1 461 słów
Podgląd SKILL.md
---
name: project-kickoff
description: Requirements discovery for a new software project, before any tech stack or system design. Guides the user step by step through the core need, users, domain rules, data sources, scope and constraints, and ends with a confirmed docs/requirements.md. Use this whenever someone describes a new app, tool, website or product idea they want to build or plan ("I want to build an app that…", "help me plan a new project", "I have an idea for a tool"), even if they jump straight to asking for a tech stack or architecture. Don't use it for small one-off scripts, bug fixes, new features in an existing codebase, or when the user already has a written spec.
---

# Project Kickoff

Help the user pin down what they're building, and why, before anyone picks a tech stack or
designs a system. Requirements that only become clear later (the real core need, a scope
limit, a domain rule, a data source that turns out to be closed) tend to overturn tech and
design decisions made too early. A short conversation now is cheaper than rework later.

Act as a curious, practical product partner: ask, listen, restate what you heard, and check
facts yourself where you can. Hold off on tech suggestions until the requirements are
confirmed, unless the user chooses to skip.

## Opening move

The user arrives with an idea, sometimes with a direct tech question. Don't launch straight
into questions. First:

1. Show in one sentence that you've understood the idea.
2. Say in one sentence why it's worth pinning down requirements first, then offer three
   choices and recommend one based on what they've told you:
   - **Full**: all sections. Suits products, portfolio pieces, team projects, and anything
     that relies on outside data or will have real users.
   - **Short**: core need, data and scope only. Suits small personal tools.
   - **Skip**: go straight to tech.
3. If they asked a tech question, say you'll come back to it. It's easier to answer once
   the need is clear.

Example:

> A meal-planning app that builds a shopping list from your week's recipes sounds useful.
> Before picking a stack, it's worth a few minutes on what it needs to do, since that
> usually decides the stack. Want a **full** kickoff (I'd suggest this, since you want to
> share it with friends), a **short** one (core need, data and scope), or to **skip**
> straight to tech?

### If they skip

Respect it and go straight to their request. Don't sneak the questions back in. If you later
spot a gap that would change the design, mention it once, briefly.

### Use what you already know

If the first message, earlier conversation or existing project files (a README, notes)
already answer some questions, don't ask them again. Restate what you found and confirm it.
The same goes for suggestions: before proposing a feature or setting, check whether an
earlier answer already covers it.

### Who you're working with

People using this range from first-time builders to experienced engineers. Don't assume
which. If it isn't clear, add one light question to the first batch about their experience
and what the project is for (learning, portfolio, personal use, a product). Match your
language to the answer: explain terms for beginners, skip the basics for experts.

## Discovery flow

### How to run it

- Ask 2–3 related questions per message, then wait. Each answer can change what's worth
  asking next, and a long list of questions gets skimmed.
- Go roughly in the order below, since earlier sections shape later ones. If the user
  mentions something that belongs to a later section, note it and don't ask it again.
- When you move to a new section, say so briefly ("Next: where the data comes from"), so
  the user can tell the conversation is going somewhere.
- When a question is hard to answer cold, offer options or examples ("Is it for just you,
  a few friends, or the public?").
- "Not sure yet" is a fine answer. Log it as an open question and move on.
- If the user mentions tech they want to use, note it as a preference or constraint, but
  don't start designing. Don't propose a stack or architecture until the sections are
  confirmed.
- Keep a running list of decisions (with the reason for each) and open questions as you
  go. It feeds the requirements document at the end.

### Hold new information lightly

People think out loud during a kickoff. A remark like "other people might use it too"
could be a firm requirement or just a passing thought. When something new would
significantly change the users, scope, data or cost, restate it as your reading and ask
which it is before working out its consequences ("When you say others could use it, do you
mean a public launch, or a link you'd share with a few friends?"). Until the user
confirms, keep it as an open question, not a decision.

Smaller remarks don't need this; just note them. Checking every passing comment would make
the conversation tiring.

### Check facts yourself

The user shouldn't have to know everything. When the answer exists out in the world (how a
domain works, whether a data source has an API, what a site's terms of use or robots.txt
allow), look it up yourself if you have web access, and share what you found with sources.
Don't raise a possible rule or problem you haven't checked: check it first, or say plainly
that it's a guess.

For any data the project depends on, fetch a real sample: a page, a file, an API response.
A source that looks fine in principle often turns out to be blocked, paywalled, incomplete
or shaped differently than expected, and finding that out now is the whole point of this
skill. If you can't check, tell the user exactly what to check and why.

### The sections

The short version covers sections 1, 4 and 5. The full version covers all six. Each one is
here because its answers can change the tech stack or the system design.

1. **Core need.** What problem, for whom, what they do today instead, and what a good
   result looks like in one real situation. Asking them to walk through the last time
   they had the problem often helps. Then restate the core need in one sentence and get a
   clear yes before going on. This is the most important checkpoint: the first version of
   an idea is often broader than, or different from, the real need, and everything else
   builds on this sentence.
2. **Users and usage.** Who uses it, how many people, on which device (a phone on the go,
   a laptop at a desk), and how often. This decides things like web or mobile, and
   whether it needs accounts, a database or real hosting.
3. **Domain rules.** How the real-world thing works: rules, exceptions and edge cases.
   For a booking app, that might be cancellation deadlines, double bookings and time
   zones; for a shared-expenses app, refunds, uneven splits and different currencies.
   Check them against real sources. Users often know the common case but not the
   exceptions, and the exceptions shape the data structure and logic.
4. **Data.** What data is needed, where it comes from, how fresh it must be, and whether
   it's accessible: an official API, an open dataset, scraping, manual entry, or
   permission needed. Include whether they're allowed to use it (terms of use,
   robots.txt, personal data and privacy). Check with a real sample (see above). Treat
   this as a requirement, not a tech detail: if the data isn't available, the project
   changes.
5. **Scope.** What's in v1, what's out, and what's for later. Steer toward a small v1 that
   serves the core need, and park everything else under "later" so nothing is lost.
6. **Constraints.** Budget, hosting, timeline, the skills they have, and what the project
   is for (learning, portfolio, personal use, a product). Build on the opening question
   instead of repeating it. These narrow the stack choice: a learning project might favor
   tools they want to learn over the fastest option.

## Wrapping up

Once the sections are covered (all six, or 1, 4 and 5 for the short version):

1. **Draft the requirements document.** Write `docs/requirements.md` following
   `references/requirements-template.md`. Fill in only what was covered, so a short
   kickoff gives a short document. Keep it to requirements: no stack or architecture,
   except tech preferences the user stated. If you can't write files, or the project
   has no folder yet, put the document in your reply instead so they can save it.
2. **Get it confirmed.** In chat, give a short summary (the core need sentence, the key
   decisions, the open questions) and ask what's wrong or missing. This is the final
   check, so give the user room to correct things. Update the document until they say
   it's right.
3. **Hand over to tech.** Now move on to the tech stack and system design. If the user
   asked a tech question at the start, answer it now. Point out which requirements drive
   the biggest tech decisions (for example, "the data has to be scraped every night, so
   you'll need something that runs on a schedule"), so the user sees how the kickoff
   shaped the design.

If requirements change later in the project, update `docs/requirements.md` and its
decisions log, so it stays a useful reference instead of going stale.
Pliki w paczce (2)
  • SKILL.md 9 KB
  • references/requirements-template.md 2 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · xixifish/project-kickoff100MIT
DPatta/project-docs-kit100MIT
kietly-web/project-kickoff-skill100MIT
SpicyFalcon619/claude-skills-setup100MIT

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

  • 100pm-start
    Prowadzi od opisu aplikacji lub narzędzia do zakresu, MVP i planu budowy, jako punkt wejścia do pm.
  • 100kickoff
    Przygotowuje start nowej funkcji lub większej zmiany produkcyjnej: brief, pytania, plan, dziennik decyzji i założenia.
  • 90kickoff
    Prowadzi od pomysłu, kodu albo dokumentu do spisanych wymagań, zadając rundy pytań o cele, zakres i reguły biznesowe.
  • 100plan-app
    Planuje aplikację przed kodem: zadaje pytania po jednym, pisze pliki kontekstu projektu i uporządkowany plan budowy.
  • 100requirements-start
    Zamienia cienką prośbę biznesu w pierwszy kontrakt wymagań, mapę interesariuszy, glosariusz domeny i plan warsztatu.
  • 100kickoff
    Prowadzi inżyniera przez cały proces pracy nad błędem lub funkcją: rozpoznanie, PRD, specyfikacja, plan, budowa, przegląd, wdrożenie i wnioski.

Uwagi i zgłoszenia

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