For IDE Agent Power Users Claude Pro $20

Claude Code 2.1 Power User Guide

Terminal-first agentic coding from Anthropic. Built for developers who already use Kilo Code, Kiro.dev, or Antigravity.

What This Guide Covers

TUI vs IDE tradeoffs
Plan Mode workflow
Claude Skills
Boris's workflow
Sub-agents
MCP servers
Usage optimization
GitHub integration

Quick Start

npm install -g @anthropic-ai/claude-code
cd your-project && claude
Full Installation Steps
  1. 1.
    Install Node.js 18+

    Required runtime. Download from nodejs.org

  2. 2.
    Install Claude Code globally
    npm install -g @anthropic-ai/claude-code
  3. 3.
    Navigate to your project & launch
    cd your-project && claude
  4. 4.
    Authenticate

    Browser opens automatically. Log in with your Anthropic account (Pro subscription required).

  5. 5.
    Start coding!

    Type your task or use /help to see commands.

Update to latest: npm update -g @anthropic-ai/claude-code

TUI vs IDE: When to Use What

Claude Code's terminal-first approach vs traditional IDE agents — pick the right tool:

Terminal (Claude Code) Wins

  • Multi-file refactors — renames, migrations, bulk updates
  • Background tasks — tests, builds, monitoring while you work
  • Git workflows!git integration, automated commits/PRs
  • SSH/Remote dev — works anywhere you have a terminal
  • Sub-agents — parallel tasks, code review without context pollution
  • MCP ecosystem — browser, database, API integrations

IDE Agent (Kilo/Kiro/Antigravity) Wins

  • Visual diff review — inline changes, side-by-side compare
  • Single-file edits — quick fixes in current context
  • Debugger integration — breakpoints, variable inspection
  • TypeScript/LSP context — deep symbol understanding
  • Selective accept — cherry-pick individual changes
  • Familiar UI — less learning curve if IDE-native
Power User Pattern: Run Claude Code in a tmux pane alongside your IDE. Use terminal for planning and multi-file work, IDE for review and single-file polish. They sync automatically via deep integration.

IDE Agent Mapping

Translation from your existing workflows:

Concept Kilo/Kiro/Antigravity Claude Code
Workspace Rules .kilorc, .kiro/rules CLAUDE.md (project root)
Global Rules Settings/Config files ~/.claude/CLAUDE.md
Spec-Driven Dev Kiro specs, PRD files Plan Mode + markdown specs
MCP Servers Extension settings .claude/settings.json
Tool Permissions Per-session approvals --allowedTools, --dangerously-skip-permissions
Usage Tracking Antigravity Cockpit /cost, CUStats extension
Background Tasks N/A claude --background

Task Tiers Strategy Boris Cherny's Approach

Categorize tasks to choose the right workflow:

Easy Tasks

One-shot

Bug fixes, small refactors, docs updates

Best tool: @claude on GitHub Issues/PRs

Medium Tasks

Iterative

New features, API integrations, component work

Workflow: Plan Mode → workshop → execute
Success rate: 20-30% → 70-80% with planning

Hard Tasks

Multi-phase

Architecture changes, complex systems, greenfield projects

1. Create spec.md with phases
2. Use Plan Mode to refine
3. Execute phase by phase, manual refinement in IDE

Plan Mode Mastery

Shift + Tab
Toggle Plan Mode

Forces Claude to think through the problem multiple times and outline a technical strategy before writing any code.

PRD-First Workflow

touch docs/feature-spec.md && claude
Example Spec Template
# Feature: [Name]

## Goal
What problem does this solve?

## Success Criteria
- [ ] Criterion 1
- [ ] Criterion 2

## Technical Approach
### Phase 1: Foundation
- Setup, scaffolding, types

### Phase 2: Core Logic
- Main implementation

### Phase 3: Polish
- Error handling, tests, docs

## Non-Goals
What we're NOT building
Pro Tip: Ask Claude to review your spec and suggest improvements before implementation. Plan Mode excels at catching architectural issues early.

Memory System

