~/.claude/
├── CLAUDE.md              # 전역 지시사항
└── settings.json          # 전역 설정

.claude/
├── CLAUDE.md              # 프로젝트 지시사항
├── settings.json          # 팀 공유 설정 (Git에 커밋)
└── settings.local.json    # 개인 설정 (Git 제외)

1. Enterprise 정책 (회사용)
2. 커맨드라인 옵션 (--add-dir 등)
3. .claude/settings.local.json (개인)
4. .claude/settings.json (프로젝트)
5. ~/.claude/settings.json (전역)

# Global Instructions for Claude Code

## 코딩 스타일

- TypeScript 우선
- 함수형 프로그래밍 선호
- 에러는 항상 명시적으로 처리
- 주석보다 명확한 변수명

## Git Commit 규칙

- Conventional Commits 사용
- 한글로 작성 (한국어 프로젝트)
- 이모지 사용 금지

## 파일 작성 시 주의

- 새 파일 생성 전 반드시 물어보기
- README나 문서 파일은 요청받을 때만 생성
- .env 파일은 절대 생성하지 않기

## 테스트

- 중요한 로직은 테스트 작성
- Jest 사용
- 파일명: `*.test.ts`

## 반응

- 간결하게 답변
- 이모지 사용하지 않기 (요청 시 제외)

# Next.js Blog Project

## 프로젝트 구조

- `/pages` - Next.js 페이지
- `/components` - React 컴포넌트
- `/lib` - 유틸리티 함수
- `/styles` - 전역 스타일
- `/data/blog` - MDX 블로그 포스트

## 기술 스택

- Next.js 12.1.4
- React 17.0.2
- Tailwind CSS 3.0
- MDX (블로그 포스트)

## 컨벤션

- 컴포넌트는 PascalCase
- 파일명은 kebab-case
- CSS는 Tailwind만 사용 (CSS Modules 금지)

## 개발 명령어

- `npm start` - 개발 서버 (hot reload)
- `npm run build` - 프로덕션 빌드 + Static Export
- `npm run lint` - ESLint + Prettier

## 블로그 포스트 작성

- `node ./scripts/compose.js`로 생성
- Frontmatter 필수 필드:
  - title, date, tags, draft, summary, layout

## MCP 초기화

- Next.js 프로젝트 시작 시 항상 next-devtools-mcp의 `init` 툴 호출

my-project/
├── .claude/CLAUDE.md           # 프로젝트 전체
├── frontend/.claude/CLAUDE.md  # 프론트엔드만
└── backend/.claude/CLAUDE.md   # 백엔드만

{
  "permissions": {},
  "environment": {},
  "hooks": {},
  "mcpServers": {},
  "preferences": {}
}

{
  "permissions": {
    "deny": [
      {
        "tool": "Write",
        "patterns": [".env*", "*.key", "credentials.json", "secrets/**"]
      },
      {
        "tool": "Read",
        "patterns": [".env.production"]
      },
      {
        "tool": "Bash",
        "patterns": ["rm -rf*", "dd *", "mkfs*"]
      }
    ]
  }
}

{
  "environment": {
    "NODE_ENV": "development",
    "API_BASE_URL": "http://localhost:3000",
    "DEBUG": "true"
  }
}

{
  "environment": {
    "NEXT_PUBLIC_APP_NAME": "MyApp",
    "NEXT_PUBLIC_VERSION": "1.0.0"
  }
}

{
  "environment": {
    "GITHUB_TOKEN": "${GITHUB_TOKEN}",
    "DATABASE_URL": "${DATABASE_URL}"
  }
}

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write $(jq -r '.tool_input.file_path // empty')"
          }
        ]
      }
    ]
  }
}

