27 Hidden Features, Settings, and Shortcuts of Claude Most People Don't Know

Here are 27 specific techniques for Claude Code, divided into three levels—Beginner, Intermediate, and Advanced—to help you go from 2x productivity to 10x productivity. This article is compiled and translated from Rahul X's post.
(Prerequisite: Claude Code launches /goals command: separates execution from evaluation to prevent AI agents from slacking or lying)
(Context: Hands-on: Step-by-step guide to using 7 agents to upgrade Vibe Coding to an expert-level development workflow)

Table of Contents

Toggle

• Beginner Tips Master these first; they prevent 80% of unproductive sessions.
• Intermediate Tips Once the basics are down, these techniques unlock real productivity leaps.
• Advanced Tips At this level, Claude Code stops being just a coding assistant and starts feeling like a full team.

Most people treat Claude Code as an advanced autocomplete tool.

They type a prompt, then wait, then accept the first output.

They leave 90% of the functional potential on the table.

There are 27 specific techniques that separate the 2x from the 10x developers.

I'm going to break them all down for you.

Beginner → Intermediate → Advanced.

Read through once, save it, and come back when you reach each stage.

Before we start—the mental model that changes everything

Most developers treat Claude Code like a vending machine.

Put in prompt, get out code.

This model is wrong.

The correct mental model is: Claude Code is a talented junior developer who needs proper onboarding, clear constraints, and regular check-ins.

Give it structure → it runs. Skip structure → it wanders aimlessly.

Every technique below, ultimately, is about the same thing:

Give Claude better structure so it can go further with fewer interruptions.

Beginner Tips Master these first; they prevent 80% of unproductive sessions.

1. Run /init before doing anything else

First thing you do in every new project: run /init.

Claude reads your codebase and generates a CLAUDE.md file.

That file becomes the brain of the project—architecture decisions, conventions, patterns, naming rules.

Every future session starts with that context already loaded.

Without it: Claude guesses your conventions. With it: Claude already knows them.

/init

One command. Done. Never skip it.

2. Use /statusline to see what's happening

Set up /statusline and turn your terminal into a live dashboard.

You can see: Token usage, session metrics, model info—all in real time.

/statusline

No more guessing how much context you've consumed.

Just look at the numbers.

3. Enable voice input

Hands-free coding keeps you in problem-solving mode.

You don't need to stop and type—just say your next command.

Especially useful when reviewing output and want to redirect without breaking your flow.

Enable it once in settings, then keep using it.

4. Use /context to find what's consuming your tokens

Your context window is a budget.

When it gets heavy, use /context to check what's consuming it.

/context

You'll almost always find redundant overhead—old files, irrelevant context, outdated instructions.

Trim it, and your output quality improves immediately.

5. Compact at 60%, clear between tasks

Two rules of context hygiene:

→ Run /compact when context hits 60%—Claude compresses the conversation without losing key information
→ Run /clear between completely unrelated tasks—start fresh

/compact   # when a task runs long
/clear     # when switching to a completely new unrelated task

Most developers wait until context is completely full before dealing with it.

By then, Claude is already degrading.

60% is the sweet spot.

6. Always start with plan mode

Before Claude writes a single line of code—make it plan first.

# When starting a session:
"Before doing anything, outline your approach.
List the steps, mark any assumptions.
Ask me if anything is unclear."

Why this works:

→ Forces Claude to think before acting
→ Surfaces misaligned assumptions early
→ Gives you a checkpoint before burning compute

Sessions that start with plan mode take 3 extra minutes.

Sessions that start without a plan often take 3 extra hours to fix.

7. Present problems, not instructions

Most people say: "Build me a login page."

Better: "Users can't log in when the password contains special characters. Here's the error message. Here's the constraint—we can't change the database schema."

Problem + constraint + context = dramatically better output.

Claude is not an instruction executor.

It's a problem solver.

Give it the problem.

8. Let Claude ask questions before it starts

Add this to every complex prompt:

"Before you start, ask me any clarifying questions you need to do this right, all at once."

The first output is almost never the best output.

The best output comes after Claude understands edge cases.

Let it ask, answer once, then watch it run.

9. Embed self-verification into your to-do lists

When giving Claude a task list, include verification steps:

To-do:
1. Create payment form
2. Add input validation
3. ✓ Verify: test blank input, special characters, and amounts over $10,000
4. Add error messages
5. ✓ Verify: confirm all error states are handled and visible

Claude self-checks before declaring the task done.

Without this: Claude declares victory at step 2. With this: Claude actually finishes the task.

