50 Powerful Claude Code Hacks to Supercharge Your Development Workflow

1. Set a cc alias

Add the following line to your ~/.zshrc or ~/.bashrc and reload the shell to invoke Claude with a short command that skips permission prompts.

alias cc='claude --dangerously-skip-permissions'

2. Prefix ! for inline bash execution

Typing !git status or !npm test runs the command immediately, shows the output in the conversation, and lets Claude act on the result without waiting for a separate tool call.

3. Stop and rewind shortcuts

Press Esc to halt Claude mid‑action; press Esc Esc (or /rewind) to open a checkpoint menu where you can restore code, the dialogue, or both.

4. Give Claude a self‑checking loop

Include test commands, code‑review prompts, or expected output in your request so Claude can run tests, detect failures, and automatically fix issues without further input.

5. Install a language‑specific LSP plugin

Use the built‑in plugin manager to add diagnostics for your language. Example commands:

/plugin install typescript-lsp@claude-plugins-official
/plugin install pyright-lsp@claude-plugins-official
/plugin install rust-analyzer-lsp@claude-plugins-official
/plugin install gopls-lsp@claude-plugins-official

Plugins for C#, Java, Kotlin, Swift, PHP, Lua, and C/C++ are also available.

6. Use the gh CLI to teach Claude any CLI tool

Running gh (or jq, curl, etc.) lets Claude learn the tool’s usage from its --help output, then invoke it directly in the session.

7. Add the ultrathink keyword for deep reasoning

Prefix a prompt with ultrathink to raise the effort level, triggering adaptive reasoning on Opus 4.6 for complex design or multi‑step debugging tasks.

8. Load on‑demand skills as Markdown files

Place reusable knowledge in .claude/skills/ as Markdown; Claude loads a skill only when the current task needs it, keeping the context lean.

9. Control Claude from your phone

Start a remote session with claude --remote and connect via the web UI or mobile app; the session runs locally while you monitor progress from anywhere.

10. Expand the context window to 1 million tokens

Both Sonnet 4.6 and Opus 4.6 support a 1 M‑token window. Switch models with /model opus[1m] or /model sonnet[1m]. Gradually increase from 500 k if quality drops.

Control automatic compaction with the environment variables CLAUDE_CODE_AUTO_COMPACT_WINDOW and CLAUDE_AUTOCOMPACT_PCT_OVERRIDE.

11. Use plan mode for complex tasks

Enable plan mode ( Shift + Tab ) for multi‑file changes, unfamiliar codebases, or architectural decisions. It adds a brief preparation step that prevents Claude from blindly spending minutes on a wrong approach.

12. Clear the session between unrelated tasks

Run /clear before starting a new, unrelated workflow to avoid context bleed‑over and improve response quality.

13. Paste raw error data instead of describing it

Feed Claude the exact log, CI output, or Slack thread with a prompt like "fix this error". Claude can parse the raw data and suggest a fix without losing details.

cat error.log | claude "explain this error and suggest a fix"
npm test 2>&1 | claude "fix the failing tests"

14. Use /btw for quick side questions

Invoke /btw to open an overlay for brief follow‑up queries without cluttering the main conversation.

15. Create isolated worktrees with --worktree

Run claude --worktree feature‑auth to spin up a separate Git worktree and session for parallel development.

16. Save drafts with Ctrl + S

Press Ctrl + S while typing a long prompt to stash it, answer a quick question, then resume the saved draft.

17. Send long‑running commands to the background with Ctrl + B

When Claude launches a lengthy Bash process (tests, builds, migrations), Ctrl + B pushes it to the background while Claude continues chatting.

18. Add a real‑time status line

Enter /statusline to generate a shell script that displays the current directory, Git branch, and token usage after each Claude interaction.

19. Use sub‑agents to keep the main context clean

Spawn a sub‑agent to investigate a payment‑failure flow; it works in its own window, returns a concise summary, and leaves the primary session uncluttered.

20. Enable experimental agent teams

Activate CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS and ask Claude to create a three‑member team that refactors modules in parallel, each with its own context window.

21. Guide compression with explicit directives

When compressing, tell Claude what to keep, e.g., /compact focus on API changes and modified file list. Add permanent rules to CLAUDE.md for future compressions.

22. Schedule periodic checks with /loop

Run /loop 5m to poll a deployment status every five minutes. The loop lives only within the current session and expires after three days.

23. Use /voice for speech‑to‑text prompts

Press the space bar after /voice to dictate; the transcription appears alongside typed input, enriching context without extra keystrokes.

24. Break out of a fix‑loop with /clear