Three-tier memory hierarchy (like workspace rules in IDE agents):

~/.claude/CLAUDE.md Global

Your personal preferences, coding style, global rules across all projects

./CLAUDE.md Project Root

Project-specific context, architecture decisions, team conventions. Commit this!

./folder/CLAUDE.md Subdirectory

Nested overrides for specific modules or packages

Example CLAUDE.md for Experienced Dev
# Project Context

## Architecture
- Monorepo with pnpm workspaces
- TypeScript strict mode
- React 19 + TanStack Query

## Conventions
- Use `type` over `interface`
- Barrel exports in index.ts
- Error boundaries per route

## Testing
- Vitest for unit tests
- Playwright for E2E
- Test files co-located with source

## Commands
- `pnpm dev` - Start dev server
- `pnpm test` - Run tests
- `pnpm lint` - ESLint + Prettier

## Don't
- No `any` types without comment
- No console.log in production
- No direct DOM manipulation in React
/memory - Quick save to CLAUDE.md

Use during conversations: "Remember that we use Zod for validation" → automatically appends to memory file

Boris Cherny's Workflow Creator's Setup

Now that you understand the core concepts, here's how Claude Code's creator actually uses it. Step-by-step guide to replicate his exact setup:

1 Set Up Folder Structure

your-project/
├── .claude/
├── commands/ # Custom slash commands
├── agents/ # Specialized sub-agents
└── settings.json # MCP & hooks config
├── CLAUDE.md # Project knowledge (~2.5k tokens)
├── frontend/
└── CLAUDE.md # Frontend-specific context
└── backend/
└── CLAUDE.md # Backend-specific context
2 Create Your CLAUDE.md (Boris's Template)
# Project: [Name]

## Tech Stack
- Language: TypeScript
- Framework: Next.js 14
- Database: PostgreSQL + Prisma
- Testing: Vitest, Playwright

## Project Structure
src/
├── app/          # Next.js app router
├── components/   # React components
├── lib/          # Shared utilities
└── server/       # API routes

## Code Conventions
- Use functional components with hooks
- Prefer `type` over `interface`
- Use absolute imports (@/)
- Co-locate tests with source files

## Common Commands
- `pnpm dev` - Start dev server
- `pnpm test` - Run unit tests
- `pnpm lint` - ESLint + Prettier

## Development Workflow
1. Create feature branch from main
2. Write tests first (TDD preferred)
3. Run lint before committing
4. Use conventional commits

## Things to Remember
- Auth uses NextAuth with GitHub provider
- All API routes need rate limiting
- Images served via Cloudinary

## Do NOT
- Use `any` type without justification
- Commit without running tests
- Use npm (we use pnpm)
- Push directly to main
3 Add Boris's Essential Custom Commands
.claude/commands/git-push.md
Check git status and diff.
Create a conventional commit message based on changes.
Push to the current branch.
If remote branch doesn't exist, create it.
.claude/commands/pr.md
Create a pull request for the current branch.
Generate title from branch name and commits.
Write a detailed description with:
- What changed
- Why it changed  
- How to test
Use `gh pr create` command.
.claude/commands/review.md
Review the staged changes for:
- Bugs and logic errors
- Security vulnerabilities
- Performance issues
- Code style violations
Be concise. Only flag real issues.

4 Adopt Boris's Key Habits

  • Always use Plan Mode for medium+ tasks (Shift+Tab before prompting)
  • Keep CLAUDE.md updated — treat it as living documentation the whole team edits
  • Use ! prefix for quick bash commands (e.g., !git status) — output feeds into context
  • Spawn sub-agents for code review to keep main context focused
  • Use @claude on GitHub for simple one-shot tasks (bugs, deps, docs)
"The key is matching the right tool to the task complexity. Don't use a sledgehammer for a thumbtack." — Boris Cherny, Anthropic

Claude Skills New in 2.1

Skills are reusable, modular capabilities that extend Claude Code. Think of them as plugins for your AI agent — they auto-load based on context and can spawn sub-agents for parallel work.

Skills vs MCP Servers vs Custom Commands

Feature Custom Commands MCP Servers Skills
Invocation Manual (/command) Manual (tools) Auto or manual
Context Main agent Main agent Can fork sub-agents
Hot reload Yes Restart needed Yes (2.1+)
Async No No Yes (--async)
Marketplace No Community repos Official + community

Getting Started with Skills

claude plugin marketplace update claude-plugins-official
claude plugin install <skill-name>
claude plugin list

Recommended Skills

git-workflow

Automated commits, PRs, and branch management with conventional commit messages.

claude plugin install git-workflow
test-generator

Auto-generates unit tests for your code. Supports Jest, Vitest, Pytest.

claude plugin install test-generator
docs-writer

Generates JSDoc, TypeDoc, or markdown documentation from your codebase.

claude plugin install docs-writer
security-audit

Scans for vulnerabilities, outdated deps, and security anti-patterns.

claude plugin install security-audit
db-migrate

Database migration helper for Prisma, Drizzle, TypeORM schemas.

claude plugin install db-migrate
refactor-assist

Intelligent refactoring suggestions with safe multi-file updates.

claude plugin install refactor-assist
Creating Your Own Skill

Skills are markdown files with YAML frontmatter in .claude/skills/:

# .claude/skills/my-deploy.md
---
name: deploy-preview
description: Deploy to preview environment
context: fork          # Runs in isolated sub-agent
model: sonnet          # Use faster model
hooks:
  post-tool-use: notify-slack
---

## Instructions
1. Run the build command: `pnpm build`
2. Deploy to Vercel preview: `vercel --prebuilt`
3. Return the preview URL
4. Post to #deploys Slack channel
Key Advantage: Skills with context: fork run in isolated sub-agents. This means a long-running security audit won't pollute your main conversation context — perfect for parallel workflows.

Sub-Agents & Background Tasks New in 2.1

Forked Sub-Agents

Spawn isolated sub-agents with context: fork in skill frontmatter. Parallel execution without polluting main context.

claude "review this PR for security issues" --print

Main ("Mama Claude") orchestrates, sub-agents execute

Async Background Agents

Long-running tasks via --background or Ctrl+B. Continue working while they run.

claude --background "run full test suite and report"

Ideal for monitoring logs, builds, migrations

Boris's Pattern: Use sub-agents for code review, simplification checks, or exploring alternative implementations without polluting your main context window.
/teleport New

Move your terminal session to Claude Desktop or web UI for complex visualization or collaboration.

Custom Slash Commands

Define reusable workflows in .claude/commands/auto hot-reloads (no restart needed)

.claude/commands/commit-push-pr.md
Check git status and diff.
Create a conventional commit message.
Push to origin.
Create a PR with a descriptive title and body.
Use gh cli for PR creation.
Usage: /commit-push-pr — automates entire git flow
More Command Examples (Copy & Use)
/review → .claude/commands/review.md
Review staged changes for bugs, security issues, and style.
Be concise. Only flag real issues worth fixing.
/test $ARGUMENTS → .claude/commands/test.md
Generate comprehensive unit tests for: $ARGUMENTS
Use the project's testing framework (check package.json).
Include edge cases and error scenarios.
Co-locate tests with source files.

Usage: /test src/utils/parser.ts

/explain → .claude/commands/explain.md
Explain the current file or selection in detail.
Cover: purpose, key functions, data flow, gotchas.
Assume reader is senior dev unfamiliar with this codebase.
/fix-lint → .claude/commands/fix-lint.md
Run linter, capture errors, and fix them:
!pnpm lint 2>&1
Fix each error. Re-run lint to verify.

Note the ! prefix for inline bash

/migrate $ARGUMENTS → .claude/commands/migrate.md
Create a database migration for: $ARGUMENTS
Use Prisma/Drizzle based on project setup.
Generate migration file and update schema.
!pnpm prisma migrate dev --name $ARGUMENTS
Bash in Commands: Use ! prefix in your command files to run shell commands. Example: !git status runs git and Claude sees the output. Chain with && or pipes.

MCP Server Integration

Configure in .claude/settings.json (project) or ~/.claude/settings.json (global)

claude mcp add context7 -- npx -y @anthropic/context7-mcp
Example MCP Configuration
{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@anthropic/context7-mcp"]
    },
    "browser": {
      "command": "npx", 
      "args": ["-y", "@anthropic/browser-mcp"]
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@anthropic/filesystem-mcp", "/path/to/allowed"]
    }
  }
}

