Configure Warp Like a Pro

Warp is a modern, GPU-accelerated terminal built in Rust. It's free for individual use and the fastest way to level up your command-line workflow on macOS.

Install via Homebrew

brew install --cask warp

Or download directly

First launch checklist

• Sign in with GitHub (or email) to activate your account
• Grant Accessibility & Full Disk Access when prompted
• Set Warp as your default terminal (Warp → Settings → Default Terminal)
• Browse Preferences with ⌘ , to explore the settings

Warp's GPU-accelerated renderer means buttery-smooth scrolling and crisp text at any size. Dial in the look before you start configuring the shell underneath.

Recommended settings

• Font → JetBrains Mono Nerd Font, 13px (installed below)
• Theme → Dracula, Tokyo Night, or your pick from the gallery
• Compact Mode → On (Settings → Appearance → Compact Mode)
• Window Opacity → 95% for a subtle transparency effect
• Prompt → PS1 or Starship (configured in Section 03)

Install a Nerd Font

Nerd Fonts patch in thousands of icons used by CLI tools like eza, Starship, and Powerlevel10k.

brew tap homebrew/cask-fonts
brew install --cask font-jetbrains-mono-nerd-font

macOS ships with Zsh as the default shell. Oh My Zsh layers on a plugin system, themes, and sensible defaults that make your shell dramatically more productive.

Install Oh My Zsh

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Essential plugins

Add zsh-autosuggestions and zsh-syntax-highlighting — two plugins that will change the way you type commands.

# Clone the plugins into Oh My Zsh's custom directory
git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

git clone https://github.com/zsh-users/zsh-syntax-highlighting ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

Then update the plugins line in your ~/.zshrc:

plugins=(git zsh-autosuggestions zsh-syntax-highlighting)

Key ~/.zshrc additions

# History
HISTSIZE=10000
SAVEHIST=10000
setopt SHARE_HISTORY

# Navigation
setopt AUTO_CD
setopt AUTO_PUSHD

# Aliases
alias ll="ls -la"
alias gs="git status"
alias gp="git pull"
alias gc="git commit"
alias ..="cd .."
alias ...="cd ../.."

# Reload config
alias reload="source ~/.zshrc"

Shell setup checklist

• Oh My Zsh installed and running
• zsh-autosuggestions and zsh-syntax-highlighting active
• Aliases added to ~/.zshrc
• Run source ~/.zshrc to reload

Your local dev stack — version managers, CLI tools, and Git config. Run these in Warp and you'll have a fully equipped development environment in minutes.

Install everything at once

# Node.js via nvm
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash
nvm install --lts
nvm alias default node

# Python via pyenv
brew install pyenv
echo 'eval "$(pyenv init -)"' >> ~/.zshrc
pyenv install 3.12
pyenv global 3.12

# GitHub CLI
brew install gh
gh auth login

# Useful CLI tools
brew install eza bat fd ripgrep jq

Level up your ls and cat

Replace the defaults with modern alternatives that have color, icons, and Git integration.

# Add to ~/.zshrc
alias ls="eza --icons --group-directories-first"
alias ll="eza -la --icons --group-directories-first --git"
alias cat="bat --theme=Dracula"
alias find="fd"

Configure Git globally

git config --global user.name "Your Name"
git config --global user.email "you@example.com"
git config --global init.defaultBranch main
git config --global pull.rebase true

# Generate SSH key (if you don't have one)
ssh-keygen -t ed25519 -C "you@example.com"
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

# Copy public key to clipboard — paste into GitHub → Settings → SSH Keys
pbcopy < ~/.ssh/id_ed25519.pub

Toolchain checklist

• Node.js installed via nvm (check: node --version)
• Python installed via pyenv (check: python --version)
• GitHub CLI authenticated (check: gh auth status)
• SSH key generated and added to GitHub
• Modern CLI tools installed (eza, bat, fd, ripgrep, jq)

Claude Code is an agentic coding tool that lives in your terminal. It reads your codebase, edits files, runs commands, and works as a first-class citizen alongside Warp's block-based UI.

Install Claude Code

# Install globally
npm install -g @anthropic-ai/claude-code

# Verify installation
claude --version

# Authenticate (opens browser)
claude auth

Useful aliases

Add these to your ~/.zshrc for faster access:

# Add to ~/.zshrc
alias cc="claude"
alias ccr="claude 'review this code for bugs and improvements'"
alias ccfix="claude 'fix the failing tests'"
alias cctest="claude 'write tests for the recent changes'"
alias ccdoc="claude 'add documentation to the undocumented functions'"

CLAUDE.md — project memory

Create a CLAUDE.md file in your project root. Claude Code reads this automatically to understand your project's conventions, architecture, and commands.

# CLAUDE.md

## Project
Brief description of your project.

## Commands
```bash
npm run dev       # Start dev server
npm run build     # Production build
npm test          # Run tests
```

## Architecture
- Framework and key tech decisions
- Important file paths
- Conventions to follow

Warp + Claude Code power moves

Claude Code checklist

• Claude Code installed globally (check: claude --version)
• Aliases added to ~/.zshrc
• CLAUDE.md created in your main project
• Run a test session: claude 'explain the project structure'

Warp isn't just a pretty terminal — it has unique features like command blocks, AI assistance, and Warp Drive that no other terminal offers. Learn the shortcuts and you'll fly.

Navigation shortcuts

Block navigation

AI features

Shortcuts checklist

• Try split panes — run a server in one, tests in another
• Use Warp AI to convert a natural language request into a command
• Save a workflow to Warp Drive as a team runbook

