Set Up Claude Code AI OS

Claude Code CLI
├── Local codebase access (read/write/execute)
├── Git integration (commit, branch, history)
├── Skills (Python scripts, executables)
├── Agents (configured Claude instances)
├── MCP servers (external tool connections)
└── Memory system (persistent context)

# Download installer
$url = "https://github.com/anthropics/claude-code/releases/latest/download/claude-code-windows.exe"
Invoke-WebRequest -Uri $url -OutFile claude-code.exe

# Install
.\claude-code.exe

# Verify
claude-code --version

# via Homebrew
brew tap anthropics/claude-code
brew install claude-code

# or download directly
curl -L https://github.com/anthropics/claude-code/releases/latest/download/claude-code-mac.tar.gz | tar xz
chmod +x claude-code
sudo mv claude-code /usr/local/bin/

# Download
wget https://github.com/anthropics/claude-code/releases/latest/download/claude-code-linux.tar.gz
tar xz claude-code
chmod +x claude-code
sudo mv claude-code /usr/local/bin/

claude-code config set-key
# Paste your API key from https://claude.ai/account/api
# Key is stored in ~/.claude-code/config.json (encrypted)

claude-code --version
# Should not show "No API key configured"

cd /path/to/my-project
mkdir -p .claude/{skills,agents,mcp,rules,templates}

# My Project — Claude Code Config

## Project Summary
Local AI stack setup, documentation, automation.

## Codebase Structure
- src/ — Source code
- docs/ — Documentation
- .claude/ — Claude Code config

## Rules
1. Always commit changes with descriptive messages
2. Run tests before committing: `npm test`
3. Update docs after changes
4. No secrets in version control

## Key Paths
- Main app: src/app.py
- Tests: tests/
- Docs: docs/

## External Resources
- API docs: https://docs.example.com
- Architecture: docs/ARCHITECTURE.md

---
name: analyze-code
description: Analyze Python code for bugs, performance issues, and style problems
version: 1.0.0
requires: []
produces: [analysis-report]
model: sonnet
context: fork
allowed-tools: [Read, Grep, Bash]
last-verified: 2026-03-21
---

# Analyze Code Skill

Analyzes Python files for issues: bugs, style, performance, security.

## Usage

```bash
/analyze-code src/app.py

{
  "file": "src/app.py",
  "issues": [
    {
      "line": 42,
      "type": "style",
      "message": "Line too long (105 > 88)",
      "fix": "Break into multiple lines"
    }
  ],
  "summary": "3 issues found"
}

/analyze-code path/to/file.py

Create `.claude/skills/analyze-code/scripts/analyze.py`:

```python
#!/usr/bin/env python3
"""Analyze Python code for issues."""

import ast
import sys
import json
from pathlib import Path

def analyze_file(filepath):
    """Analyze a Python file."""
    path = Path(filepath)
    if not path.exists():
        return {"error": f"File not found: {filepath}"}

    with open(path) as f:
        content = f.read()

    issues = []

    # Check line length
    for i, line in enumerate(content.split('\n'), 1):
        if len(line) > 88:
            issues.append({
                "line": i,
                "type": "style",
                "message": f"Line too long ({len(line)} > 88)",
                "content": line[:50] + "..."
            })

    # Parse AST
    try:
        tree = ast.parse(content)
    except SyntaxError as e:
        return {"error": f"Syntax error: {e}"}

    # Find long functions
    for node in ast.walk(tree):
        if isinstance(node, ast.FunctionDef):
            func_len = node.end_lineno - node.lineno
            if func_len > 50:
                issues.append({
                    "line": node.lineno,
                    "type": "style",
                    "message": f"Function too long ({func_len} lines)",
                    "name": node.name
                })

        # Check for hardcoded secrets
        if isinstance(node, ast.Constant):
            if isinstance(node.value, str):
                if 'password' in node.value.lower() or 'api' in node.value.lower():
                    issues.append({
                        "line": node.lineno,
                        "type": "security",
                        "message": "Possible hardcoded secret detected",
                        "fix": "Use environment variables"
                    })

    return {
        "file": str(path),
        "issues": issues,
        "summary": f"{len(issues)} issues found",
        "status": "ok" if not issues else "warnings"
    }

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print(json.dumps({"error": "Usage: analyze.py <file>"}))
        sys.exit(1)

    result = analyze_file(sys.argv[1])
    print(json.dumps(result, indent=2))