Recommended MCPs

  • Context7 (docs lookup)
  • Browser (web automation)
  • Filesystem (extended access)
  • GitHub (repo operations)

MCP Commands

  • claude mcp list
  • claude mcp add [name]
  • claude mcp remove [name]
  • /mcp (in session)

Hooks System New in 2.1

Run custom scripts at specific lifecycle points:

PreToolUse

Before any tool executes (validation, logging)

PostToolUse

After tool completes (formatting, notifications)

Stop

When agent completes (cleanup, reporting)

Notification

Custom notification routing

Example: Auto-lint on File Write
// .claude/settings.json
{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Write|Edit",
      "hooks": [{
        "type": "command",
        "command": "pnpm lint --fix $CLAUDE_FILE_PATH"
      }]
    }]
  }
}

VSCode Extension

The official VSCode extension embeds Claude Code inside your editor, not as a chat sidebar but as an integrated terminal experience.

ext install anthropic.claude-code

When to Use What

Terminal (Standalone)

  • • Large refactors spanning many files
  • • Background tasks
  • • When you want full terminal power
  • • Running alongside any editor

VSCode Extension

  • • Quick edits while coding
  • • File-context aware prompts
  • • Inline diff viewing
  • • Seamless editor integration
Deep Integration: Claude Code syncs with VSCode, Cursor, and Windsurf. File changes in the terminal appear instantly in the IDE, and vice versa.