{
  "mcpServers": {
    "next-devtools": {
      "command": "npx",
      "args": ["-y", "next-devtools-mcp@latest"]
    },
    "github": {
      "command": "mcp-server-github",
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "postgres": {
      "command": "mcp-server-postgres",
      "args": ["${DATABASE_URL}"]
    }
  }
}

{
  "preferences": {
    "autoCompact": true,
    "model": "claude-sonnet-4-5",
    "verbose": false,
    "maxContextLength": 200000
  }
}

# SaaS Web Application

## Tech Stack

- Next.js 14 (App Router)
- TypeScript 5.3
- Tailwind CSS
- Prisma + PostgreSQL
- tRPC

## Commands

- `npm run dev` - Start dev server (localhost:3000)
- `npm run build` - Production build
- `npm run typecheck` - Run TypeScript compiler (no emit)
- `npm run lint` - ESLint check
- `npm run format` - Prettier format
- `npm run db:push` - Push schema to database
- `npm run db:studio` - Open Prisma Studio

## Code Style

- Use ES modules (import/export) syntax, not CommonJS (require)
- Prefer functional components and hooks
- Use TypeScript strict mode
- No `any` types - use `unknown` if necessary
- Async/await preferred over .then()

## Workflow

1. Make code changes
2. Run typecheck: `npm run typecheck`
3. Run tests: `npm test`
4. Format code: `npm run format`

## Project Structure

- `/app` - Next.js app directory (pages, layouts, API routes)
- `/components` - Reusable React components
- `/lib` - Utilities and helpers
- `/prisma` - Database schema and migrations
- `/server` - tRPC server code

## Important Notes

- Always run typecheck before committing
- Database migrations require manual review
- API routes should validate input with Zod
- Use Server Components by default, Client Components only when needed

## Testing

- Jest for unit tests
- Playwright for E2E tests
- Test files: `*.test.ts` or `*.spec.ts`
- Aim for >80% coverage on critical paths

# Data Science Project

## Environment

- Python 3.11
- Poetry for dependency management
- pyenv for Python version management

## Setup Commands

- `poetry install` - Install dependencies
- `poetry shell` - Activate virtual environment
- `poetry add <package>` - Add new dependency

## Development Commands

- `poetry run pytest` - Run tests
- `poetry run black .` - Format code
- `poetry run mypy .` - Type checking
- `poetry run ruff check .` - Linting

## Code Style

- Follow PEP 8
- Use type hints for all functions
- Black for formatting (line length: 88)
- Docstrings in Google style

## Project Structure

- `/data` - Raw and processed data (gitignored)
- `/notebooks` - Jupyter notebooks for exploration
- `/src` - Main source code
- `/tests` - Test files
- `/models` - Trained ML models (gitignored)

## Workflow

1. Write code with type hints
2. Run `black .` for formatting
3. Run `mypy .` for type checking
4. Run `pytest` for testing
5. Update documentation if API changed

## Important

- Never commit large data files or models
- Use DVC for data version control
- All experiments should be logged in notebooks
- Random seeds should be set for reproducibility

# React Native Mobile App

## Stack

- React Native 0.73
- TypeScript
- Expo SDK 50
- React Navigation
- Zustand (state management)

## Commands

- `npm start` - Start Expo dev server
- `npm run ios` - Run on iOS simulator
- `npm run android` - Run on Android emulator
- `npm test` - Run Jest tests
- `npm run lint` - ESLint
- `npm run typecheck` - TypeScript check

## Code Conventions

- Components in PascalCase
- Files in kebab-case
- Use absolute imports via tsconfig paths
- Prefer hooks over class components
- StyleSheet.create for styles (no inline styles)

## Project Structure

- `/src/screens` - Screen components
- `/src/components` - Reusable components
- `/src/navigation` - Navigation config
- `/src/stores` - Zustand stores
- `/src/api` - API client
- `/src/utils` - Helper functions
- `/src/types` - TypeScript types

## Platform-Specific Code

- Use `.ios.tsx` and `.android.tsx` for platform-specific files
- Check Platform.OS for runtime platform checks
- Test on both iOS and Android

## Performance

- Use React.memo for expensive components
- Optimize FlatList with getItemLayout
- Avoid inline functions in render
- Use Flipper for debugging

## Testing

- Jest + React Native Testing Library
- Test user interactions, not implementation
- Mock native modules when needed

# RESTful API Server

## Stack

- Node.js 20
- Express.js
- TypeScript
- Prisma ORM
- PostgreSQL
- Redis (caching)

## Commands

- `npm run dev` - Dev server with hot reload
- `npm run build` - Compile TypeScript
- `npm start` - Production server
- `npm test` - Run tests (Jest)
- `npm run migrate` - Run DB migrations
- `npm run seed` - Seed database

## Code Standards

- Use async/await, not callbacks
- Proper error handling with try-catch
- Validate input with Zod
- Use dependency injection
- Write JSDoc comments for public APIs

## Project Structure

- `/src/routes` - Express routes
- `/src/controllers` - Request handlers
- `/src/services` - Business logic
- `/src/models` - Database models
- `/src/middleware` - Express middleware
- `/src/utils` - Helper functions
- `/src/types` - TypeScript types

## API Design Principles

- RESTful endpoints (/api/v1/users)
- Consistent response format
- Proper HTTP status codes
- Pagination for list endpoints
- Rate limiting enabled

## Error Handling

- Custom error classes
- Centralized error middleware
- Log errors to console (dev) and file (prod)
- Never expose stack traces in production

## Security

- Helmet.js for HTTP headers
- CORS configured properly
- JWT for authentication
- bcrypt for password hashing
- Input validation on all endpoints

## Testing

- Unit tests for services
- Integration tests for routes
- Use test database
- Mock external APIs

# Fullstack Monorepo

## Stack

- Turborepo
- pnpm workspaces
- TypeScript

## Packages

- `apps/web` - Next.js frontend
- `apps/api` - Express backend
- `packages/ui` - Shared React components
- `packages/config` - Shared configs (ESLint, TypeScript)
- `packages/database` - Prisma schema

## Commands (from root)

- `pnpm dev` - Run all apps in dev mode
- `pnpm build` - Build all packages
- `pnpm test` - Run all tests
- `pnpm lint` - Lint all packages
- `pnpm typecheck` - Type check all packages

## Workspace Commands

- `pnpm --filter web dev` - Run web app only
- `pnpm --filter api build` - Build API only
- `pnpm add <pkg> --filter web` - Add dependency to web

## Code Sharing

- Use workspace protocol: `"ui": "workspace:*"`
- Shared types in `packages/types`
- Shared utilities in `packages/utils`

## Workflow

1. Make changes in appropriate package
2. Run typecheck: `pnpm typecheck`
3. Run affected tests: `turbo test --filter=...^HEAD`
4. Build: `turbo build`

## Important

- Changes in `packages/*` affect multiple apps
- Run `turbo prune --scope=web` for deployments
- Use `turbo run` for caching benefits
- Never import from `apps/*` in `packages/*`

## CI/CD

- Vercel for frontend
- Railway for backend
- GitHub Actions for CI
- Turborepo remote caching enabled

# Open Source Library

## Project Info

- Library for [specific purpose]
- Published on npm as `@org/package-name`
- Follows semver versioning

## Commands

- `npm run dev` - Watch mode for development
- `npm run build` - Build for production
- `npm run test` - Run test suite
- `npm run test:watch` - Watch mode testing
- `npm run docs` - Generate documentation
- `npm run publish:patch` - Publish patch version

## Code Quality

- 100% TypeScript
- JSDoc comments for all public APIs
- Examples in documentation
- Zero dependencies (if possible)

## Testing

- Vitest for unit tests
- Test coverage >90%
- Test all public APIs
- Test edge cases and errors

## Documentation

- README.md with usage examples
- API reference in `/docs`
- Changelog follows Keep a Changelog format
- Migration guides for breaking changes

## Publishing Checklist

1. Update version in package.json
2. Update CHANGELOG.md
3. Run `npm run build`
4. Run `npm test`
5. Run `npm run docs`
6. Create git tag
7. Push to GitHub
8. Run `npm publish`

## Contribution Guidelines

- Fork and PR workflow
- Discuss major changes in issues first
- Add tests for new features
- Update documentation
- Sign commits

# ML Project - PyTorch

## Environment

- Python 3.10
- CUDA 12.1
- PyTorch 2.1
- Weights & Biases for experiment tracking

## Setup

- `conda env create -f environment.yml`
- `conda activate ml-project`
- `wandb login` - Authenticate W&B

## Training Commands

- `python train.py --config configs/base.yaml` - Train model
- `python train.py --resume checkpoint.pth` - Resume training
- `python eval.py --checkpoint best.pth` - Evaluate model

## Code Structure

- `/configs` - Training configurations (YAML)
- `/data` - Dataset loaders
- `/models` - Model architectures
- `/trainers` - Training loops
- `/utils` - Helper functions
- `/notebooks` - Exploration notebooks

## Best Practices

- Set random seeds for reproducibility
- Log all hyperparameters to W&B
- Save checkpoints every N epochs
- Use mixed precision training (AMP)
- Profile code before optimizing

## Experiment Tracking

- Every run logged to W&B
- Include: hyperparameters, metrics, artifacts
- Tag experiments meaningfully
- Document failed experiments

## Data

- Raw data in `/data/raw` (gitignored)
- Processed data in `/data/processed`
- Use DataLoader with num_workers=4
- Augmentation in dataset class

## Model Development

1. Start with baseline model
2. Add complexity incrementally
3. Validate on dev set frequently
4. Ablation studies for each component
5. Document architectural choices

## Deployment

- Export to ONNX format
- Optimize with TensorRT (if GPU)
- Benchmark inference speed
- Package with Docker

# AI INSTRUCTIONS

## Core Guidelines

- Ignore GEMINI.md
- Use code-searcher subagent for context efficiency
- Validate tool results before proceeding

## Memory Bank System

- CLAUDE-activeContext.md - Current session context
- CLAUDE-patterns.md - Code patterns
- CLAUDE-decisions.md - Key decisions

## Preferred Commands

✅ RECOMMENDED: fd, rg (fast)
❌ AVOID: tree, find, grep (slow)

# [Project Name] - Claude Development Rules

## Tech Stack

- [List all technologies]

## Critical Constraints

- [Must-follow rules]
- [Security requirements]
- [Performance requirements]

## Validation Checkpoints

- [ ] Typecheck passed
- [ ] Tests passed
- [ ] Linting clean

## Code Standards

- [Naming conventions]
- [File structure]
- [Error handling patterns]

# Kotlin Multiplatform Project

## Architecture

- Shared business logic in commonMain
- Platform-specific UI in androidMain/iosMain

## Gradle Commands

- `./gradlew build` - Build all targets
- `./gradlew :shared:testDebugUnitTest` - Run shared tests
- `./gradlew :androidApp:assembleDebug` - Build Android

## Code Organization

- `/shared` - KMP shared code
- `/androidApp` - Android-specific
- `/iosApp` - iOS-specific

## Important Notes

- Use expect/actual for platform-specific code
- Common code should be platform-agnostic
- Test on all target platforms

# IntelliJ IDEA Plugin Development

## Build Commands

- `./gradlew buildPlugin` - Build plugin
- `./gradlew runIde` - Run IDE with plugin
- `./gradlew test` - Run tests

## Plugin Structure

- `/src/main/kotlin` - Plugin source
- `/src/main/resources/META-INF/plugin.xml` - Plugin descriptor

## Coding Patterns

- Use IntelliJ Platform SDK APIs
- Follow JetBrains plugin guidelines
- Implement actions, listeners, services

## Testing

- Use light platform tests
- Mock IntelliJ components
- Test actions and UI

# AWS MCP Server

## Environment Setup

- Python 3.11+
- Poetry for dependencies
- AWS CLI configured

## Development

- `poetry install` - Install dependencies
- `poetry run pytest` - Run tests
- `poetry run mypy .` - Type check

## Security

- Never commit AWS credentials
- Use IAM roles when possible
- Rotate secrets regularly

## AWS Services

- S3 for storage
- Lambda for compute
- DynamoDB for data

## Important

- All AWS calls must have error handling
- Use boto3 for AWS SDK
- Log all AWS API calls

# Global Claude Code Instructions

## General Preferences

- Concise responses
- No emojis unless requested
- Show code diff when editing files

## Common Commands

- `/clear` - Clear context
- `/compact` - Compress context
- `/cost` - Check token usage

## Always Check

- File permissions before writing
- Existing tests before modifying code
- Git status before committing

# [Project] Specific Instructions

## This Project Uses

- [Specific tech stack]
- [Specific conventions]

## Before Starting

1. Read CLAUDE-activeContext.md
2. Check current branch
3. Review recent commits

## After Completing Task

1. Update CLAUDE-activeContext.md
2. Run tests
3. Commit with conventional commit message

# Technology: [Name]

## Official Documentation Research

- Read official docs thoroughly
- Identify best practices
- Note common pitfalls

## Real-World Patterns

- Study popular open-source projects
- Extract common patterns
- Document anti-patterns to avoid

## Domain-Specific Rules

- [Technology-specific conventions]
- [Common gotchas]
- [Performance tips]

## Code Examples

- [Minimal working example]
- [Common use cases]
- [Edge cases]

{
  "permissions": {
    "deny": [
      {
        "tool": "Write",
        "patterns": [".env*", "package-lock.json"]
      }
    ]
  },
  "environment": {
    "NODE_ENV": "development"
  },
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write $(jq -r '.tool_input.file_path // empty')"
          },
          {
            "type": "command",
            "command": "npx next lint --fix $(jq -r '.tool_input.file_path // empty') || exit 0"
          }
        ]
      }
    ]
  },
  "mcpServers": {
    "next-devtools": {
      "command": "npx",
      "args": ["-y", "next-devtools-mcp@latest"]
    }
  }
}

