Generated Project Anatomy

This page describes every file and directory created when Genesis scaffolds a new project. We'll use a Python FastAPI project (widget-api) as the running example.

Directory structure

widget-api/
  CLAUDE.md
  .mcp.json
  .gitignore
  pyproject.toml
  .claude/
    settings.json
    agents/
      test-runner.md
      code-reviewer.md
      doc-writer.md
      api-designer.md
      data-modeller.md
    skills/
      test/SKILL.md
      lint/SKILL.md
      review/SKILL.md
      commit/SKILL.md
      endpoint/SKILL.md
      migrate/SKILL.md
  src/widget_api/
    __init__.py
    main.py
  tests/
    test_main.py
  migrations/
  docs/
    README.md
    architecture.md

The exact structure varies by stack. A Go project uses cmd/ and internal/, a Node.js project uses src/ with package.json, and so on.

CLAUDE.md

The most important file in any generated project. It serves as the project's brain, providing Claude with everything it needs to work effectively:

Project identity, language/locale rules, error handling rules
Code standards, testing mandates, documentation rules
Commit style, stack-specific conventions

Template variations by plan

Profile	Format
Lean (Pro)	Condensed template that merges language, error handling, code standards, and testing into a single "Standards" section
Standard (Max)	Full template with clearly separated sections
Full (ProMax)	Full template with additional context and extended project-specific rules

.claude/settings.json

Configures Claude Code's permissions and automated hooks for the project.

Permissions

Stack-specific tool permissions. A Python FastAPI project gets:

{
  "permissions": {
    "allow": [
      "Bash(python:*)",
      "Bash(pip:*)",
      "Bash(pytest:*)",
      "Bash(ruff:*)",
      "Bash(uv:*)"
    ]
  }
}

Hooks

PostToolUse hook: Runs ruff check --fix and ruff format automatically after Claude edits .py files
Stop hook: Reminds Claude to run tests and commit before ending a session
PreToolUse hook (if risk-evaluator included): Risk evaluation prompt before every shell command

Statusline

Displays the current model and context usage at the bottom of the Claude Code interface:

[Claude Sonnet 4.6] ctx: 34%

.claude/agents/

One Markdown file per agent. Every project includes three workflow agents:

Base agents

test-runner.md: Runs the test suite, analyses failures, provides context about what broke and why
code-reviewer.md: Reviews code for quality, style, correctness, security, and adherence to CLAUDE.md standards
doc-writer.md: Generates and updates documentation, including README files, architecture docs, and inline comments
risk-evaluator.md (conditional): Evaluates dangerous operations using a 1–5 severity rubric. Severity 1–2 proceeds silently; severity 3 warns; severity 4–5 halts and requires explicit confirmation

Domain agents

2–4 additional agents selected based on project type:

api-designer for API projects
data-modeller for database projects
auth-specialist for projects with authentication
component-architect for frontend projects
cli-designer for CLI tools
pipeline-architect for data projects
security-reviewer for security-sensitive projects

.claude/skills/

One directory per skill, each with a SKILL.md file defining when and how the skill is invoked.

Base skills (always included)

Skill	Purpose
`/test`	Run the project's test suite using the stack's test framework
`/lint`	Run linters and formatters using the stack's toolchain
`/review`	Trigger a code review using the code-reviewer agent
`/commit`	Stage changes and create a well-formed commit message

Dynamic skills (selected by project type)

Skill	Purpose	When selected
`/endpoint`	Scaffold API endpoint	API, web service
`/migrate`	Create database migration	Projects with databases
`/component`	Scaffold UI component	Frontend
`/storybook`	Generate Storybook stories	Frontend with Storybook
`/run`	Build and run project	CLI tools
`/build`	Compile/build project	CLI tools, compiled languages
`/pipeline`	Scaffold data pipeline stage	Data projects
`/query`	Write and test database queries	Data projects

.mcp.json

Configures MCP (Model Context Protocol) servers for external integrations. Only present if the project has integrations that benefit from MCP.

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres",
               "postgresql://localhost:5432/widget_api"]
    }
  }
}

Available MCP servers

postgres for PostgreSQL databases
mysql for MySQL databases
sqlite for SQLite databases
github for GitHub API
playwright for browser testing and automation
aws for AWS services

Genesis only configures MCP servers that the project actually needs. No speculative integrations.

Memory files

Written to ~/.claude/projects/-home-xeeva-claude-<name>/memory/, outside the project directory. Claude reads these automatically at the start of each session.

MEMORY.md: An index file that points to the other memory files
user-profile.md: Your role, experience level, interaction preferences, and working style. Seeded from your Genesis personalisation.md
project-context.md: Project name, purpose, stack, key integrations, creation date, and architectural decisions

Application boilerplate

Genesis generates a minimal but functional starting point for the chosen stack:

Entry points: src/main.py, cmd/<name>/main.go, src/index.ts, src/main.rs
Package configuration: pyproject.toml, go.mod, package.json, Cargo.toml, Gemfile, build.gradle.kts
Test setup: Framework configuration and a sample test that verifies the project runs
Stack-specific config: tsconfig.json, .golangci.yml, ruff.toml, rustfmt.toml, etc.

Documentation

docs/README.md: Project name, purpose, setup instructions, and usage guide
docs/architecture.md: High-level architecture describing the project's structure, key components, data flow, and design decisions

.gitignore

A stack-appropriate gitignore covering language-specific build artefacts, IDE files, environment files, OS files, dependency directories, and log files.