• .cursor/rules — first system prompt
• I-P-O diagram — first architecture view
• Smoke test — 3 pass/fail checks

• CLAUDE.md — richer context file
• Agentic loop — Plan → Act → Observe
• TDD & eval checklist — structured verification

40%

Planning & Research

The agent proposes a complete step-by-step plan and stops — it waits for your approval before writing a single line of code.

/plan
# after claude code starts
shift+tab twice

• Task touches more than one file
• Involves user data or security
• You’re not sure what the right approach is

• Terminal-native agent (also has a desktop app)
• Whole-project awareness
• Autonomous multi-step execution
• Plan Mode for complex tasks
• Best for: large changes, refactoring, multi-file work

• IDE with AI built in (also has a CLI version)
• Inline editing & autocomplete with whole-project awareness
• Fast file-level feedback
• Visual diff review
• Come with more model options
• Best for: focused edits, learning code, quick fixes

# My App

Write good code. Use Python.
Make it work.
Don't break things.

Vague. No project info. Wastes a dedicated memory slot the agent reads every session.

# Project: GIX Staff Portal

## Stack
- Python 3.11, Streamlit, SQLite

## Coding Standards
- PEP 8, 4-space indent
- Type annotations on all functions

## Constraints
- No external APIs (offline-first)
- User-friendly error messages

YES

Put it in CLAUDE.md

NO

Don’t bother

• You write your own CLAUDE.md
• You create commands one at a time
• You configure hooks manually
• Your setup stays in one project

• 156 pre-built skills auto-loaded
• 13 specialized agents ready to invoke
• Hierarchical rules across all projects
• 10+ hooks enforcing quality silently
• 33+ slash-command workflows

• trigger: auto — the skill activates without being invoked
• The “hard gate” — the skill literally refuses to write code until design is approved
• Skills can be domain-specific: python-patterns, scientific-visualization, metabolomics
• Or process-oriented: brainstorming, TDD enforcement, debugging workflows

• Planner — enforces design-first, creates implementation plans
• Code Reviewer — reviews diffs for correctness, style, security
• Security Reviewer — focused threat modeling and vulnerability scan

---
name: security-reviewer
model: claude-sonnet-4
tools: [Read, Grep, Bash]
---
You are a security-focused reviewer…

• Common rules apply to every project, every language
• Language-specific extensions: typescript/, python/, golang/
• Example: “Always use type annotations” in python/ rules
• Example: “Prefer interfaces over types” in typescript/ rules

~/.claude/rules/
├── common/          # Always active
├── python/
│   └── standards.md # Active in .py
└── typescript/
    └── standards.md # Active in .ts

Give the agent a headless browser. It can navigate pages, click buttons, extract content, and test web apps just like a human.

Connect your agent to design files. It can read component structures, extract styles, and turn designs into code directly.

1. Red: Write a test that fails (no code exists).
2. Green: Write just enough code to pass.
3. Refactor: Clean up the code.

• Clearly defines the success condition.
• Prevents AI from testing only what it built.
• Forces you to plan before execution.

def get_forecast(city: str):
    # Hardcoded to pass the assertion
    # Just enough code to be "green"
    return [
        {"high": 70, "low": 50},
        {"high": 72, "low": 51},
        {"high": 68, "low": 49},
        {"high": 65, "low": 48},
        {"high": 75, "low": 55}
    ]

def get_forecast(city: str):
    # Now integrate the real API
    # The test ensures we don't break the shape
    data = fetch_weather_api(city)
    return [
        {"high": day.max_temp, "low": day.min_temp}
        for day in data.days[:5]
    ]

• Business logic with defined inputs/outputs
  e.g. calculate_discount(price, tier)
• Data transformations
  Parsing CSV, cleaning API responses
• Bug fixes — write a test that reproduces the bug first
• AI-generated code — define the contract before the agent writes

# Step 1: Write a test that reproduces the bug
def test_handles_negative_price():
    result = calculate_discount(-10, "gold")
    assert result == 0  # Negative price should return 0

# Step 2: Run it — it FAILS (bug confirmed!)
# Step 3: Fix the function
def calculate_discount(price: float, tier: str) -> float:
    if price <= 0:
        return 0
    discount = TIER_RATES.get(tier, 0)
    return round(price * (1 - discount), 2)

• Exploratory prototyping — you don’t know what you’re building yet
• UI layout and visual design — hard to assert pixel positions
• One-off scripts or throwaway code
• External API integration where the response shape is unknown

• Prototype first, then add tests once the design stabilizes
• Use manual testing or screenshot testing for UI
• For API integration: write integration tests after you understand the response shape
• Remember the 40/20/40 rule — testing always happens, TDD is just one approach