# Next.js Project Guidelines

When starting work on this project, ALWAYS call the `init` tool
from next-devtools-mcp FIRST.

## Coding Standards

- Use TypeScript
- Functional components only
- Tailwind CSS for styling
- No inline styles

## File Organization

- Components in `/components`
- Pages in `/pages`
- Utilities in `/lib`

## Development Commands

- `npm start` - Dev server with hot reload
- `npm run build` - Production build

{
  "permissions": {
    "deny": [
      {
        "tool": "Bash",
        "patterns": ["rm -rf*", "DROP DATABASE*"]
      }
    ]
  },
  "environment": {
    "NODE_ENV": "development",
    "LOG_LEVEL": "debug"
  },
  "mcpServers": {
    "postgres": {
      "command": "mcp-server-postgres",
      "args": ["postgresql://localhost:5432/devdb"]
    }
  }
}

# API Server Project

## Database

- PostgreSQL 14
- Use `postgres` MCP for queries
- Migrations in `/migrations`

## API Design

- RESTful endpoints
- Express.js
- OpenAPI spec in `/docs`

## Error Handling

- Always use try-catch
- Return proper HTTP status codes
- Log errors to console

## Testing

- Jest for unit tests
- Supertest for API tests
- Run tests before committing

node_modules/
dist/
build/
.next/
coverage/
*.log
.env*
*.lock
package-lock.json
yarn.lock

