organic-growth 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 lab71.tech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# 🌱 Organic Growth
+
+[![Test](https://github.com/lab71tech/organic-growth/actions/workflows/test.yml/badge.svg)](https://github.com/lab71tech/organic-growth/actions/workflows/test.yml) [![GitHub Release](https://img.shields.io/github/v/release/lab71tech/organic-growth)](https://github.com/lab71tech/organic-growth/releases)
+
+Claude Code setup for incremental software development.
+
+Grow features in natural stages, where each stage delivers a complete, working system.
+
+Inspired by Alistair Cockburn’s Elephant Carpaccio and the idea that projects grow like plants, rather than being sliced from a finished whole.
+
+## Install
+
+```bash
+# In your project directory:
+bunx organic-growth
+
+# Or with npx:
+npx organic-growth
+
+# With a product DNA document:
+bunx organic-growth docs/my-product-spec.md
+
+# Force overwrite existing files:
+bunx organic-growth --force
+```
+
+This copies the `.claude/` configuration into your project. No runtime dependencies.
+
+## What You Get
+
+```
+.claude/
+├── CLAUDE.md              # Project context template + growth philosophy
+├── agents/
+│   └── gardener.md        # Plans, implements, and validates growth stages
+└── commands/
+    ├── seed.md            # /seed  — bootstrap new project
+    ├── grow.md            # /grow  — plan a new feature
+    ├── next.md            # /next  — implement next stage
+    ├── replan.md          # /replan — adjust when things change
+    └── review.md          # /review — deep quality review
+```
+
+## Workflow
+
+```bash
+# 1. Bootstrap (new project)
+> /seed                          # interview mode
+> /seed docs/product-dna.md      # from existing product document
+
+# 2. Grow features
+> /grow Add user authentication
+> /next                          # stage 1
+> /next                          # stage 2
+> /next                          # stage 3
+> /clear                         # fresh session every 3 stages
+> /review 3                      # quality check
+> /next                          # continue
+
+# 3. When reality changes
+> /replan We need to support SSO instead of basic auth
+```
+
+## Philosophy
+
+- **One stage = one intent = one test = one commit**
+- **Rolling plan:** 3-5 stages ahead, re-evaluate every 3
+- **Two-layer quality:** deterministic tools after every stage, LLM review on demand
+- **Context hygiene:** fresh session every 3 stages
+- **Product context required:** fill in CLAUDE.md or provide a DNA document
+
+## After Install
+
+1. Edit `.claude/CLAUDE.md` — fill in the Product section (or run `/seed`)
+2. Fill in Quality Tools section with your project's lint/test commands
+3. Start building with `/grow`
+
+## Releases
+
+Releases are triggered manually via the [Release](.github/workflows/release.yml) workflow. When triggered, it:
+
+1. Checks for meaningful commits since the last `v*` tag
+2. Bumps the version in `package.json`
+3. Commits the version bump and pushes a new `v*` tag
+4. Creates a GitHub Release with auto-generated release notes
+
+The [Publish to npm](.github/workflows/publish.yml) workflow triggers on any `v*` tag push and publishes to npm automatically. The full pipeline is: **manual trigger -> version bump -> tag -> GitHub Release -> npm publish**.
+
+```bash
+# Patch release (default — bug fixes, small changes)
+gh workflow run Release
+
+# Minor release (new features, backwards-compatible)
+gh workflow run Release -f bump=minor
+
+# Major release (breaking changes)
+gh workflow run Release -f bump=major
+
+# Dry run — preview what would be released without making changes
+gh workflow run Release -f dry-run=true
+```
+
+Or use the "Run workflow" button on the Actions tab in GitHub.
+
+| Input | Type | Default | Description |
+|-------|------|---------|-------------|
+| `bump` | choice: `patch`, `minor`, `major` | `patch` | Version bump type |
+| `dry-run` | boolean | `false` | When `true`, calculates the version and shows a summary but skips the commit, tag, and release |
+
+## License
+
+MIT

package/bin/cli.mjs

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, copyFileSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join, dirname, relative } from 'path';
+import { fileURLToPath } from 'url';
+import { createInterface } from 'readline';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TEMPLATES_DIR = join(__dirname, '..', 'templates');
+const TARGET_DIR = process.cwd();
+
+const RESET = '\x1b[0m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+const DIM = '\x1b[2m';
+
+function log(msg) { console.log(msg); }
+function success(msg) { log(`${GREEN}✓${RESET} ${msg}`); }
+function warn(msg) { log(`${YELLOW}!${RESET} ${msg}`); }
+function info(msg) { log(`${CYAN}→${RESET} ${msg}`); }
+
+async function ask(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question(question, answer => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+function getAllFiles(dir, base = dir) {
+  const files = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) {
+      files.push(...getAllFiles(full, base));
+    } else {
+      files.push(relative(base, full));
+    }
+  }
+  return files;
+}
+
+function readVersion() {
+  const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
+  return pkg.version;
+}
+
+function printHelp() {
+  log('');
+  log(`${GREEN}🌱 Organic Growth${RESET} — Claude Code setup for incremental development`);
+  log('');
+  log(`${CYAN}Usage:${RESET}`);
+  log(`  npx organic-growth [options] [dna-file.md]`);
+  log('');
+  log(`${CYAN}Options:${RESET}`);
+  log(`  -f, --force     Overwrite existing files without prompting`);
+  log(`  -h, --help      Show this help message`);
+  log(`  -v, --version   Show version number`);
+  log('');
+  log(`${CYAN}Arguments:${RESET}`);
+  log(`  dna-file.md     Path to a product DNA document to copy into docs/`);
+  log('');
+  log(`${CYAN}Examples:${RESET}`);
+  log(`  npx organic-growth                  Install templates (prompts on conflicts)`);
+  log(`  npx organic-growth --force          Install templates (overwrite existing)`);
+  log(`  npx organic-growth spec.md          Install templates + copy DNA document`);
+  log('');
+}
+
+async function install() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp();
+    return;
+  }
+
+  if (args.includes('--version') || args.includes('-v')) {
+    log(readVersion());
+    return;
+  }
+
+  const force = args.includes('--force') || args.includes('-f');
+  const dna = args.find(a => !a.startsWith('-') && a.endsWith('.md'));
+
+  log('');
+  log(`${GREEN}🌱 Organic Growth${RESET} — Claude Code setup for incremental development`);
+  log('');
+
+  const files = getAllFiles(TEMPLATES_DIR);
+  const created = [];
+  const skipped = [];
+
+  for (const file of files) {
+    const src = join(TEMPLATES_DIR, file);
+    const dest = join(TARGET_DIR, file);
+    const destDir = dirname(dest);
+
+    if (!existsSync(destDir)) {
+      mkdirSync(destDir, { recursive: true });
+    }
+
+    if (existsSync(dest) && !force) {
+      const answer = await ask(`${YELLOW}!${RESET} ${file} already exists. Overwrite? [y/N] `);
+      if (answer !== 'y' && answer !== 'yes') {
+        skipped.push(file);
+        continue;
+      }
+    }
+
+    copyFileSync(src, dest);
+    created.push(file);
+  }
+
+  // Create docs/growth/ directory
+  const growthDir = join(TARGET_DIR, 'docs', 'growth');
+  if (!existsSync(growthDir)) {
+    mkdirSync(growthDir, { recursive: true });
+    created.push('docs/growth/');
+  }
+
+  // Handle DNA document
+  if (dna) {
+    const dnaSource = join(TARGET_DIR, dna);
+    if (existsSync(dnaSource)) {
+      const dnaDest = join(TARGET_DIR, 'docs', 'product-dna.md');
+      copyFileSync(dnaSource, dnaDest);
+      success(`Product DNA copied from ${dna}`);
+    } else {
+      warn(`DNA file not found: ${dna}`);
+    }
+  }
+
+  log('');
+  if (created.length > 0) {
+    log(`${GREEN}Installed:${RESET}`);
+    for (const f of created) {
+      log(`  ${DIM}${f}${RESET}`);
+    }
+  }
+  if (skipped.length > 0) {
+    log(`${YELLOW}Skipped (already exist):${RESET}`);
+    for (const f of skipped) {
+      log(`  ${DIM}${f}${RESET}`);
+    }
+  }
+
+  log('');
+  log(`${GREEN}Done!${RESET} Next steps:`);
+  log('');
+  if (dna) {
+    info(`Run ${CYAN}/seed docs/product-dna.md${RESET} to bootstrap from your DNA document`);
+  } else {
+    info(`Run ${CYAN}/seed${RESET} to bootstrap a new project (interview mode)`);
+    info(`Or: ${CYAN}/seed path/to/product-doc.md${RESET} if you have a product document`);
+  }
+  info(`Edit ${CYAN}.claude/CLAUDE.md${RESET} to fill in your tech stack and quality tools`);
+  log('');
+  log(`${DIM}Commands available after setup:${RESET}`);
+  log(`  ${CYAN}/seed${RESET}    — bootstrap project (interview or DNA document)`);
+  log(`  ${CYAN}/grow${RESET}    — plan and start a new feature`);
+  log(`  ${CYAN}/next${RESET}    — implement the next growth stage`);
+  log(`  ${CYAN}/replan${RESET}  — re-evaluate when things change`);
+  log(`  ${CYAN}/review${RESET}  — deep quality review of recent stages`);
+  log('');
+}
+
+install().catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "organic-growth",
+  "version": "1.0.0",
+  "description": "Claude Code setup for incremental software development — grow features in natural stages",
+  "bin": {
+    "organic-growth": "bin/cli.mjs"
+  },
+  "files": [
+    "bin/",
+    "templates/"
+  ],
+  "keywords": [
+    "claude-code",
+    "ai",
+    "agents",
+    "agile",
+    "incremental-development",
+    "elephant-carpaccio"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lab71tech/organic-growth"
+  }
+}

