Skip to content
Skills Library
Programming · Planning

bootstrap

/bootstrap

Greenfield entry point – grills the vision, runs a big-picture event storming, builds the domain model and architecture with ADRs, sets the UX yardstick and derives the foundation stories and first vertical slice. Use when starting a new project.

Repository
kataster ↗
Licence
MIT
Last repository change
07.11.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 07.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Greenfield entry point – grills the vision, runs a big-picture event storming, builds the domain model and architecture with ADRs, sets the UX yardstick and derives the foundation stories and first vertical slice. Use when starting a new project.

Arguments

/bootstrap [project idea in one sentence – empty = ask first]
Original author description

Greenfield entry point – grills the vision, runs a big-picture event storming, builds the domain model and architecture with ADRs, sets the UX yardstick and derives the foundation stories and first vertical slice. Use when starting a new project.

How it works

  1. Preconditions
  2. Phase 1 – Grill the vision
  3. Phase 2 – Big-picture event storming
  4. Phase 3 – Domain model and architecture
  5. Phase 4 – UX yardstick
  6. Phase 5 – Foundation stories and the first slice
  7. Phase 6 – Review
  8. Phase 7 – Wrap-up
  9. Rules
Original SKILL.md headings · 116 lines, 955 words
SKILL.md preview
---
name: bootstrap
description: Greenfield entry point – grills the vision, runs a big-picture event storming, builds the domain model and architecture with ADRs, sets the UX yardstick and derives the foundation stories and first vertical slice. Use when starting a new project.
disable-model-invocation: true
argument-hint: "[project idea in one sentence – empty = ask first]"
---

# Bootstrap a New Project

You are starting from nothing but an idea. The order is fixed: **vision → domain → architecture → UX → stories**.
Technology comes after the domain, never before it.

Idea: the arguments from the invocation (empty → ask the user for one sentence first).

## Preconditions

1. Read `.claude/project.json`. If it is missing, tell the user to run `npx kataster init` first and stop.
2. If the repository already has code, this is the wrong command: use `/adopt`.
3. Call the `skill` tool for `grilling` and `domain-model`. Grilling sets how you ask; domain-model sets how the
   glossary is written.

## Phase 1 – Grill the vision

The frontier is every `[OPEN]` in `docs/product/vision.md`: problem, user groups, goals, non-goals, success
criteria, constraints, the domain in one paragraph. Work it in rounds as the `grilling` skill says – numbered
questions, recommended answer each, whole frontier per round.

Rules for this phase:

- **No technology.** No framework, no database, no hosting. If the user starts there, park it: "that is an ADR
  after the domain, and the domain may change the answer."
- **Force a non-goal.** A vision without a "we will not do this" is a wish list.
- **Success criteria must be measurable**, or they are not criteria.
- **Write as you go**: remove answered `[OPEN]`s from `docs/product/vision.md`; resolved terms go into
  `CONTEXT.md` immediately (domain-model skill).

Stop when the frontier is empty and the user confirms a shared understanding.

## Phase 2 – Big-picture event storming

Read `.claude/skills/event-storming/SKILL.md` and follow it with the whole domain as focus. Phases 1–6 are
mandatory; 7–8 are the proposal you hand to the architect.

- 8–15 suspected events as a starting point, in the user's words, past tense.
- Order them into `flows` – one per business process. Mark pivotal events.
- Collect hotspots systematically; grill the ones the user can decide now.
- Commands and actors, policies (including time-triggered), read models.
- Write `docs/domain/events.yaml` after **every** phase. The hook validates and renders it; fix errors at once.

Stop when every event has an aggregate or context, every command a trigger, and no hotspot blocks a boundary.

## Phase 3 – Domain model and architecture

Delegate to `domain-architect` with the file paths and the IDs from `events.yaml`: bounded contexts, context map,
aggregates with testable invariants, and the logical data model. The agent proposes; the user decides.

Then the architecture, in this order:

1. **Shape** – the simplest architecture that meets the documented requirements. A monolith is the default;
   anything distributed needs a cited requirement.
2. **Tech stack** – only now, following `.claude/skills/architect/TECH-STACK.md`. One ADR
   (`docs/adr/0001-tech-stack.md`, `status: proposed`), with the driving requirements cited from
   `docs/product/vision.md` and `docs/domain/events.yaml`. **Only the user sets `accepted`.**
3. **Other decisions** – only the ones that pass the architect skill's three criteria. Not every library.

## Phase 4 – UX yardstick

Call the `skill` tool for `ux-design`. Grill the questions the vision does not settle:

- devices and the design size (the size the layout is built for, not the exception),
- UI language(s) and where terms come from,
- the states every screen needs (empty, full, rejected, no permission),
- the recurring patterns worth a G-number.

Delegate to `ux-designer`: write the approved decisions into `docs/product/ux-guidelines.md` as rules with date
and reason. Do not let it become a mood board.

## Phase 5 – Foundation stories and the first slice

Write the stories yourself as the spec engineer (the `user-stories` skill is the method), in two parts:

1. **Foundation tech tasks** – what every later story relies on: repository skeleton, the single quality command
   (`verify`), CI, the test harness and test data approach, auth/roles if the vision needs them, deployment.
   Each is a tech task with a checklist and `depends_on`, not a domain story. Keep them minimal: foundation just
   in time, not a platform project.
2. **The first vertical slice** – the smallest set of stories that delivers one real end-to-end path from the
   vision (e.g. "report → triage → resolve"), each a story with Gherkin scenarios, `ui: true` where a person sees
   something.

Rules: one story = one command + its events on one aggregate, at most 4 scenarios; no implementation plan inside a
domain story; every domain story links `aggregate`, `command` and its `events`; `status: draft`, then `review` when
finished. The spec linter must be green before `ready-for-human-review`.


## Phase 6 – Review

Read `.claude/skills/review-stories/SKILL.md` and follow it with the story IDs from Phase 5. The spec linter is the
gate; the user approves every `ready`. Fix what it finds in the story (or in the model, when an event or aggregate
is missing) – never work around a lint error.

## Phase 7 – Wrap-up

Summarize: vision settled (and what stayed open), number of events/commands/policies/read models, contexts and
aggregates, ADRs proposed, UX guidelines written, stories created and their review outcome.

Then name the next step:

- `node .claude/skills/implement/scripts/verify.ts` should be green before the first `/implement`.
- `/implement` for the first foundation story; `/feature <idea>` once the domain has a language and the
  foundation stands.
- `/groom-backlog` after the first bounded context is complete.

## Rules

- **Domain before technology, always.** If a technology question blocks the domain, it is a spike with a timebox,
  not an architecture decision made in advance.
- **No invented requirements.** Every ADR cites a path in `docs/`. No documented requirement → no complexity.
- **The user owns the language and the decisions.** You propose; they confirm. Accepted ADRs are theirs to set.
- **Stop at checkpoints.** After vision, after event storming, after the model, after the stories – summarize in
  3–5 lines and ask whether to continue. A bootstrap that runs to the end without a checkpoint produces a
  beautiful model nobody agreed to.

Versions

RepositoryScoreLicence
This page · hemi1986/kataster90MIT
renzrollon/interlock100MIT
vercel-labs/vercel-plugin100Apache-2.0
bytedance/deer-flow100MIT
Nazhra05/Super-set100MIT
Nazhra05/Super-set100MIT
chaordic-io/discipline100MIT
geekatron/jerry100Apache-2.0
fullymiddleaged/clawness100MIT

Database snapshot: 13.11.2026 · package version eae3ba5160d1 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100hatch3r-feature
    End-to-end feature implementation workflow. Covers data model, domain logic, API, and UI as a vertical slice. Use when implementing new features or working on feature request issues.
  • 100project-bootstrap
    This skill launches an interactive 8-phase new project setup wizard. Use when the user asks "create a new project", "start a project", "bootstrap project", "set up a new repo", "initialize project", "新しいプロジェクト作成", "プロジェクトを始める", or "プロジェクト立ち上げ".
  • 100bootstrap-v6-install
    Add Bootstrap 6 to a project and set it up for local development. Use when installing Bootstrap, adding Bootstrap to a new or existing project, or setting up Bootstrap's CSS and JavaScript via CDN or a package manager.
  • 100vertical-slice-architecture
    Enforce Vertical Slice Architecture (VSA) when building applications in any language (Go, .NET/C#, Java, Kotlin, TypeScript, Python, etc.) and any type (web API, mobile backend, CLI, event-driven). Organize code by feature/use-case instead of technical layers. Each feature is a…
  • 100adopt
    Brownfield entry point – maps the repository, adopts it in slices (one domain plus at most one shared library), drafts the domain model with evidence, grills the user, documents each package where it lives and records the gap; it derives stories only when asked (--stories). Use…
  • 90DDD Strategic Patterns for Domain Modeling
    This skill should be used when the user asks to 'model the domain', 'identify bounded contexts', 'map domain relationships', 'run event storming', 'define ubiquitous language', 'analyze domain complexity'. Provides DDD strategic patterns for requirements and design.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.