claude

> /clear

claude

> /compact "최근 변경사항과 열린 TODO 정리해줘"

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npm run format"
          }
        ]
      }
    ]
  }
}

{
  "environment": {
    "GITHUB_TOKEN": "ghp_xxxxx",
    "DATABASE_URL": "postgresql://localhost:5432/mydb"
  },
  "preferences": {
    "verbose": true
  }
}

.claude/settings.local.json

# Monorepo Project

## Structure

- `/packages/web` - Next.js frontend
- `/packages/api` - Express backend
- `/packages/shared` - Shared utilities

## General Rules

- pnpm 사용
- Turborepo로 빌드
- 공통 ESLint/Prettier 설정

# Frontend Package

## Specific to Frontend

- React 18
- Next.js 14
- Tailwind CSS

When working here, focus on UI/UX and client-side logic.

# Backend Package

## Specific to Backend

- Express.js
- PostgreSQL
- JWT auth

When working here, focus on API endpoints and database logic.

{
  "environment": {
    "API_KEY": "sk-1234567890abcdef"
  }
}

{
  "environment": {
    "API_KEY": "${API_KEY}"
  }
}

export API_KEY=sk-1234567890abcdef

너: "이 프로젝트는 Next.js 블로그고, MDX 쓰고..."

# Project Overview