Chrome Extension Beta

Native browser integration allows Claude to navigate, inspect, and interact with web apps directly from the terminal.

Capabilities

  • Screenshot & analyze UI
  • Access DevTools console
  • Click, type, navigate
  • Use existing session cookies

Use Cases

  • • E2E debugging with live UI
  • • Testing auth flows
  • • Scraping data during dev
  • • Visual regression feedback
Record Custom Skills (Workflow Automation)

Record multi-step browser workflows by screen capture. Claude captures screenshots and DOM interactions to generate reusable /commands.

1. Start recording in extension
2. Perform workflow manually
3. Claude generates reusable command

GitHub Integration

@Claude GitHub App

Tag @claude in issues or PRs for one-shot tasks:

Issue comment:

"@claude fix the TypeScript error in src/utils.ts and create a PR"

GitHub Action Setup Steps
  1. 1.
    Install the Claude GitHub App

    Go to github.com/apps/claude and install on your repo

  2. 2.
    Add API key to repository secrets

    Settings → Secrets → Actions → New secret: ANTHROPIC_API_KEY

  3. 3.
    Create workflow file

    Add .github/workflows/claude.yml:

    name: Claude Code Action
    on:
      issue_comment:
        types: [created]
      pull_request_review_comment:
        types: [created]
    
    jobs:
      claude:
        if: contains(github.event.comment.body, '@claude')
        runs-on: ubuntu-latest
        permissions:
          contents: write
          pull-requests: write
          issues: write
        steps:
          - uses: actions/checkout@v4
          - uses: anthropics/claude-code-action@v1
            with:
              anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
  4. 4.
    Start using!

    Comment @claude [your request] on any issue or PR

Best For

  • Bug fixes from issues
  • Dependency updates
  • Documentation fixes
  • Simple feature additions

Limitations

  • No interactive iteration
  • Limited context window
  • Can't run local tests
  • One-shot only

Model Selection

Claude Opus 4.5

Recommended

Best for complex coding, architecture, multi-file operations

claude --model opus

Claude Sonnet 4

Default

Fast, capable, good balance for most tasks

claude --model sonnet

Claude Haiku

Budget

Quick lookups, simple tasks, preserving quota

