March 17, 2026·9 min read

15 Claude Code Tips Most Developers Miss

Claude CodeTipsDeveloper Productivity

The tips that actually matter

Most developers install Claude Code, use it for a few sessions, and assume they've seen what it can do. They haven't. The default experience is maybe 30% of what's available, and the remaining 70% is where the real claude code tips live: the features that turn Claude Code from a smart assistant into a configurable development system.

This post covers 15 specific features that most developers either don't know about or underuse. No theory, just commands you can run today. If you haven't set up Claude Code yet, start with our setup guide first.

1. Use CLAUDE.md for persistent project instructions

This is the single highest-impact claude code trick available. Create a CLAUDE.md file in your project root, and Claude Code reads it automatically at the start of every session.

# CLAUDE.md

## Project conventions
- Use TypeScript strict mode
- All API routes return { data, error } shape
- Tests go in __tests__/ next to the source file
- Never use default exports

## Current priorities
- Finishing the auth refactor (see /src/auth/)
- Payment webhook reliability (Stripe retries)

Claude Code supports CLAUDE.md at three levels: project root (read by everyone), ~/.claude/CLAUDE.md (global, applies to all projects), and .claude/CLAUDE.md (project-specific, ignored by git by default). Use all three. Global for your personal coding style, project root for team conventions, .claude/ for context you don't want in version control.

This is the foundation that every other tip builds on. Set it up first.

2. Memory files for cross-session context

CLAUDE.md is static instructions. Memory files are living context: what you're working on now, what happened yesterday, what decisions were made.

Create .claude/memory.md and maintain it as your project's working memory:

## Current sprint
- Auth refactor: 80% done, token refresh still needs work
- Don't suggest Redis for session storage, we ruled it out (see notes from March 3)

## Known issues
- Rate limiter breaks behind Cloudflare proxy
- Stripe webhook occasionally times out on large payloads

Claude reads this automatically. The difference is immediate: instead of re-explaining context every session, you update a file once. For a deeper dive on building a full memory architecture, read our guide to Claude Code memory systems.

3. Slash commands for repeatable workflows

Create custom commands in .claude/commands/ as markdown files. Each file defines a procedure Claude follows when you type the command.

<!-- .claude/commands/deploy.md -->
# Deploy

1. Run the test suite: `npm test`
2. If tests pass, build: `npm run build`
3. Commit with message: "build: production deploy [timestamp]"
4. Push to main
5. Verify deployment at https://your-app.vercel.app

Now type /deploy in any Claude Code session and it executes the full procedure. Use commands for anything you do more than twice: deployments, database migrations, PR reviews, sprint planning updates.

Commands can include variable interpolation with $ARGUMENTS, so /deploy staging can behave differently from /deploy production.

4. Hooks for automated quality gates

Hooks are scripts that run automatically before or after Claude uses a tool. They're defined in .claude/settings.json and they're how you enforce rules without relying on Claude to remember them.

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write|Edit",
        "command": "bash .claude/hooks/lint-check.sh"
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Bash",
        "command": "bash .claude/hooks/log-commands.sh"
      }
    ]
  }
}

Available hook points: PreToolUse, PostToolUse, SessionStart, PreCompact, and Stop. Use PreToolUse hooks to block writes that violate your rules. Use PostToolUse hooks for logging and verification. Use Stop hooks to auto-save state.

Hooks are deterministic: they always run, unlike instructions which Claude might occasionally overlook. Put your hardest constraints in hooks.

5. Skills for domain knowledge injection

Skills are markdown files in .claude/skills/ that contain domain-specific knowledge Claude can load on demand. Think of them as reference manuals for specific topics.

<!-- .claude/skills/stripe-integration/SKILL.md -->
# Stripe Integration Skill

## Webhook verification
Always verify signatures using `stripe.webhooks.constructEvent()`.
Never trust unverified webhook payloads.

## Idempotency
All payment operations must include an idempotency key.
Use the format: `{user_id}_{operation}_{timestamp}`.

Skills keep specialized knowledge out of your main CLAUDE.md (which should stay concise) while making it available when needed. Claude loads relevant skills based on context, or you can reference them explicitly. For the full breakdown, see our skills deep dive.

6. Resume previous sessions with `--resume`

Every Claude Code session gets an ID. Use claude --resume to pick up where you left off, including full conversation history and context.

# Resume the most recent session
claude --resume

# List recent sessions and pick one
claude --resume --list

This is a claude code shortcut that saves significant ramp-up time. Left a debugging session yesterday with a partial fix? Resume it instead of re-explaining the problem. Combined with memory files, resuming a session means almost zero context loss.

7. Keyboard shortcuts that save real time

These are small but they add up across hundreds of daily interactions:

Escape: Cancel the current generation immediately. Use it the moment Claude starts going in the wrong direction, and don't wait for it to finish.
Tab: Accept a file suggestion or autocomplete.
Ctrl+C: Cancel and keep what's been generated so far.
/clear: Reset conversation context without exiting (more on this in tip 11).

The Escape key alone is worth knowing. Catching a bad generation at 2 seconds instead of 30 saves real time over a day.

8. Worktrees for parallel agent work

Git worktrees let you have multiple working copies of the same repo. Combined with Claude Code, this means you can run parallel agents on different tasks without them stepping on each other.

# Create a worktree for a feature branch
git worktree add ../my-project-auth feature/auth-refactor

# Run Claude Code in the worktree
cd ../my-project-auth && claude

Run one agent on the auth refactor in a worktree while another handles API tests in the main tree. No merge conflicts from simultaneous file edits, no confused context. This is essential for claude code productivity on larger projects where you have multiple workstreams.