If Claude gets stuck in a repetitive correction cycle, clear the session and start with a better initial prompt.

25. Reference files directly with @

Use @src/auth/middleware.ts to tell Claude exactly which file to inspect, avoiding costly token‑consuming searches.

26. Explore unfamiliar code with vague prompts

Ask open‑ended questions like “What improvements would you make to this file?” to let Claude surface hidden patterns and suggestions.

27. Edit plans on the fly with Ctrl + G

When Claude proposes a plan, press Ctrl + G to open it in your editor, tweak steps, and save without re‑explaining.

28. Initialise and prune CLAUDE.md

Run /init to generate a starter CLAUDE.md from your project layout, then trim redundant entries.

29. Strictly validate each CLAUDE.md line

Ask yourself for every line: “If this line were missing, would Claude fail?” Remove anything unnecessary to stay within the ~150‑line budget.

30. Update CLAUDE.md after mistakes

When Claude errs, tell it “Update your CLAUDE.md to prevent this in the future,” and the file will be amended automatically.

31. Store conditional rules in .claude/rules/

Place YAML rule files that apply only to certain paths (e.g., TypeScript conventions) in .claude/rules/ so the main CLAUDE.md stays concise.

---
paths:
  - "**/*.ts"
---
# TypeScript conventions
Prefer interfaces over types.

32. Use @imports to keep CLAUDE.md tidy

Reference external Markdown files (e.g., @docs/git-instructions.md) from CLAUDE.md so Claude loads them only when needed.

33. Whitelist safe commands with /permissions

Add trusted commands to a whitelist so Claude can run them without prompting, while unknown commands still require approval.

34. Run tasks in a sandbox with /sandbox

Enable OS‑level isolation; file writes stay inside the project directory and network requests are limited to approved domains.

35. Create custom sub‑agents for repeatable jobs

Store pre‑configured agents in .claude/agents/ (e.g., a security‑review agent) and invoke them with /agents.

36. Choose the right MCP server for your stack

Use Playwright for UI tests, PostgreSQL/MySQL for schema queries, Slack for log inspection, or Figma for design‑to‑code workflows.

37. Set output styles with /config

Pick between explanatory, concise, or technical styles, or create custom styles in ~/.claude/output‑styles/.

38. Distinguish CLAUDE.md from hooks

CLAUDE.md

provides guidance; hooks are deterministic actions that always run (e.g., auto‑formatting on file write).

39. Add a PostToolUse hook for auto‑formatting

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write $CLAUDE_FILE_PATH 2>/dev/null || true"
          }
        ]
      }
    ]
  }
}

40. Add a PreToolUse hook to block destructive commands

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "type": "command",
        "command": "if echo $TOOL_INPUT | grep -qE 'rm -rf|drop table|truncate'; then echo 'BLOCKED: destructive command' >&2; exit 2; fi"
      }
    ]
  }
}

41. Preserve important context during compression

Define a notification hook that re‑injects the current task description, modified file list, and constraints whenever Claude compresses the context.

42. Manually review sensitive changes

Always double‑check authentication, payment, and data‑migration modifications; automated tests cannot catch every security‑critical error.

43. Experiment with alternative approaches using /branch

Branch the conversation ( /branch or /fork) to try risky refactors without losing the original dialogue.

44. Let Claude interview you for vague specifications

Prompt Claude with an AskUserQuestion tool to flesh out missing requirements before starting implementation.

45. Dual‑Claude collaboration mode

One Claude writes code while a second Claude reviews it from a fresh context, providing an independent engineering perspective.

46. Review pull requests conversationally

Open a PR in the session and ask targeted questions (e.g., “What is the riskiest change?”) to uncover deeper issues than a static review.

47. Name and colour‑code sessions

Use /rename and /color to label sessions (e.g., /rename auth‑refactor, /color red) for quick visual identification.

48. Play a sound when Claude finishes

{
  "hooks": {
    "Stop": [
      {
        "matcher": "*",
        "hooks": [
          {
            "type": "command",
            "command": "/usr/bin/afplay /System/Library/Sounds/Glass.aiff"
          }
        ]
      }
    ]
  }
}

49. Distribute batch jobs with claude -p

for file in $(cat files-to-migrate.txt); do
  claude -p "Migrate $file from class components to hooks" \
    --allowedTools "Edit,Bash(git commit *)" &
done
wait

50. Customize the spinner wording

Tell Claude to replace the default loading verbs (e.g., “Flibbertigibbeting…”) with your own style, such as magical incantations or domain‑specific jargon.

These 50 tips form a comprehensive workflow that can be followed daily to get the most out of Claude Code, from safe command execution to advanced agent orchestration.