/model Switch models mid-session

Start complex tasks with Opus, switch to Sonnet for iterations

Usage Tracking

Built-in Tracking

/cost

View current session cost & token usage

/status

Check connection & rate limit status

CUStats - Community Usage Tracker

Browser extension that tracks your Claude Pro usage across all interfaces.

custats.info

Understanding the 5-Hour Window

Claude Pro uses a rolling 5-hour window for rate limits. Heavy Opus usage can trigger cooldowns.

Antigravity Cockpit Auto-Wake (for comparison)

If you're familiar with Antigravity's auto-wake feature:

  • • You set a wake time (e.g., 6 AM) before your work starts (e.g., 9 AM)
  • • Extension pings the LLM with "hi" at 6 AM
  • • The 5-hour window starts at 6 AM and resets at 11 AM
  • • You get fresh quota when you actually start working

Claude Code alternative: No built-in auto-wake yet. Workaround: open Claude Code briefly in the morning with a simple prompt, then close. Check CUStats to monitor when your window resets.

Pro Subscription Optimization

1

Strategic Model Switching

Start with Opus for planning and architecture. Switch to Sonnet for implementation iterations. Use Haiku for quick lookups.

2

Compact Context

Use /compact to summarize long conversations. Reduces token count while preserving key context.

3

Pre-allow Tools

Use --allowedTools to skip permission prompts. Saves tokens on approval messages.

claude --allowedTools "Read,Write,Edit,Bash"
4

Use ! for Bash

Drop into bash mode with ! prefix for quick commands. Results feed back into context without extra prompts.

!git status && git diff --staged
5

Resume Sessions

Use claude --resume to continue previous sessions without rebuilding context.

Keyboard Shortcuts

Toggle Plan Mode
Shift + Tab
Send Message Enter
New Line
Shift + Enter
Cancel Generation Esc
Previous Message
Background Agent New
Ctrl + B
Exit
Ctrl + D
Accept All Changes a

Slash Commands Reference

Built-in commands — type / to see autocomplete

/help Show all available commands
/model Switch AI model → /model opus for complex tasks
/memory Save to CLAUDE.md → /memory We use Zod for validation
/compact Summarize long conversation to save tokens
/clear Fresh start — clears conversation history
/cost Check token usage — run often to avoid rate limits
/status Connection health + rate limit status
/teleport Move to Desktop/web UI New
/mcp List connected MCP servers
/config Open settings (verbosity, permissions, etc.)
/bug Report issue to Anthropic

Common Workflows

Save memory: /memory API rate limit is 100 req/min
Switch to Opus: /model opus then describe complex task
Check budget: /cost → switch to sonnet if high
Long session: /compact → keeps key context, drops noise

CLI Flags Reference

--model [model] Specify model (opus, sonnet, haiku)
--resume Continue previous session
--print Output only, no interactive session
--background Run as background agent
--allowedTools "[tools]" Pre-approve specific tools
--dangerously-skip-permissions Skip all permission prompts ⚠️
--verbose Show detailed logging
--version Show version number

Community Tools Third-Party

Useful community-built extensions and integrations (not official Anthropic products):

Zed IDE + Claude Code

Official Integration

Zed has native Claude Code integration via ACP (Agent Communication Protocol). Provides a visual IDE experience while using Claude Code's agentic capabilities.

macOS/Linux Fast & lightweight Multi-cursor
zed.dev/blog/claude-code-via-acp

Claude Canvas

Community Plugin

TUI toolkit that gives Claude Code rich terminal interfaces. Spawns tmux panes for interactive UIs like calendars, email drafts, and flight bookings.

Requires: tmux, bun Multi-pane UI

Search "Claude Canvas TUI" for community implementations

CUStats

Browser Extension

Tracks Claude Pro usage across web interface. Shows remaining quota, usage history, and cooldown timers.

custats.info
Note: These are community tools, not official Anthropic products. Always review third-party code before installation. Features may change or break with Claude Code updates.

Resources & Documentation

Official Anthropic

Video Guides