1. Run

   git rev-parse --is-inside-work-tree

   to see if the CWD is already inside a git repository (even if it has zero commits or is otherwise empty).
2. Run

   ls -A

   to check if the directory has any files/folders at all.
3. If it IS a git repo, note this — we will NOT run

   git init

   later. Also run

   git symbolic-ref --short HEAD

   to detect the current default branch name and store it as

   {DEFAULT_BRANCH}

   .
4. If it is NOT a git repo, note this — we may need to initialize one later.

   {DEFAULT_BRANCH}

   will be determined in Step 8.

• Whether the current directory is a git repo
• Whether it's empty or has existing files

Where do you want to set up the project?

1. Here — use the current directory (

   {CWD}

   )
2. New subdirectory — create a new folder inside the current directory

cd

What problem are you solving? Describe what you want to build in 1-2 sentences.

What would you like to set up?

1. Full project — scaffold code, tooling, and ops (runtime, package manager, formatter, linter, CI, license, precommits, CLAUDE.md)
2. Ops only — just set up ops tooling (git, .gitignore, license, CI, precommits, CLAUDE.md) without creating project code or installing a runtime/package manager

• Lowercase, kebab-case (

  my-project-name

  )
• Short (1-3 words)
• Descriptive of the solution, not the problem

• Run

  bun init

• Create

  tsconfig.json

  with strict mode

• Ask: npm, yarn, or pnpm? (Recommend pnpm)
• Run the appropriate init command
• Create

  tsconfig.json

  with strict mode

• Ask: uv, poetry, or pip? (Recommend uv)
• Run the appropriate init command
• Set Python version (ask or default to 3.12+)

• Run

  cargo init

• Create

  rust-toolchain.toml

  to pin the toolchain and ensure all contributors have formatting/linting/editor components:

[toolchain]
channel = "stable"
components = ["rustfmt", "clippy", "rust-analyzer"]

• Ask for module path (suggest

  github.com/{user}/{project}

  )
• Run

  go mod init

1. Install the chosen tools as dev dependencies
2. Create the appropriate config file(s) (e.g.,

   biome.json

   ,

   ruff.toml

   ,

   .eslintrc

   ,

   rustfmt.toml

   )
3. Add

   format

   ,

   lint

   , and

   lint:fix

   scripts to the project's task runner (e.g.,

   package.json

   scripts,

   Makefile

   ,

   Justfile

   )

.github/workflows/ci.yml

• Format check step (e.g.,

  biome check

  ,

  ruff format --check

  ,

  cargo fmt --check

  )
• Lint step (using the linter chosen in Step 5)
• Test step (appropriate test runner)
• Triggered on push to

  {DEFAULT_BRANCH}

  and pull requests

Note: The workflow file is created locally. The user must push the repository to GitHub and verify the workflow runs. Any required secrets (e.g.,

GITHUB_TOKEN

, deployment keys) must be configured in the repository's Settings → Secrets and variables → Actions.

WebFetch

https://raw.githubusercontent.com/Nathan13888/nice-skills/master/data/licenses/{SPDX-ID}

• <year>

  or

  [year]

  → current year

• <copyright holders>

  or

  [fullname]

  → user's name from

  git config user.name

  (ask if not set)

1. Fetch the license text from the URL above
2. Replace placeholders
3. Write to

   LICENSE

1. Ask which two licenses to combine (recommend MIT + Apache-2.0, the Rust ecosystem standard)
2. Fetch both license texts in parallel via

   WebFetch

3. Replace placeholders in both
4. Create

   LICENSE-MIT

   and

   LICENSE-APACHE

   (pattern:

   LICENSE-{SHORT-NAME}

   )
5. Create a root

   LICENSE

   file explaining the dual licensing:

This project is licensed under either of

  * Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
  * MIT License (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

1. Ask the user what the default branch name should be (suggest

   main

   , but accept any name such as

   master

   ). Store the answer as

   {DEFAULT_BRANCH}

   .
2. Run

   git init -b {DEFAULT_BRANCH}

   to initialize with that branch name.
3. Create

   .gitignore

   (see below)
4. Create initial commit:

   chore: initialize project

1. Ask the user if they want a

   .gitignore

   created or updated
2. If in Ops only mode and no runtime was chosen, ask the user which

   .gitignore

   template(s) to use (or offer to skip)
3. Ask the user if they want an initial commit with the scaffolded files

1. Install lefthook (pick the method appropriate for the project):
   • npm/bun:

     npm install --save-dev lefthook

     /

     bun add -d lefthook

   • Homebrew:

     brew install lefthook

   • Go:

     go install github.com/evilmartians/lefthook@latest

   • Or download a binary release from GitHub
2. Create

   lefthook.yml

   at the project root. Substitute the actual commands for the chosen runtime and formatter/linter:

pre-commit:
  commands:
    format-fix:
      run: {format fix command}   # e.g. biome format --write, ruff format, cargo fmt
    lint-fix:
      run: {lint fix command}     # e.g. biome lint --fix, ruff check --fix, cargo clippy --fix

pre-push:
  commands:
    format-check:
      run: {format check command} # e.g. biome format --check, ruff format --check, cargo fmt --check
    lint-check:
      run: {lint check command}   # e.g. biome lint, ruff check, cargo clippy -- -D warnings
    test:
      run: {test command}         # e.g. bun test, pytest, cargo test, go test ./...

1. Run

   lefthook install

   to activate the hooks.

• Install

  husky

  and

  lint-staged

• Configure

  lint-staged

  in

  package.json

  to run the formatter/linter fix commands on staged files (auto-fix on commit)
• Initialize husky with:

  • pre-commit

    hook: runs

    lint-staged

    (auto-fixes staged files)

  • pre-push

    hook: runs format check, lint check, and tests

• Install

  pre-commit

  framework
• Create

  .pre-commit-config.yaml

  with hooks that fix (e.g.,

  ruff format

  ,

  ruff check --fix

  )
• Run

  pre-commit install --hook-type pre-commit --hook-type pre-push

• Add a

  pre-push

  stage entry (or a separate

  .git/hooks/pre-push

  script) that runs format check, lint check, and

  pytest

• Create

  .git/hooks/pre-commit

  : runs

  cargo fmt

  (fix) and

  cargo clippy --fix

• Create

  .git/hooks/pre-push

  : runs

  cargo fmt --check

  ,

  cargo clippy -- -D warnings

  , and

  cargo test

• Make both scripts executable (

  chmod +x

  )

• Create

  .git/hooks/pre-commit

  : runs

  gofmt -w .

  (fix) and applies

  golangci-lint run --fix

  if available
• Create

  .git/hooks/pre-push

  : runs

  gofmt -l .

  (check),

  go vet ./...

  , and

  go test ./...

• Make both scripts executable (

  chmod +x

  )

• Runtime: {runtime}
• Language: {language}
• Package Manager: {package manager}
• Formatter: {formatter}
• Linter: {linter}

• {Language-specific conventions, e.g., "Use strict TypeScript - no

  any

  types"}
• Write tests for all new functionality
• Use conventional commits (type: description)
• Keep functions small and focused

Project initialized: {name}
Location: {path}
Runtime: {runtime}
Package Manager: {pkg manager}
Formatter: {formatter}
Linter: {linter}
License: {license(s)}
CI/CD: {ci/cd}
Pre-commit: {yes/no}

Files created:
{list of files — if AGENTS.md + symlink was chosen, show both AGENTS.md and CLAUDE.md → AGENTS.md}

Next steps:

1. {install command}
2. Push to GitHub and verify GitHub Actions workflows run correctly
   - Configure any required secrets in Settings → Secrets and variables → Actions
3. Start building!

Ops tooling initialized
Location: {path}
License: {license(s)}
CI/CD: {ci/cd}
Pre-commit: {yes/no}

Files created:
{list of files — if AGENTS.md + symlink was chosen, show both AGENTS.md and CLAUDE.md → AGENTS.md}

Next steps:

1. Push to GitHub and verify GitHub Actions workflows run correctly
   - Configure any required secrets in Settings → Secrets and variables → Actions
2. Start building!

Reminder: GitHub Actions workflows only run once the repository is pushed to GitHub. If you haven't created the remote repository yet, do that first (

gh repo create

or via the GitHub UI), then push with

git push -u origin {DEFAULT_BRANCH}

.

cd

• Always ask before creating files — never assume preferences
• Use

  AskUserQuestion

  with concrete options, not open-ended prompts
• If a tool is not installed (e.g.,

  bun

  ,

  uv

  ), offer to install it or suggest an alternative
• All files MUST be created in the chosen project directory (CWD or the user's subdirectory choice from Step 0) — never in a parent, sibling, or unrelated directory
• Check if the target directory already exists before creating anything
• Keep the initial project minimal — don't over-scaffold
• Respect the user's choice to skip code scaffolding — ops-only mode is a first-class path, not a fallback
• The CLAUDE.md should be practical and specific, not boilerplate
• Detect git user.name and user.email from git config for license attribution
• If the user provides a GitHub username, use it for module paths and license
• Use

  WebFetch

  with prompt "Return the full file content exactly as-is" to get raw template text without summarization
• If

  WebFetch

  fails for any URL, fall back to generating content from memory and inform the user
• For dual-license, fetch both license texts in parallel to minimize latency

undefined