Claude Chat, CoWork,
Code & OpenClaw

npm install -g @anthropic-ai/claude-code

cd ~/my-project
claude

You: "What does this project do?"

Claude wants to run: npm test

  [Allow] [Deny] [Allow always]

/help     - Show all commands
/clear    - Clear conversation
/cost     - Show token usage
/model    - Switch AI models
/compact  - Compress context
/quit     - Exit

cd ~/my-project
claude

# Inside the session:
/init

# Project-level (shared with team)
./CLAUDE.md

# User-level (personal, all projects)
~/.claude/CLAUDE.md

# Project: My App

## Build & Test
- Install: `npm install`
- Dev: `npm run dev`
- Test: `npm test`

## Code Standards
- TypeScript strict mode
- 2-space indentation
- Named exports over defaults

# In CLAUDE.md:
See @README.md for overview.
See @docs/api-guide.md for API docs.

# View auto memory:
/memory

# Browse files:
ls ~/.claude/projects/my-project/memory/

# MCP gives Claude the ability to:
# - Read/write Notion pages
# - Send/read Slack messages
# - Query databases
# - Pull Figma designs
# - Create GitHub PRs

claude mcp add --transport http notion \
  https://mcp.notion.com/mcp

# Slack
claude mcp add slack --transport http \
  https://mcp.slack.com/mcp

# GitHub
claude mcp add --transport http github \
  https://api.githubcopilot.com/mcp/

# Context7 (library docs)
claude mcp add --transport http context7 \
  https://mcp.context7.com/mcp

# List all servers
claude mcp list

# Remove a server
claude mcp remove notion

"Find the latest design specs in Figma
 and implement the button component."

"Read the PRD from Notion and create
 GitHub issues for each feature."

# File: .claude/skills/deploy.md
---
name: deploy
description: Deploy the app
---

## Steps
1. Run `npm run build`
2. Run `npm test` - abort if fail
3. Run `npm run deploy`
4. Verify at production URL

# Project skills (shared)
mkdir -p .claude/skills

# Personal skills (all projects)
mkdir -p ~/.claude/skills

# .claude/skills/code-review.md
---
name: code-review
description: Review staged changes
---

Review staged git changes:
1. Run `git diff --staged`
2. Check for security, performance,
   error handling, style issues
3. Provide summary with severity

# Inside Claude Code session:
/deploy
/code-review

.claude/skills/
  generate-api/
    generate-api.md  # The skill
    template.ts      # Template
    schema.json      # Config

# Context window: ~200,000 tokens
# Sweet spot: 20,000-80,000 tokens
# Above that: diminishing returns
# Near limit: significant degradation

# ~/.claude/projects/my-app/memory/
MEMORY.md              # Index
debugging-patterns.md  # On demand
api-conventions.md     # On demand
test-strategies.md     # On demand

# .claude/rules/react-patterns.md
---
globs: ["src/components/**/*.tsx"]
---

Good:
```tsx
export function UserCard({ user }: Props) {
  return <Card>...</Card>;
}
```

Bad:
```tsx
export default function(props: any) {
  return <div>...</div>;
}
```

# .claude/rules/api-routes.md
---
globs: ["src/api/**/*.ts"]
---
All API routes must:
- Validate input with Zod
- Return typed responses
- Include error handling

# Audit your context:
# 1. Is this still relevant?
# 2. Can this be a scoped rule?
# 3. Can this be a skill (on-demand)?
# 4. Is this duplicating other context?

# Built-in subagents:
# Explore - Fast, read-only (Haiku model)
# Plan    - Creates structured plans
# General - Handles delegated tasks

# .claude/agents/code-reviewer.md
---
name: code-reviewer
description: Reviews code for quality
tools:
  - Read
  - Glob
  - Grep
model: sonnet
---
You are a code reviewer. Focus on:
- Security vulnerabilities
- Performance issues
- Error handling gaps

# Claude uses Explore automatically:
"Where is the authentication middleware?"
"Find all files that import User model."

# Multi-phase skill:
# Phase 1: Explore scans codebase
# Phase 2: code-reviewer reviews each
# Phase 3: Main agent implements fixes
# Phase 4: Run tests to verify

---
name: safe-researcher
tools: [Read, Glob, Grep]
disallowedTools: [Edit, Bash]
permissionMode: plan
maxTurns: 20
---

# Simple one-shot
claude -p "Explain what this project does"

# With a specific model
claude -p "Summarize README.md" --model sonnet

# JSON output
claude -p "List all TODO comments" \
  --output-format json

# Stream JSON messages
claude -p "Analyze this file" \
  --output-format stream-json

claude -p "Extract all API endpoints" \
  --output-format json \
  --json-schema '{
    "type": "object",
    "properties": {
      "endpoints": {
        "type": "array",
        "items": {
          "type": "object",
          "properties": {
            "method": {"type":"string"},
            "path": {"type":"string"}
          }
        }
      }
    }
  }'

# Pipe to jq for filtering
claude -p "List files" --output-format json \
  | jq '.result'

# Pipe to another script
claude -p "Generate SQL migration" \
  | psql my_database