chmod +x .claude/skills/analyze-code/scripts/analyze.py

/analyze-code src/app.py

---
name: developer
description: Full-stack developer with code analysis, debugging, and testing abilities
model: sonnet
tools: [Read, Grep, Glob, Bash, Write, Edit]
disallowedTools: []
skills:
  - analyze-code
  - run-tests
---

# Developer Agent

You are a skilled developer responsible for:
- Writing clean, tested code
- Debugging issues
- Code reviews
- Performance optimization

## Rules

1. Always run tests before committing
2. Add type hints to new functions
3. Document complex logic
4. No hardcoded secrets or API keys

## Workflow

When asked to implement a feature:

1. Ask clarifying questions if needed
2. Design the solution
3. Write code incrementally
4. Run tests with `/run-tests`
5. Analyze code with `/analyze-code`
6. Commit with descriptive message

## Tools Available

- File operations (read/write/edit)
- Git commands (commit, branch, log)
- Terminal (bash, python)
- Custom skills (analyze-code, run-tests)

{
  "name": "github",
  "type": "server",
  "command": "mcp-github",
  "args": ["--token=${GITHUB_TOKEN}"],
  "enabled": true
}

# macOS/Linux
export GITHUB_TOKEN="ghp_xxxxxxxxxxxx"

# Windows PowerShell
$env:GITHUB_TOKEN = "ghp_xxxxxxxxxxxx"

# Verify
echo $env:GITHUB_TOKEN

# Memory Index

## Project State
- Current sprint: Q2 2026
- Active features: Authentication refactor
- Known issues: Slow dashboard queries

## Team
- Project lead: Alice ([email protected])
- DevOps: Bob ([email protected])
- Key contact: [email protected]

## Decisions
- Stack: Python + React + PostgreSQL
- Deployment: Docker + Kubernetes
- Testing: pytest + Jest

## Key Paths
- App entry: src/app.py
- Config: config/settings.py
- Tests: tests/
- Docs: docs/ARCHITECTURE.md

# Daily Log: 2026-03-21

## Events
- 10:30 Implemented user authentication
- 11:15 Added password reset flow
- 14:00 Fixed SQL injection in search
- 16:45 All tests passing

cd /path/to/project
claude-code

# Claude is ready

Implement a function to validate email addresses.
Add tests, analyze the code, then commit.

claude-code -p "Fix the bug in src/auth.py where login fails for spaces in password"

claude-code --agent developer "Add type hints to src/utils.py"

claude-code "Run /analyze-code src/app.py and report security issues"

my-project/
├── .claude/
│   ├── CLAUDE.md                 # Project instructions
│   ├── memory/
│   │   ├── MEMORY.md             # Persistent facts
│   │   └── logs/
│   │       ├── 2026-03-20.md
│   │       └── 2026-03-21.md
│   ├── agents/
│   │   ├── developer.md
│   │   └── reviewer.md
│   ├── skills/
│   │   ├── analyze-code/
│   │   │   ├── SKILL.md
│   │   │   └── scripts/
│   │   │       └── analyze.py
│   │   └── run-tests/
│   │       ├── SKILL.md
│   │       └── scripts/
│   │           └── test.py
│   ├── mcp/
│   │   ├── github.json
│   │   └── slack.json
│   └── rules/
│       ├── 01-safety.md
│       └── 02-quality.md
├── src/
├── tests/
├── docs/
└── README.md

# Start interactive session
claude-code

# One-shot analysis
claude-code -p "Analyze src/app.py for performance issues"

# With specific agent
claude-code --agent developer "Write a test for the auth module"

# List available agents
claude-code --list-agents

# List available skills
claude-code --list-skills

# Set configuration
claude-code config set model=opus
claude-code config set session-timeout=30

# Check status
claude-code --version
claude-code config show

claude-code config set-key
# Paste your API key