Skip to content
Skills Library
AI & agents · Building & coding

init-claude

/init-claude

Generate a production-grade CLAUDE.md for any project. Detects project type (Go CLI, Node API, full-stack monorepo, IaC, Python, etc.) and generates a comprehensive CLAUDE.md with architecture map, agent routing, dev commands, QA checklist, code standards, and workflow instructions. Use when the user says "init claude", "create claude.md", "set up claude", "bootstrap claude", "add claude.md", "project setup", or when starting any new project.

Repository
PandaStack ↗
Licence
MIT
Last repository change
12.11.2026

Assessment and security

100/ 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.
Content35 / 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 12.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

Generate a production-grade CLAUDE.md for any project. Detects project type (Go CLI, Node API, full-stack monorepo, IaC, Python, etc.) and generates a comprehensive CLAUDE.md with architecture map, agent routing, dev commands, QA checklist, code standards, and workflow instructions. Use when the user says "init claude", "create claude.md", "set up claude", "bootstrap claude", "add claude.md", "project setup", or when starting any new project.

Triggers from the description

init claudecreate claude.mdset up claudebootstrap claudeadd claude.mdproject setup
Original author description

Generate a production-grade CLAUDE.md for any project. Detects project type (Go CLI, Node API, full-stack monorepo, IaC, Python, etc.) and generates a comprehensive CLAUDE.md with architecture map, agent routing, dev commands, QA checklist, code standards, and workflow instructions. Use when the user says "init claude", "create claude.md", "set up claude", "bootstrap claude", "add claude.md", "project setup", or when starting any new project.

How it works

  1. Protocol
  2. Rules
Original SKILL.md headings · 164 lines, 884 words
SKILL.md preview
---
name: init-claude
description: Generate a production-grade CLAUDE.md for any project. Detects project type (Go CLI, Node API, full-stack monorepo, IaC, Python, etc.) and generates a comprehensive CLAUDE.md with architecture map, agent routing, dev commands, QA checklist, code standards, and workflow instructions. Use when the user says "init claude", "create claude.md", "set up claude", "bootstrap claude", "add claude.md", "project setup", or when starting any new project.
version: 0.1.0
---

# Init CLAUDE.md — Project-Aware Generation

You are generating a CLAUDE.md file tailored to the detected project. This is the single source of truth that future Claude sessions will use to understand and work within this codebase. It must be accurate, comprehensive, and opinionated.

## Protocol

### Phase 1: Detect Project Type

Scan the project root to determine:

1. **Language & framework** — Check for `go.mod`, `package.json`, `Cargo.toml`, `requirements.txt`, `pyproject.toml`, `Gemfile`, etc.
2. **Project structure** — Monorepo (`pnpm-workspace.yaml`, `turbo.json`, `apps/`, `packages/`) vs single-app vs CLI vs library
3. **Key technologies** — Database (Prisma, Mongoose, SQLAlchemy), auth (Auth0, Supabase, JWT), AI (OpenAI, Anthropic), deployment (Render, AWS, Vercel)
4. **Existing conventions** — Test framework (Vitest, Jest, Go test, pytest), linter config, CI workflows
5. **Existing CLAUDE.md** — If one exists, audit it against the template below and fill gaps rather than overwriting

Announce what you detected before generating.

### Phase 2: Generate CLAUDE.md

Use the template below, adapting sections to the detected project type. Every section must contain real, project-specific information — no placeholders or "TODO" markers.

```markdown
# CLAUDE.md — {Project Name}

## Project Overview

{1-3 sentences: what this project does, who it's for, core value prop}

## Architecture

{ASCII tree of the project structure with annotations}

```
{directory tree with inline comments explaining each module}
```

### Key Modules

{For each major module/package: purpose, key files, dependencies}

## Key Technologies

- **Language**: {language + version}
- **Framework**: {primary framework}
- **Database**: {DB + ORM/driver}
- **Auth**: {auth strategy}
- **Testing**: {test framework}
- **Build**: {build tool}
- **Deploy**: {deployment target}

## Development Setup

### Prerequisites
{Runtime versions, required tools}

### Installation
```bash
{exact commands to get running from scratch}
```

### Development Commands
```bash
{all dev, build, test, lint commands with comments}
```

## Agent Routing (if applicable)

| Domain | Agent | When to Consult |
|--------|-------|-----------------|
| {domain} | {agent name} | {trigger condition} |

## Planning Workflow

1. Clarify scope — what user scenario does this serve?
2. Check architecture impact — does this cross module boundaries?
3. Identify external dependencies — what APIs, services, or data are needed?
4. Write the plan as a checklist with file paths
5. Get confirmation before implementing

## Implementation Workflow

1. Write types/interfaces first
2. Write tests alongside implementation
3. Follow existing patterns in the codebase
4. Run QA before committing

## QA Checklist

```
[ ] All tests pass: {test command}
[ ] No linting errors: {lint command}
[ ] New code has tests (80%+ coverage on new files)
[ ] Error handling on all external calls
[ ] No hardcoded secrets, URLs, or environment-specific values
[ ] Edge cases tested: {project-specific edge cases}
```

## Code Standards

**Error handling**: {language-specific error pattern, e.g., Go's fmt.Errorf wrapping, Node's try/catch + typed errors}

**Logging**: {logging library and usage pattern}

**Testing**: {test style: table-driven, AAA, fixture-based, etc.}

**Naming**: {naming conventions for this language/framework}

## Key Design Constraints

1. {Constraint 1 — e.g., "The shared package must be built before other packages"}
2. {Constraint 2 — e.g., "All API responses must go through the serializer"}
3. {Constraint 3 — e.g., "Never call AWS APIs without context timeout"}

## File Conventions

- {pattern → meaning, e.g., "*.test.ts → unit tests colocated with source"}
- {pattern → meaning}

## Dependencies

```
{key dependencies with versions and purpose}
```

## Quick Commands

```bash
{most common commands a developer would run daily}
```
```