This is a Next.js blog using MDX for content.

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npm run format && npm run lint:fix"
          }
        ]
      }
    ]
  }
}

# Dependencies
node_modules/
vendor/

# Build
dist/
build/
.next/
out/

# Tests
coverage/
__tests__/__snapshots__/

# Logs
*.log
logs/

# OS
.DS_Store
Thumbs.db

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write $(jq -r '.tool_input.file_path // empty')"
          }
        ]
      }
    ]
  }
}

# Project Instructions

## Coding Style

- Write clean, readable code
- Add comments for complex logic

## Testing

- Write tests for critical functions

{
  "permissions": {
    "deny": [
      {
        "tool": "Write",
        "patterns": [".env*", "*.lock"]
      }
    ]
  },
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write $(jq -r '.tool_input.file_path // empty')"
          },
          {
            "type": "command",
            "command": "npx eslint --fix $(jq -r '.tool_input.file_path // empty') || exit 0"
          }
        ]
      }
    ],
    "SessionStart": [
      {
        "matcher": ".*",
        "hooks": [
          {
            "type": "command",
            "command": "git fetch && git status -sb"
          }
        ]
      }
    ]
  },
  "mcpServers": {
    "github": {
      "command": "mcp-server-github",
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "postgres": {
      "command": "mcp-server-postgres",
      "args": ["${DATABASE_URL}"]
    }
  }
}

# Fullstack Project

## Stack

- Frontend: Next.js + TypeScript + Tailwind
- Backend: Express + PostgreSQL
- Auth: JWT

## Workflow

1. Feature 브랜치 생성
2. 코드 작성 + 테스트
3. PR 생성
4. 리뷰 후 머지

## Conventions

- Conventional Commits
- ESLint + Prettier
- 100% test coverage for critical paths

## Commands

- `npm run dev:frontend` - Frontend dev server
- `npm run dev:backend` - Backend dev server
- `npm test` - Run all tests
- `npm run db:migrate` - Run migrations