Intermediate Tips Once the basics are down, these techniques unlock real productivity leaps.

10. Deploy sub-agents for parallel work

One of the most underrated features.

Instead of executing tasks sequentially, split them among sub-agents with isolated contexts.

"Spin up a sub-agent for the database schema.
Another for the API endpoints.
You handle coordinating the integration."

Parallel work, isolated contexts, zero cross-contamination.

The productivity leap is not incremental—it's multiplicative.

11. Store reusable prompts as custom skills

Every time you rewrite the same instruction, you're losing time.

Store reusable workflows as skill files:

# skills/code-review.md
When reviewing code:
1. First check for security vulnerabilities
2. Flag any N+1 queries
3. Verify error handling for every external call
4. Check variable naming follows our conventions (camelCase, descriptive)
5. Output: list critical issues first, then suggestions

Load the skill, Claude follows your exact standards every time.

Never rewrite the same instructions again.

12. Use lighter models for simple tasks

Haiku for: file renames, simple refactors, boilerplate code, config edits.

Sonnet/Opus for: architecture decisions, complex debugging, multi-file changes.

# When setting up a session:
"Use the most cost-effective model for this task."

Most developers use Opus for everything.

It's like driving a Ferrari to buy groceries.

Match the model to the task.

13. Continuously update CLAUDE.md as the project evolves

The CLAUDE.md you generate with /init is not a one-time file.

Update it as the project changes:

# CLAUDE.md

## Current Tech Stack
- Next.js 14 (App Router, not Pages Router)
- Supabase for auth and database
- Tailwind + shadcn/ui for components

## Hard Rules
- Never commit or push. User handles all git operations.
- Always use TypeScript, never JS files.
- All API routes in /app/api/

## Known Issues
- Auth sessions sometimes expire on mobile—keep this in mind for any auth-related work

Outdated context is worse than no context.

An outdated CLAUDE.md sends Claude confidently in the wrong direction.

14. Link external files in CLAUDE.md instead of pasting them in

Don't stuff everything into CLAUDE.md.

Instead, reference external files:

# CLAUDE.md

## Architecture
See: /docs/architecture.md

## API Conventions
See: /docs/api-standards.md

## Current Sprint
See: /docs/sprint-23.md

Claude only loads what's needed.

Your context stays lean, your token budget stays healthy.

15. Immediately kill sessions that go off track

As soon as Claude veers off course, stop it immediately.

Don't let bad work accumulate.

Stop. This is not what I asked for.

Actual need: [restate clearly]
Constraints: [state constraints]
Start over with only these.

Bad work that accumulates is harder to fix than starting over.

Catch deviation early, re-prompt strongly.

16. Challenge the first output

Acceptance is the enemy of good work.

After every output:

What's the weakest part here?
If you had more time, what would you change?
Is there a simpler approach I should consider?

Claude's first answer is rarely its best answer.

The best answer comes after being challenged.

17. Set up notification hooks

Stop staring at the terminal.

Set up hooks to notify you when long tasks finish:

# Example: Send notification when Claude finishes
claude run "build the feature" && \
  osascript -e 'display notification "Claude finished" with title "Claude Code"'

Go do something else.

Come back when it calls you.

18. Send screenshots to Claude for layout verification

Claude can't see the application you're running.

But it can analyze screenshots of the application.

"Here's a screenshot of the current state.
The button alignment on mobile is broken.
Fix the CSS to match the design spec."

Paste the screenshot directly into the session.

10x faster visual debugging.

Advanced Tips At this level, Claude Code stops being just a coding assistant and starts feeling like a full team.

19. Chrome DevTools integration

Let Claude interact with your running application through DevTools.

It can read console errors, network requests, and DOM state in real time.

"Open DevTools on the checkout page.
Find the problem with the payment button not responding.
Check console errors and the network tab."

Debugging becomes: Claude sees the page, Claude fixes the page.

No more: you copy-paste errors, Claude guesses.

20. Resume previous sessions

Never lose context from a previous session.

claude --resume 9901b366-c4b6-4d78-89ad-81e964e373e

Claude opens the exact session—full conversation history, full context, and the exact spot you left off.

Find your session ID in Claude Code history.

Bookmark sessions you'll come back to.

21. Use Git Worktrees for parallel sessions

This is the biggest productivity unlock for serious projects.

Run multiple Claude sessions simultaneously on different branches.

# Create worktrees for parallel work
git worktree add ../project-feature-auth feature/auth
git worktree add ../project-feature-payments feature/payments
git worktree add ../project-feature-dashboard feature/dashboard