9. MCP servers extend capabilities dramatically

Model Context Protocol (MCP) servers give Claude Code direct access to external tools: databases, APIs, cloud services, and more. Configure them in .mcp.json at your project root.

{
  "mcpServers": {
    "turso": {
      "command": "npx",
      "args": ["-y", "@turso/mcp"],
      "env": {
        "TURSO_DATABASE_URL": "libsql://your-db.turso.io",
        "TURSO_AUTH_TOKEN": "your-token"
      }
    }
  }
}

With a database MCP server, Claude can query your production data directly. With a GitHub MCP, it can create PRs, review code, and manage issues without you switching tools. With a Google Sheets MCP, it can read and write spreadsheet data as part of automated workflows.

The practical impact: instead of Claude generating SQL for you to copy-paste into a database client, it runs the query itself and reasons about the results. That's a fundamentally different workflow.

10. Scope agent permissions with allowed-tools

Control exactly which tools an agent or command can use by specifying allowed-tools in your configuration. This is how you create safe, scoped agents that can't accidentally modify things they shouldn't.

{
  "allowed-tools": ["Read", "Glob", "Grep", "Bash(git status)"]
}

A review agent that can only read files and run git status can't accidentally edit your code. A deploy agent with access to specific bash commands can't run arbitrary scripts. Scoping permissions isn't just safety: it also makes agents more focused and reliable because they don't waste time considering tools they shouldn't use.

11. Manage context with `/clear` and `/compact`

Claude Code has a finite context window. Long sessions degrade quality as the window fills up. Two commands manage this:

/clear: Resets the conversation while preserving your CLAUDE.md and memory files. Use this between unrelated tasks in the same session.
/compact: Compresses the conversation history, keeping key context while freeing space. Use this when a session is getting long but you're still mid-task.

# After finishing a feature, before starting the next task
/clear

# Mid-task, conversation getting long
/compact

The rule of thumb: if you've been in a session for 30+ tool calls or notice Claude repeating itself or missing details, compress. If you're switching to a completely different task, clear. Don't wait for degraded output; proactive context management is a core claude code productivity habit.

For teams using Claudify, context management patterns like these are pre-configured in your project scaffolding, so you spend less time tuning and more time building.

12. Agent subcommands for parallel execution

The claude CLI supports running agents: headless, non-interactive sessions that execute a specific task and return results. Use them for parallel work.

# Run a task non-interactively
claude -p "Review all files in src/auth/ for security issues and write findings to REVIEW.md"

# Run multiple agents in parallel
claude -p "Write unit tests for src/utils/date.ts" &
claude -p "Write unit tests for src/utils/string.ts" &
wait

Agents defined in .claude/agents/ can have their own memory, allowed tools, and instructions. A review agent reads code and writes reports. A test agent generates test files. A deploy agent handles the release process. Each stays focused on its domain.

13. Project-level configuration in settings.json

.claude/settings.json is where project-level configuration lives: hooks, permissions, and behavioral settings that apply to every session in the project.

{
  "hooks": {
    "PreToolUse": [],
    "PostToolUse": [],
    "SessionStart": [],
    "Stop": []
  },
  "allowed-tools": [],
  "deny-tools": [],
  "model": "opus"
}

This file is checked into your repo, so team members share the same Claude Code configuration automatically. Put your hook definitions, tool permissions, and any project-specific settings here. Keep it valid JSON: a syntax error in this file breaks all hooks.

14. Non-interactive scripting with `claude -p`

The -p flag runs Claude Code with a single prompt, non-interactively. This is how you integrate Claude into shell scripts, CI pipelines, and automation.

# Generate a changelog from recent commits
claude -p "Read the last 10 git commits and write a CHANGELOG entry for this week"

# Lint and fix in a pre-commit hook
claude -p "Check staged files for TypeScript errors and fix them"

# Use in a bash script
RESULT=$(claude -p "What's the current Node.js version in package.json?")
echo "Node version: $RESULT"

Combine -p with --allowedTools to scope what the scripted session can do. A CI pipeline that uses Claude for code review should only have read access, never write.

15. Use `@file` references for dynamic context

In Claude Code commands and prompts, use @file syntax to include file contents dynamically. This pulls the current content of a file into the prompt at execution time.

<!-- .claude/commands/review-pr.md -->
# Review PR

Review the changes in this PR against our coding standards:

@CLAUDE.md
@.claude/knowledge-base.md

Focus on:
1. Convention violations
2. Missing error handling
3. Test coverage gaps

This is powerful for commands that need to reference configuration or context that changes over time. Instead of duplicating your coding standards in every command, reference the source file. When the standards update, every command that references them gets the update automatically.

The @ syntax works with any file path relative to your project root. Use it in custom commands, in prompts, and in CLAUDE.md itself to compose context from multiple sources.

Put it all together

These tips aren't independent: they compound. CLAUDE.md sets the rules, memory files maintain context, hooks enforce constraints, skills provide domain knowledge, and commands orchestrate workflows. A project using all of these is a fundamentally different experience from bare Claude Code.

Start with CLAUDE.md (tip 1) and memory (tip 2); those two alone will change how productive you are. Add commands and hooks as your workflow stabilizes. Layer in MCP servers when you need external tool access. The system grows with your project.

Not sure Claude Code is the right tool for you? See our honest comparison of the 7 best coding assistants in 2026 to find the best fit for your workflow.

If you want a pre-built version of this entire stack, including CLAUDE.md templates, memory architecture, hooks, skills, and commands designed for production development, Claudify ships all of it configured and ready to use. Install it once and skip the setup entirely.