project-kickoff
/project-kickoff
Prowadzi krok po kroku przez odkrywanie wymagań nowego projektu programistycznego, zanim wybierze się stos, i kończy zatwierdzonym dokumentem wymagań.
- Autor
- xixifish ↗
- Repozytorium
- project-kickoff ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 28.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 2
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 28.10.2026, bez odwołań do wycofanych modeli i API.
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
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
- Opening move
- Discovery flow
- Wrapping up
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
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · xixifish/project-kickoff | 100 | MIT |
| DPatta/project-docs-kit | 100 | MIT |
| kietly-web/project-kickoff-skill | 100 | MIT |
| SpicyFalcon619/claude-skills-setup | 100 | MIT |
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.