# Now run a Claude session in each directory separately
# Claude works on three tasks simultaneously
# Zero conflicts, zero waiting.

Session 1: Build auth. Session 2: Build payments. Session 3: Build dashboard.

All running at the same time.

That's how you deliver a week's work in a day.

22. Replace MCP servers with direct API endpoints

MCP servers add overhead.

For performance-critical or high-traffic work, call the API endpoint directly.

# Don't: use MCP server → Notion
# Instead: "Call the Notion API directly at api.notion.com/v1/pages
# Here's my API key format and endpoint structure."

Less overhead, fewer tokens consumed, lower latency.

Expensive tool calls → replace with direct API → immediate improvement.

23. Use /loop to automate repetitive tasks

Claude can keep executing tasks unattended for up to 3 days.

Set it up, then walk away.

Claude monitors, records, categorizes—for days.

24. Remote control from your phone

Manage your local Claude session remotely.

# Expose your Claude session via ngrok or similar
ngrok http 3000

# Access from your phone's browser
# Start a build while commuting
# Check progress without opening your computer

Especially useful when you've left your desk and remember something you forgot to start.

Open your phone, start the task, it's done by the time you get home.

25. Query the database in plain English

For one-off analysis, skip writing SQL entirely.

Claude converts to SQL, executes it, returns the answer.

No SQL to write, no schema to remember, just a question and an answer.

26. Use Ultrathink for truly hard problems

When a problem is really complex—allocate maximum token budget and explicitly tell Claude.

For 90% of tasks, fast is fine.

For that 10% of truly hard tasks—slow down.

The thinking budget is there; use it.

27. Use Ultracode mode in Opus 4.8

For the highest coding performance:

/effort high

This activates ultracode—Claude's highest-effort coding mode.

Reserve it for:
→ Complex architecture decisions
→ Security-critical implementations
→ Performance optimization passes
→ Multi-system refactors

It consumes more tokens, takes longer.

But for hard problems, it produces meaningfully better code.

The pattern behind the 27 tips

Every tip on this list falls into one of three categories:

Context discipline — CLAUDE.md, /init, /compact, /clear, file links. Give Claude better information, it makes better decisions.

Smart delegation — Sub-agents, Worktrees, parallel sessions, /loop. Stop doing one thing at a time when Claude can handle many simultaneously.

Proactive automation — Hooks, remote control, skills, database queries. If you've done it manually more than twice, Claude should be doing it.

Developers who deliver 10x the work aren't smarter than you.

They're just more systematic.

Where to start

Don't try to implement all 27 today.

Week 1: /init, /compact, plan mode, self-verifying to-do lists. Just these four will transform your sessions.

Week 2: Custom skills, lightweight models, CLAUDE.md updates, challenge every output. You'll stop rewriting the same instructions.

Week 3: Sub-agents, Worktrees, parallel sessions. You'll start shipping multiple features simultaneously.

Week 4 and beyond: /loop, Ultrathink, DevTools, remote control. You'll stop staring at the terminal entirely.

This system compounds on itself.

Each level makes the next one more powerful.

Start at the beginning, master it, then move up.

Quick reference

Beginner:
→ 1. /init — Generate project CLAUDE.md
→ 2. /statusline — Live token dashboard
→ 3. Voice input — Hands-free coding
→ 4. /context — Find token consumption
→ 5. /compact at 60%, /clear between tasks
→ 6. Start with plan mode — outline before executing
→ 7. Present problems, not instructions
→ 8. Let Claude ask questions before starting
→ 9. Add self-verification steps to to-do lists

Intermediate:
→ 10. Sub-agents for parallel isolated work
→ 11. Custom skills — store reusable prompts
→ 12. Haiku for simple tasks, Opus for complex
→ 13. Continuously update CLAUDE.md as project evolves
→ 14. Link external files, don't paste them in
→ 15. Kill deviations immediately — re-prompt strongly
→ 16. Challenge the first output every time
→ 17. Notification hooks — stop staring at the terminal
→ 18. Send screenshots for visual debugging

Advanced:
→ 19. Chrome DevTools integration
→ 20. claude –resume for session continuity
→ 21. Git Worktrees for parallel sessions
→ 22. Direct API calls instead of MCP servers
→ 23. /loop for multi-day repetitive tasks
→ 24. Remote control from your phone
→ 25. Plain English database queries
→ 26. Ultrathink for hard problems
→ 27. /effort high for Ultracode mode