package/templates/.claude/CLAUDE.md

@@ -0,0 +1,115 @@
+# Project Context
+
+## Product (THE SEED — fill this in)
+
+<!-- Without this section, the agent grows weeds. Be brief but specific. -->
+<!-- If you have a full product document, put it in docs/product-dna.md -->
+<!-- This section is the distilled version — what the agent sees always. -->
+<!-- The DNA document is read only during planning (/grow, /replan). -->
+
+**What:** [One sentence. What is this product?]
+**For whom:** [Who uses it? What's their context?]
+**Core problem:** [What pain does it solve?]
+**Key domain concepts:** [3-7 terms that someone new needs to understand]
+**Current state:** [Greenfield / MVP exists / Production system]
+**Full DNA:** [docs/product-dna.md if exists, otherwise "N/A"]
+
+## Tech Stack (THE SOIL — auto-discovered, but document the non-obvious)
+
+<!-- Claude Code reads your build files. Only add what it CAN'T discover. -->
+
+- [Any non-standard commands, e.g.: `./gradlew test --profile staging`]
+- [Unusual conventions, e.g.: "endpoint names in Polish"]
+- [Hard constraints, e.g.: "no Lombok", "Flyway not Liquibase"]
+
+### Quality tools (fill in for your project)
+
+<!-- Gardener runs these after every stage. List the exact commands. -->
+
+- **Build:** [e.g.: `./gradlew build` or `npm run build`]
+- **Lint:** [e.g.: `./gradlew ktlintCheck` or `npm run lint`]
+- **Type check:** [e.g.: `tsc --noEmit` or N/A for dynamic languages]
+- **Test:** [e.g.: `./gradlew test` or `npm test`]
+- **Smoke:** [e.g.: `curl http://localhost:8080/health` or `npm run dev` + check]
+
+## Priorities (LIGHT & WATER — what matters now)
+
+<!-- This changes. Update it when priorities shift. -->
+
+- [e.g.: "MVP speed over production polish"]
+- [e.g.: "Must work offline first"]
+- [e.g.: "Security is non-negotiable, even for MVP"]
+
+---
+
+# Development Philosophy: Organic Growth
+
+Every feature is grown in stages from seed to maturity.
+Each stage produces a complete, working system — not a partial one.
+A seedling is a whole plant, not 10% of a tree.
+
+## Growth Rules
+
+1. **One stage = one intent = one test = one commit**
+   - Each stage has a single purpose
+   - Each stage has at least one test proving it works
+   - Each stage is committed separately with a clear message
+   - The app builds, tests pass, and runs after every stage
+
+2. **Rolling plan: 3-5 stages ahead**
+   - Never plan more than 5 concrete stages ahead
+   - Keep a rough outline of what comes after, but expect it to change
+   - Re-evaluate the plan every 3 stages or when something unexpected happens
+   - Update `docs/growth/<feature>.md` after every stage
+
+3. **Vertical, not horizontal**
+   - Each stage touches all layers needed (API + service + DB + test)
+   - No "build all the backend first, then the frontend"
+   - Early stages can return hardcoded values — that's natural
+   - Growth: hardcoded → configurable → dynamic → optimized
+
+4. **Context hygiene**
+   - Start a fresh session every 3 stages
+   - The growth plan in `docs/growth/` is the continuity mechanism
+   - After `/clear`, run `/next` — the agent reads the plan and continues
+
+5. **Quality gate after every stage**
+   - Build must pass
+   - Linter must pass (zero new warnings)
+   - Type check must pass (if applicable)
+   - ALL tests must pass (not just new ones)
+   - App must start (health check / smoke test)
+   - Fix all failures within the stage — don't carry debt forward
+
+6. **Deep review on demand**
+   - Run `/review` after every 3-5 stages or before merging
+   - Reviews run with fresh context (no implementation bias)
+   - Check: correctness, consistency, simplicity, security, test quality
+   - Fix 🔴 issues before continuing growth
+
+## Growth Stage Patterns
+
+For **greenfield** projects, first stages always follow this pattern:
+1. Empty project with passing build
+2. Hello World endpoint/page (proves the stack works end-to-end)
+3. First real domain concept with hardcoded data
+4. Persistence (database, migration, repository)
+5. First real behavior with real data
+
+For **existing** projects, first stages are:
+1. The simplest possible version of the new behavior (even hardcoded)
+2. Connect it to existing data/services
+3. Add the real logic incrementally
+
+## Commit Convention
+
+```
+feat(scope): stage N — <what grew>
+
+Growth plan: docs/growth/<feature>.md
+```
+
+## Growth Plan Location
+
+All plans live in `docs/growth/<feature-name>.md`.
+Format documented in the gardener agent.

package/templates/.claude/agents/gardener.md

@@ -0,0 +1,132 @@
+---
+name: gardener
+description: Plans and implements features as organic growth stages.
+  Automatically invoked for incremental feature development.
+  Reads product context from CLAUDE.md, manages rolling growth plans,
+  implements one stage at a time, and self-validates.
+tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Grep
+  - Glob
+---
+
+You are a software gardener. You grow features in natural stages —
+each stage produces a complete, living system.
+
+# How You Work
+
+You have three modes, determined by what you're asked to do:
+
+## Mode: PLAN (invoked by /grow)
+
+0. Read CLAUDE.md — check if the Product section is filled in.
+   If it contains placeholders like "[One sentence..." or is empty:
+   STOP. Tell the user: "No product context yet. Run /seed first
+   to plant the seed, or tell me about the project and I'll fill
+   it in now." If the user describes the project, fill in the
+   Product/Tech Stack/Priorities sections before continuing.
+1. Read CLAUDE.md to understand the product (seed), stack (soil),
+   and priorities (light & water)
+2. Check if `docs/product-dna.md` exists. If yes, read it —
+   it contains the full domain knowledge, business rules, and
+   invariants. Use it to make informed planning decisions.
+   If no, CLAUDE.md Product section is sufficient.
+3. Explore the codebase to understand current state
+4. Ask the user 2-3 clarifying questions — no more.
+   Focus on: acceptance criteria, constraints, riskiest part.
+4. Create a growth plan in `docs/growth/<feature-name>.md`:
+
+```markdown
+# Feature: <name>
+Created: <date>
+Status: 🌱 Growing
+
+## Seed (what & why)
+<one paragraph: what this feature does and why it matters>
+
+## Growth Stages
+
+### Concrete (next 3-5 stages, detailed)
+- ⬜ Stage 1: <description>
+  - Intent: <what this achieves>
+  - Verify: <how to check it works>
+  - Touches: <which areas of the code>
+
+- ⬜ Stage 2: ...
+
+### Horizon (rough outline of what comes after)
+- <rough stage description>
+- <rough stage description>
+- ...
+
+## Growth Log
+<!-- Auto-updated after each stage -->
+```
+
+### Planning Principles
+- First stage is always the simplest possible thing that proves
+  the idea works end-to-end (even with hardcoded values)
+- Order by: risk reduction first, then user value
+- Each stage must be vertical (touch all necessary layers)
+- If a stage feels bigger than "one intent" — split it
+- For greenfield: follow the greenfield pattern from CLAUDE.md
+
+## Mode: GROW (invoked by /next)
+
+1. Read the growth plan from `docs/growth/`
+2. Find the next ⬜ stage
+3. Check the stage counter:
+   - If this is stage 3, 6, 9... → re-evaluate the plan first
+     (are remaining stages still correct? adjust if needed)
+4. Implement ONLY this stage:
+   a. Write the code
+   b. Write/update at least one test
+   c. Quality gate — run ALL checks, fix before proceeding:
+      - Build: verify it compiles (`./gradlew build`, `npm run build`, etc.)
+      - Lint: run the project linter (`./gradlew ktlintCheck`, `npm run lint`, etc.)
+      - Type check: if applicable (`tsc --noEmit`, strict mode, etc.)
+      - Tests: ALL tests pass, not just new ones
+      - Smoke: app starts, health endpoint responds (or equivalent)
+   d. If any check fails — fix it within this stage, don't leave it
+      for the next one. Quality debt doesn't carry forward.
+5. Self-review (quick, not a full code review):
+   - Is this stage vertical? (touches all needed layers)
+   - Did I only implement ONE intent?
+   - Did I smuggle in work from future stages?
+   - If I failed any check → fix before proceeding
+6. Update the growth plan:
+   - Mark stage as ✅ with brief note of what was done
+   - Add entry to Growth Log with date
+   - If this was a re-evaluation point, update upcoming stages
+7. Commit: `feat(scope): stage N — <what grew>`
+8. Report:
+   - What grew
+   - What's next
+   - Progress: "Stage 4/~12 — 🌱🌱🌱🌱⬜⬜⬜⬜..."
+   - If stage counter is multiple of 3: recommend `/clear` + new session
+
+## Mode: REPLAN (invoked by /replan)
+
+1. Read the current growth plan
+2. Read the user's reason for replanning
+3. If `docs/product-dna.md` exists, consult it — the reason for
+   replanning may relate to domain rules or business invariants
+4. Assess current state: what's built, what works, what changed
+5. Rewrite the Concrete stages (next 3-5) from current state
+6. Update the Horizon section
+7. Do NOT undo or modify completed stages
+8. Report what changed and why
+
+# Critical Rules
+
+- NEVER implement more than one stage per /next invocation
+- NEVER plan more than 5 concrete stages ahead
+- ALWAYS run build + tests + smoke check before committing
+- ALWAYS update the growth plan after each stage
+- If a stage reveals the plan is wrong, STOP and replan before continuing
+- Hardcoded values are natural in early stages — don't optimize prematurely
+- The growth plan file is the source of truth, not your memory
+- If you don't understand the domain, ASK — don't guess

package/templates/.claude/commands/grow.md

@@ -0,0 +1,11 @@
+---
+description: Plan and start growing a new feature from seed
+---
+
+Grow a new feature using the Organic Growth approach.
+
+1. Use the gardener agent in PLAN mode
+2. Feature to grow: $ARGUMENTS
+3. After the plan is created and approved, ask:
+   "Plan ready. Start growing stage 1?"
+4. If yes, immediately proceed with GROW mode for stage 1

package/templates/.claude/commands/next.md

@@ -0,0 +1,12 @@
+---
+description: Grow the next stage from the current growth plan
+---
+
+Continue growing: implement the next stage from the active growth plan.
+
+1. Find the active plan in docs/growth/
+2. Use the gardener agent in GROW mode
+3. If no plan exists, tell the user to run /grow first
+4. If all stages are done, congratulate and suggest what might grow next
+
+Feature filter (optional): $ARGUMENTS

package/templates/.claude/commands/replan.md

@@ -0,0 +1,10 @@
+---
+description: Re-evaluate the growth plan when reality changes
+---
+
+Something changed. Re-evaluate the growth plan from current state.
+
+1. Find the active plan in docs/growth/
+2. Use the gardener agent in REPLAN mode
+3. Reason for replanning: $ARGUMENTS
+4. If no reason given, ask: "What changed?"

package/templates/.claude/commands/review.md

@@ -0,0 +1,64 @@
+---
+description: Deep quality review of recent growth stages (fresh context, no implementation bias)
+---
+
+Review code quality of recent stages. Run this after several stages
+or before merging — it provides a second opinion with zero bias from
+the implementation session.
+
+1. Determine scope:
+   - If $ARGUMENTS contains a number (e.g., `/review 3`): review last N stages
+   - If $ARGUMENTS contains a feature name: review that feature's stages
+   - Default: review all stages since last review (or last 5, whichever is smaller)
+
+2. Read the growth plan to understand intent of each reviewed stage.
+
+3. For each stage in scope, examine the git diff and review for:
+
+   **Correctness:**
+   - Does the code actually do what the stage intended?
+   - Are there logic errors, off-by-one, null cases?
+   - Do the tests test the right thing? (not just "test exists")
+
+   **Consistency:**
+   - Does new code follow the same patterns as existing code?
+   - Naming conventions, error handling style, project structure
+   - If `docs/product-dna.md` exists: do domain terms match?
+
+   **Simplicity:**
+   - Is anything over-engineered for the current stage?
+   - Code that belongs in future stages?
+   - Unnecessary abstractions or premature optimization?
+
+   **Security basics:**
+   - SQL injection, XSS, hardcoded secrets
+   - Auth/authz gaps if relevant
+   - Input validation
+
+   **Test quality:**
+   - Do tests break if the feature is removed? (vs always-green tests)
+   - Are edge cases covered?
+   - Test readability — can someone understand intent from the test?
+
+4. Output a review report:
+
+   ```
+   ## Review: <feature> — stages N-M
+
+   ### 🟢 Good
+   - <what's well done — be specific>
+
+   ### 🟡 Suggestions
+   - <improvements, not blockers>
+   - <file:line — what to consider>
+
+   ### 🔴 Issues
+   - <things that should be fixed before continuing>
+   - <file:line — what's wrong and why>
+
+   ### Verdict: ✅ Continue / ⚠️ Fix before next stage / 🔴 Stop and address
+   ```
+
+5. If there are 🔴 Issues, offer to fix them now.
+
+Scope: $ARGUMENTS

package/templates/.claude/commands/seed.md

@@ -0,0 +1,44 @@
+---
+description: Bootstrap a new project — from DNA document or interview
+---
+
+Plant the seed for a new project.
+
+1. Check if a product DNA document was provided (as $ARGUMENTS path or attachment).
+   Also check if `docs/product-dna.md` already exists.
+
+   **Path A — DNA exists:**
+   - Read the document
+   - Distill it into CLAUDE.md Product section (~10 lines: what, for whom,
+     core problem, key domain concepts, current state)
+   - Copy/move the full document to `docs/product-dna.md` if not already there
+   - Confirm with the user: "Here's what I extracted. Anything to adjust?"
+
+   **Path B — No DNA:**
+   - Interview the user. Ask these questions ONE AT A TIME:
+     - What are you building? (one sentence)
+     - Who is it for? What's their context?
+     - What core problem does it solve?
+     - What tech stack do you want? (or: should I suggest one?)
+     - Any hard constraints? (hosting, budget, compliance, language)
+     - What's the priority: speed to MVP, production quality, or learning?
+   - Fill in CLAUDE.md Product section from answers
+
+2. In both paths, also fill in:
+   - Tech Stack (THE SOIL): from DNA or interview + scan of existing project files
+   - Priorities (LIGHT & WATER): from DNA or interview
+
+3. Check if CLAUDE.md already has a filled Product section.
+   If yes, ask: "Product context already exists. Overwrite or update?"
+
+4. Generate `docs/growth/project-bootstrap.md` — the first growth plan:
+   - Stage 1: Initialize project (build tool, dependencies, empty build passes)
+   - Stage 2: Hello World endpoint/page (proves stack works end-to-end)
+   - Stage 3: First domain concept with hardcoded data
+   - Stage 4: Persistence (database, migration, first real data)
+   - Stage 5: First real behavior with real data
+   Adjust these based on the specific stack and domain from DNA/interview.
+
+5. Ask: "Seed planted. Start growing stage 1?"
+
+Input: $ARGUMENTS