Prompts

// memdir/memdir.ts - loadMemoryPrompt()
1. Load MEMORY.md from project's .claude/ directory
2. Truncate to 200 lines max (warn if truncated)
3. Inject as dynamic system prompt section
4. Cache until /clear or /compact

// MEMORY.md format:
---
name: memory_name
description: one-line description
type: user|feedback|project|reference
---
Memory content here...

// AgentDefinition type
type AgentDefinition = {
  agentType: string       // "general-purpose", "Explore", "Plan"
  description: string     // User-facing purpose
  whenToUse: string       // When to spawn
  tools: string[]         // Allowlist (* = all)
  disallowedTools: string[]
  prompt: string          // Custom system prompt
  model: string           // inherit/sonnet/opus/haiku
  effort: number          // 1-5
  maxTurns: number        // Max iterations
  isolation: string       // worktree/remote
  memory: string          // user/project/local
  background: boolean     // Run in background
}

// Good: Specific, contextualized
Agent({
  description: "Fix auth token refresh",
  prompt: "The JWT refresh in src/auth/refresh.ts:45 is
    using the wrong endpoint. Change it from /v1/token
    to /v2/token. The migration was done in PR #234.
    Run the auth tests after fixing.",
  subagent_type: "general-purpose"
})

// Bad: Vague, lazy delegation
Agent({
  description: "fix the bug",
  prompt: "There's a bug somewhere in auth. Find and fix it."
})

<task-notification>
  <task-id>{agentId}</task-id>
  <status>completed</status>
  <summary>Fixed auth refresh endpoint</summary>
  <result>Changed /v1/token to /v2/token in...</result>
  <usage>
    <total_tokens>15432</total_tokens>
    <tool_uses>8</tool_uses>
    <duration_ms>45000</duration_ms>
  </usage>
</task-notification>

// Pattern: src/tools/{ToolName}/prompt.ts
export const TOOL_NAME = "Read"
export const DESCRIPTION = `Reads a file from the
  local filesystem...`

// Some tools generate prompts dynamically:
export function getPrompt(context): string {
  return `...${context.features}...`
}

// How skills are invoked:
Skill({ skill: "commit" })
Skill({ skill: "commit", args: "-m 'Fix bug'" })
Skill({ skill: "review-pr", args: "123" })
Skill({ skill: "ms-office-suite:pdf" })  // namespaced

# .claude/agents/my-skill.md
---
description: "What this skill does"
whenToUse: "When user asks to..."
tools: ["Read", "Edit", "Bash"]
model: "sonnet"
---

You are a specialized agent for...
[Full prompt instructions here]

# .claude/agents/security-review.md
---
description: "Security-focused code review"
whenToUse: "When user asks for security review"
tools: ["Read", "Grep", "Glob", "Bash"]
---

You are a security-focused code reviewer. Analyze the
codebase for:

1. SQL injection vulnerabilities
2. XSS attack vectors
3. Authentication bypasses
4. Insecure dependencies
5. Secrets in source code

For each finding, provide:
- File and line number
- Severity (Critical/High/Medium/Low)
- Description of the vulnerability
- Suggested fix with code

# .claude/agents/migrate-db.md
---
description: "Generate database migrations"
whenToUse: "When user needs schema changes"
tools: ["Read", "Write", "Bash", "Grep"]
model: "opus"
---

You are a database migration specialist.
Read the current schema, understand the requested
changes, and generate a safe migration file.

Rules:
- Always create reversible migrations
- Add NOT NULL with defaults
- Create indexes concurrently
- Never drop columns in production

// Tell Claude to parallelize research
"Search the codebase for all API endpoints and their
authentication methods. Use multiple agents in parallel
to check src/routes/, src/api/, and src/middleware/"

// Tell Claude to plan first
"Plan the implementation for adding WebSocket support.
Use a Plan agent to design the architecture before
writing any code."

// Tell Claude to verify
"Implement the feature, then spawn a verification agent
to independently check the implementation."

# CLAUDE.md

## Project Overview
This is a Next.js e-commerce app with PostgreSQL.

## Architecture
- /src/app/ - Next.js App Router pages
- /src/lib/ - Shared utilities and DB client
- /src/components/ - React components (use shadcn/ui)

## Conventions
- Use TypeScript strict mode
- All API routes return { data, error } shape
- Tests use Vitest, not Jest
- Commits follow Conventional Commits

## Common Commands
- npm run dev - Start dev server
- npm run test - Run tests
- npm run db:migrate - Run migrations

I need to add a user notification system:

1. Create a notifications table in the database
2. Add a NotificationService in src/services/
3. Create API endpoints:
   - GET /api/notifications (list)
   - POST /api/notifications/:id/read (mark read)
   - DELETE /api/notifications/:id (dismiss)
4. Add a notification bell component in the header
5. Write tests for the service and API

Use the existing auth middleware for all endpoints.
Follow the patterns in src/services/UserService.ts.

// Save project conventions
"Remember: we use pnpm, not npm. All tests should
use the factory pattern from tests/factories/"

// Save architectural decisions
"Remember: we decided to use event sourcing for the
payment system because of audit requirements"

// Save personal preferences
"Remember: I prefer concise responses without
trailing summaries. Show me the diff, not an explanation."