### Phase 3: Adapt by Project Type

**Go CLI** — Emphasize: cobra command structure, error wrapping with `%w`, `slog` logging, `golangci-lint`, table-driven tests, `//go:build` tags for integration tests.

**Node.js API** — Emphasize: Express/Fastify route organization, Zod validation at boundaries, middleware patterns, structured logging, Vitest/Jest testing.

**Full-stack monorepo** — Emphasize: workspace package structure, build order dependencies (`build:shared` first), per-package dev/test/build commands, shared types package, deployment services.

**Vue.js frontend** — Emphasize: composable patterns, router guards, component architecture, CSS architecture (custom properties vs Tailwind), Pinia stores if used.

**Python** — Emphasize: virtual environment setup, `structlog` or stdlib logging, pytest patterns, type hints, `ruff` or `black` formatting.

**IaC / Terraform** — Emphasize: module structure, backend config, variable conventions, `terraform plan` before apply, state management, no hardcoded ARNs/account IDs.

### Phase 4: Verify

After generating:

1. **Read every referenced file** — Verify that directories, commands, and files mentioned in the CLAUDE.md actually exist
2. **Run commands** — Verify that dev/build/test commands work (or note which ones need setup first)
3. **Check for gaps** — Is there anything a new developer would need that's missing?
4. **Check for lies** — Is there anything stated that isn't actually true about this project?

## Rules

- **Real information only.** Every path, command, and dependency must be verified against the actual project. No guessing.
- **Opinionated, not generic.** A CLAUDE.md that says "follow best practices" is useless. Specify exactly which practices, with examples from the actual codebase.
- **One source of truth.** Don't duplicate information from README.md. CLAUDE.md is for Claude sessions — it's a working reference, not documentation for humans.
- **Update, don't overwrite.** If a CLAUDE.md already exists, preserve what's correct and fill gaps. Don't delete information the user added manually.
- **Keep it under 400 lines.** Long enough to be comprehensive, short enough to be read in full. If a section needs more detail, create a separate doc and link to it.

Versions

The database has no other skills named init-claude.

Database snapshot: 13.11.2026 · package version da5fb75a327a (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

  • 100init
    Scan project and generate a customized CLAUDE.md. Detects stack, test commands, and conventions. Use when onboarding to a new project or user says 'init', 'setup claude', 'generate CLAUDE.md'.
  • 90Project Scaffolding
    This skill should be used when the user wants to set up Claude for a project, create a CLAUDE.md file, scaffold the .claude directory, initialize an AI workflow, configure a project for Claude, set up dev intelligence, initialize a new project, or do a new project setup.…
  • 100agents-md-author
    Bootstrap or update project AI-agent instruction files (AGENTS.md for Codex, CLAUDE.md for Claude Code, or both) from the current project's structure. Triggers on: write AGENTS.md, write CLAUDE.md, generate AGENTS.md, agent instructions, project conventions for AI, bootstrap…
  • 100setperms
    Set tool permissions for Claude Code. Configures allowed commands, rules, and preferences in .claude/ directory. Triggers on: setperms, init tools, configure permissions, setup project, set permissions, init claude.
  • 100dotnet-init
    Interactive project initialization. Detects project type, asks architecture questions, and generates a customized CLAUDE.md — no manual template copying. Use when: "init project", "setup project", "initialize", "new project setup", "generate CLAUDE.md", "configure for…
  • 89nacl-init
    Initialize a new project with CLAUDE.md containing development rules, skill routing, bug fix protocol, and documentation discipline. Use when: new project, initialize project, setup project, create CLAUDE.md, or the user says "/nacl-init".

Feedback and reports

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