The difference between a fast terminal and a great one is the workflows you build on top. These scripts and tools will save you hours every week.

fzf — fuzzy find everything

fzf is a general-purpose fuzzy finder. It plugs into file search, command history, Git branches, and anything else you can pipe into it.

brew install fzf

# Add to ~/.zshrc
source <(fzf --zsh)

# Key bindings (add to ~/.zshrc)
export FZF_DEFAULT_COMMAND='fd --type f --hidden --follow --exclude .git'
export FZF_DEFAULT_OPTS='--height 40% --layout=reverse --border'
export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"

Project switcher function

Jump to any project directory with fuzzy matching:

# Add to ~/.zshrc
p() {
  local dir
  dir=$(find ~/Development -maxdepth 2 -type d | fzf --preview 'eza -la --icons {}')
  if [[ -n "$dir" ]]; then
    cd "$dir"
  fi
}

Session startup script

Create a script that boots your full dev environment in one command:

#!/bin/bash
# ~/bin/dev-start.sh — launch your dev environment

PROJECT=${1:-$(basename $PWD)}

echo "Starting dev environment for $PROJECT..."

# Open in Warp split panes
warp-cli split-pane --direction right
warp-cli send-text --pane 1 "npm run dev"
warp-cli send-text --pane 2 "npm run test -- --watch"

echo "Dev environment ready."

Environment & secrets management

Use direnv to auto-load environment variables per project — no more manual source .env:

brew install direnv

# Add to ~/.zshrc
eval "$(direnv hook zsh)"

# In your project directory
echo 'export DATABASE_URL="postgres://..."' > .envrc
direnv allow

Final power checklist

• fzf installed and shell integration active (Ctrl+R for history, Ctrl+T for files)
• Project switcher function added to ~/.zshrc
• dev-start.sh script created and made executable (chmod +x)
• direnv installed and hooked into Zsh
• Back up your ~/.zshrc — you've earned it

Combine Warp's unique features with TypeScript, GitHub CLI, and Claude Code to build a developer workflow that's faster than anything you've used before.

Scaffold a TypeScript project

Bootstrap a new project and push it to GitHub in under a minute:

# Create a new project (pick your framework)
npm create astro@latest my-app -- --template minimal --typescript strict
cd my-app

# Initialize Git and push to GitHub
git init && git add -A && git commit -m "init: scaffold project"
gh repo create my-app --public --source=. --push

Set up strict TypeScript from the start:

{
  "compilerOptions": {
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "exactOptionalPropertyTypes": true
  }
}

Feature branch workflow

A clean branch workflow using GitHub CLI — never leave the terminal:

# Create and switch to a feature branch
git checkout -b feat/add-auth-middleware

# ... make your changes ...

# Stage, commit, and open a PR in one flow
git add -A
git commit -m "feat: add JWT auth middleware"
gh pr create --fill

# Check CI status
gh pr checks

# Once CI passes, merge
gh pr merge --squash --delete-branch

Claude Code development loop

The real power: use Claude Code as a pair programmer inside Warp. This is the workflow loop that replaces context-switching to a browser-based AI:

# Step 1 — Ask Claude to implement a feature
claude 'add rate limiting middleware to the Express API routes'

# Step 2 — Review what Claude changed
git diff

# Step 3 — Ask Claude to write tests
claude 'write tests for the rate limiting middleware using vitest'

# Step 4 — Run the tests
npm test

# Step 5 — If tests fail, let Claude fix them
claude 'fix the failing tests'

# Step 6 — Commit when green
git add -A && git commit -m "feat: add rate limiting with tests"

Multi-pane TypeScript workflow

Use Warp's split panes to run your full development environment simultaneously. This is where Warp's GPU-accelerated rendering really shines — no lag across panes.

# Pane 1 (main) — your working terminal
# Already open

# Pane 2 — split right for TypeScript watch mode
# Press Cmd+D, then run:
npx tsc --watch --noEmit

# Pane 3 — split down from Pane 2 for test watch
# Press Cmd+Shift+D, then run:
npx vitest --watch

# Pane 4 — split down from Pane 1 for dev server
# Press Cmd+Shift+D, then run:
npm run dev

Debug TypeScript errors with Warp AI

When TypeScript throws a cryptic error, use Warp AI to decode it instantly. No more copy-pasting errors into a search engine.

# Hit Ctrl+Space and type naturally:
# "what does TS2345 mean and how do I fix it"

# Or ask Claude Code for a deeper fix:
claude 'the TypeScript compiler is throwing TS2345 on src/middleware.ts:42 — fix it'

# Share the error block with your team:
# Click the block → Cmd+Shift+S → share link generated

Ship it: PR → CI → merge

The full shipping flow from feature branch to merged PR:

# Create PR with a structured description
gh pr create --title "feat: add rate limiting" --body "## Changes
- Added rate limiting middleware (100 req/min per IP)
- Added Redis-backed token bucket
- Added tests for rate limit scenarios

## Testing
- npm test — all passing
- Manual test: curl -v localhost:3000/api/health"

# Watch CI in a split pane (Cmd+D)
gh run watch

# Once CI is green, merge and clean up
gh pr merge --squash --delete-branch
git checkout main && git pull

Workflows checklist

• Scaffold a TS project with strict: true and push to GitHub
• Create a feature branch and open a PR with gh pr create
• Use Claude Code to implement a feature and write tests
• Run tsc --watch and vitest --watch in split panes (Cmd+D)
• Use Warp AI (Ctrl+Space) to decode a TypeScript error
• Ship a PR: gh pr create → gh run watch → gh pr merge