# Use in a bash script
RESULT=$(claude -p "What is the main entry?")
echo "Entry point: $RESULT"

# CI/CD safe mode - read only
claude -p "Review this PR" \
  --allowedTools Read,Glob,Grep \
  --output-format json

# Allow specific tools
claude -p "Fix linting errors" \
  --allowedTools Read,Edit,Bash

# Resume last session
claude --resume

# Resume specific session
claude --resume session_abc123

# Install Playwright MCP
npx @anthropic-ai/claude-code mcp add \
  playwright \
  --transport stdio \
  -- npx @playwright/mcp@latest

# In a Claude Code session:
"Navigate to https://example.com and
 take a screenshot of the homepage."

"Go to our staging site and screenshot
 the login page on mobile viewport."

"Go to our competitor's pricing page
 and extract all plan names and prices
 into a JSON file."

"Scrape the top 10 results from
 Hacker News and summarize them."

"Go to our signup page, fill in test
 data, and verify the form submits
 without errors."

"Log into the admin panel and check
 if there are any pending approvals."

"Navigate to our invoice page for
 order #12345 and save it as a PDF."

"Generate a PDF report of the
 analytics dashboard."

# Enable agent teams
export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

# Add to your shell profile for persistence:
echo 'export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1' \
  >> ~/.zshrc

claude

# Inside the session:
"I need you to work with 2 teammates.
 Agent A: Implement the user API.
 Agent B: Write tests for the API.
 You: Coordinate and review."

# Inline (default) - output in main terminal
# tmux - each agent in a tmux pane
# hidden - agents work silently

# Set in .claude/settings.json:
{
  "agentTeams": {
    "display": "tmux"
  }
}

"Create a team of 3:

 Teammate 1 (Frontend):
   Build the React components for
   the dashboard page.

 Teammate 2 (Backend):
   Create the API endpoints for
   dashboard data.

 Teammate 3 (Tests):
   Write integration tests for
   the dashboard feature."

"Review this PR with 3 specialists:
 Agent 1: Security review
 Agent 2: Performance review
 Agent 3: Code style review

 Combine all findings into one report."

# Inside Claude Code session:
/loop every 4 hours: Check for new
  GitHub issues labeled 'bug' and
  create a summary in BUGS.md

/remind at 5pm: Run the test suite
  and email me the results.

/remind in 2 hours: Check if the
  deployment completed successfully.

/tasks          # List all scheduled
/tasks cancel 3  # Cancel task #3

# .github/workflows/nightly-review.yml
name: Nightly Code Review
on:
  schedule:
    - cron: '0 2 * * *'  # 2 AM daily
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm i -g @anthropic-ai/claude-code
      - run: |
          claude -p "Review all changes
          from the last 24 hours.
          Create a summary report." \
          --output-format json \
          --allowedTools Read,Glob,Grep \
          > report.json
    env:
      ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

# Claude Desktop supports:
# - Scheduled prompts at specific times
# - Recurring tasks (daily, weekly)
# - Tasks survive app restarts
# - Access to all your MCP servers

# The Ralph Loop pattern:
# 1. Check for new work (GitHub issues,
#    Slack messages, file changes)
# 2. Prioritize and plan
# 3. Execute the highest-priority task
# 4. Commit results and report
# 5. Loop back to step 1

# Implementation:
while true; do
  claude -p "Check GitHub for new issues
    labeled 'auto'. Pick the highest
    priority one. Implement it. Create
    a PR. Move to next." \
    --allowedTools Read,Edit,Bash,Glob,Grep \
    --max-turns 50
  sleep 300  # Wait 5 minutes
done

# Long-running autonomous task:
claude -p "Refactor the entire auth
  module to use the new token system.
  1. Read all auth-related files
  2. Create a migration plan
  3. Implement changes file by file
  4. Update all tests
  5. Run full test suite
  6. Fix any failures
  7. Create a detailed PR description" \
  --max-turns 200 \
  --allowedTools Read,Edit,Bash,Glob,Grep

# .claude/skills/skill-generator.md
---
name: skill-generator
description: Generates new skills
---

Analyze the user's recent Claude Code
sessions (from memory files) and:
1. Identify repeated patterns
2. For each pattern, generate a skill
3. Save to .claude/skills/
4. Test each skill with a dry run
5. Report what was created

# orchestrator.sh
#!/bin/bash
# Master orchestrator that runs nightly

# Phase 1: Triage
claude -p "Review all open issues and
  categorize by: bug, feature, docs" \
  --output-format json > triage.json

# Phase 2: Assign to specialists
for issue in $(jq -r '.bugs[]' triage.json); do
  claude -p "Fix bug: $issue" \
    --max-turns 30 &
done
wait

# Phase 3: Review all changes
claude -p "Review all uncommitted changes
  and create a summary PR"

# Event-driven architecture:
# 1. GitHub webhook triggers
# 2. Script receives event
# 3. Claude Code processes it
# 4. Results posted back

# Example: Auto-review every PR
# In GitHub Actions:
on:
  pull_request:
    types: [opened, synchronize]
jobs:
  auto-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: |
          claude -p "Review this PR.
          Focus on security and perf.
          Post review comments." \
          --allowedTools Read,Glob,Grep