create-ai-eng-app

Scaffold a new AI Engineering Kit project — a Next.js app wired for a spec-driven workflow in your coding agent, built for product managers and founders who ship production software without reading code.

Works with Claude Code, Codex, Cursor, GitHub Copilot, Antigravity, Grok Build and Kimi Code. Claude Code is the recommended setup and the one the course documents.

Usage

npx create-ai-eng-app my-app   # into a new subfolder
npx create-ai-eng-app          # into the folder you are standing in
npx create-ai-eng-app add      # into a project that already exists

Without a name the kit installs into the current folder — handy right after cloning an empty repo. It refuses to overwrite anything: if a file it ships is already there, it stops and names it. The two exceptions are the files GitHub creates for you — your README.md is kept and the kit's is skipped, and your .gitignore keeps its rules and only gains the missing ones.

Adding it to a project you already have

Run it in a folder that already holds a project and it says what it found, then asks:

This folder already has a project in it:
  package.json, src/, 47 commits

◆  What should I do here?
│  ◉ Add the AI Engineering Kit to this project
│  ○ Scaffold a new project here instead
└  ↑/↓ to navigate • ENTER: confirm

Adding installs the framework only — the skills, the rules and the workflow map, in the layout each of your agents reads. No Next.js stack, no npm install, no .env.local, no commit, and your package.json is not renamed. Your code, your dependencies and your tooling stay exactly as they are; the kit adapts to them rather than the other way round.

Two things it will stop and ask about rather than decide for you:

• A skill of yours with a kit name. build, deploy, qa and cleanup are names people give their own skills. Yours is moved to .ai-eng-kit-backup/ and never deleted.
• A CLAUDE.md with your own notes, when you pick more than one agent. Content moves to AGENTS.md with a backup, so there stays exactly one file to maintain.

Then run /verify-setup and /init. /init skips the greenfield interview and instead records what your project is and how to start, verify and deploy it — so the skills check their work against your project instead of assuming the kit's stack. It does not rewrite anything you already have.

The skills adapt to your stack, and say so when they can't. Everything stack-specific lives in stack packs under docs/stacks/ — the database commands, the host's panel, the framework's conventions. A skill reads what your project recorded and loads the matching pack; where the kit has none for your stack, it asks you and follows your answer instead of guessing. What never changes is the discipline: every schema change is a versioned file, anything that checks a credential is rate-limited, nothing ships that QA didn't pass. A missing pack changes how those are met, never whether.

It asks two things.

Which coding agents — pick one or several; the same framework is installed into the layout each one reads:

◆  Integrate with:
│
│  ▣ Claude Code ★
│  □ Codex
│  □ Cursor
│  □ GitHub Copilot
│  □ Antigravity
│  □ Grok Build
│  □ Kimi Code
│
│  ★ recommended
└  ↑/↓ to navigate • TAB/SPACE: select • ENTER: confirm

The working language — Deutsch or English. Your agent then talks to you in that language and writes everything in it: PRD, feature specs, acceptance criteria, QA reports. The kit's own guides stay English.

Add --agents=claude,codex and --lang=de|en to skip both questions.

Then:

cd my-app              # only if you scaffolded into a subfolder
claude                 # open your coding agent
/verify-setup          # confirm the setup is ready
/init                  # define your product and first features

Skills are called with / in every agent except Codex, where they are $verify-setup, $init — or picked from its /skills menu. /help always prints the syntax that is right for your project.

Update an existing project

npx create-ai-eng-app update   # refresh the .claude/ framework + workflow map to latest

Your app code, features/, and your own notes are not touched — the update is per file, driven by a manifest of what the kit owns. A project created before the language question was introduced gets asked once, here.

The workflow

/init → /write-spec → /architecture → /tasks → /build → /qa → /deploy

Every feature runs through those phases. Alongside them:

| Skill | When | |-------|------| | /map | Map a project that already exists — stack, architecture, concerns, and the features it already has — before /init | | /reverse-spec | Turn one already-built feature into a confirmed spec — criteria read from the code, confirmed by you, verified by /qa | | /refactor | Split one oversized file behind an unchanged facade — behaviour-preserving, proven by the same green tests and criteria as before | | /refine PROJ-X | Change or challenge an existing spec — anytime | | /audit | Read-only drift check: do the docs still match reality? | | /dsgvo | GDPR / DSGVO assessment — before building anything with personal data | | /e2e-tests | Lock in the critical journeys with Playwright, after /qa | | /security-check | Non-destructive check of the live app, after /deploy | | /cleanup | Tidy the docs of deployed features | | /help | Where am I, and what's next? | | /verify-setup | Check the setup — after install, or whenever it looks off |

What it sets up

• Stack: Next.js 16 + TypeScript + Tailwind + shadcn/ui + Supabase + Vitest + Playwright

• Framework: the same 19 skills, 2 rule sets and 6 stack packs, installed where each agent looks for them — standalone, so commands stay bare (/init, /build):

  | agent | skills | rules | |---|---|---| | Claude Code ★ | .claude/skills/ | .claude/rules/ | | Codex | .codex/skills/ | (in the memory file) | | Cursor | .cursor/skills/ | .cursor/rules/*.mdc | | GitHub Copilot | .github/skills/ | .github/instructions/*.instructions.md | | Antigravity | .agents/skills/ | .agents/rules/ | | Grok Build | .grok/skills/ | (in the memory file) | | Kimi Code | .kimi-code/skills/ | (in the memory file) — skills are called /skill:build |

• Feature folders: features/PROJ-X-name/ with spec.md (the contract) / design.md / tasks.md / qa-report.md; acceptance criteria carry stable IDs, forming the chain AC → Task → Test. Status lives in features/INDEX.md only.

• App-wide docs: docs/PRD.md, docs/data-model.md (entities + relationships), docs/app-shell.md (navigation + layout frame), docs/privacy.md, plus production guides (error tracking, security headers, rate limiting, performance, database)

• Data protection for two jurisdictions: /dsgvo assesses against the EU GDPR / German DSGVO, the Swiss DSG, or both — chosen at /init, recorded in .ai-eng-kit → law, with the rules of each in docs/law/. Engineering review, not legal advice

• Project map: exactly one file carries your project's context and a managed block the kit keeps current — CLAUDE.md in a Claude-Code-only project, otherwise AGENTS.md. Any other memory file is a generated pointer to it, so there is never a second place to edit.

• Guardrails: .claude/settings.json (Claude Code) and .grok/config.toml (Grok Build) block reading .env* and force-pushing. Enforced in those two only — the other agents get the same rules as instructions they follow, not as a sandbox that stops them.

• Grok Build reads the Claude Code layout too (.claude/skills/, .claude/rules/). If you select both, Grok Build sees every skill twice — pick one of the two, or accept the duplicate slash commands.

Updates are pull-based via update — the developer decides when to update, no surprise drift mid-build. Running it without a flag re-shows the agent picker with your current selection preselected, so adding an agent later is one keystroke.