Claude Code / Prompt Champs

20 Claude Code Features I Actually Use (Beginner to Pro)

07:37 runtimePublished June 30, 202620 key ideas

It's 1am, and you've got seven browser tabs open. You copy a function out of your editor, paste it into a chat, copy the answer back, and paste it in. You explain your project again — the fifth time this week —…

Watch on YouTube

The complete breakdown

It's 1am, and you've got seven browser tabs open. You copy a function out of your editor, paste it into a chat, copy the answer back, and paste it in. You explain your project again — the fifth time this week — because the AI forgot everything the second the window closed. Then you look up and it just rewrote the wrong file, and your working code is gone. That knot in your stomach? It doesn't have to be there. The gap between fighting this tool and flying with it isn't talent, and it isn't more typing. It's a handful of small moves most people never switch on — the ones that let you work calmer, ship faster, and stay in control of every change. Here are twenty of them, counting down to the one that changes how you start.

Use this page with the video

Watch the episode above for the visual explanation, then use the notes below to revisit each idea, example, and practical move.

01

Reference Files With @

You paste half a file, it asks for the rest, and three minutes vanish to copy-paste. Type @src/auth.py explain the login flow — the @ autocompletes the path and reads the whole file inline. Full context in one line, zero pasting.

Type @path to pull in a whole file

02

Paste a Screenshot

The button sits ten pixels off-center and words can't capture it. Hit Cmd+V (Ctrl+V on Windows) to drop the screenshot into your prompt, then ask why it's misaligned. It reads the image and works from what you see, not guesswork.

Cmd+V drops an image it can read

03

Compact and Clear

An hour into debugging, replies slow as the chat fills with dead ends. Run /compact keep the final fix to shrink the history to what matters, or /clear to wipe the slate. You get room to think without losing the fix you earned.

/compact trims, /clear resets chat

04

Switch Models Mid-Task

You're paying opus-level effort to rename a variable. Type /model haiku for the quick, cheap turns, then /model opus the moment you hit the hard problem. You match horsepower to the task instead of overspending on every edit.

/model swaps speed for depth

05

Press Esc to Interrupt

It's three paragraphs into editing the wrong file and clearly going sideways. One press of Esc stops it cold, keeps the work so far, and waits. Say review it instead and you redirect in seconds, with no runaway edit to undo.

One Esc halts it, keeps work

06

Resume Where You Stopped

You closed the terminal, and an hour of built-up context feels gone. Run claude --continue to reopen the previous session, or /resume to pick from a list. Every file and decision sits where you left it, so you start from progress.

claude --continue reopens the thread

07

Save Custom Slash Commands

You retype the same six-step release prompt every Friday and fumble a step. Save those steps as a markdown file in .claude/commands/ and run it with /release. The workflow in your head becomes one command the whole team can fire.

Store a workflow as /yourcommand

08

Give It Project Memory

Every session opens with you re-explaining that tests run before commits. Put your rules in a CLAUDE.md file — like always run npm test before committing — and it loads automatically. Write the standard once, stop repeating it.

CLAUDE.md auto-loads your rules

09

Stop Approving Every Edit

You've clicked yes forty times on edits you already trusted, breaking focus each time. Press Shift+Tab to cycle into acceptEdits mode and it stops asking on safe changes. The flow keeps moving, and you still see every edit.

Shift+Tab into acceptEdits mode

10

Background a Running Task

Your test suite takes four minutes and you're stuck watching a spinner. Press Ctrl+B to send the dev server or the test run to the background, then keep prompting while it churns. You get those minutes back to keep building.

Ctrl+B runs a task in the background

11

Auto-Run After Edits

You keep forgetting to format the file, so the diff fills with whitespace noise. Add a PostToolUse hook in .claude/settings.json that runs your formatter after every edit. The cleanup happens on its own, so each change lands tidy.

A PostToolUse hook runs after edits

12

Connect Real Tools

You bounce between the terminal and GitHub, copy-pasting issue text by hand. Connect an MCP server for GitHub, a database, or Figma, then say find issue 1234 and open a PR. It reads and writes those tools directly, no middleman.

MCP servers touch your real tools

13

Isolate Work in a Worktree

You want to try a risky feature but not on the branch you ship today. Run claude --worktree feature-x and it works in a separate worktree and branch. Its edits never touch your current files, so you experiment and merge only wins.

claude --worktree isolates its edits

14

Rewind a Bad Change

A refactor spiraled and three files are tangled with no clean undo. Run /rewind (or tap Esc Esc) to restore your files and the conversation to any earlier turn. You roll back to the moment before it went wrong and start clean.

/rewind restores an earlier turn

15

Delegate to a Subagent

Mapping how a library handles threading would bury your main thread in noise. Hand it to a subagent from .claude/agents/ that works in its own context and returns only the answer. Your main conversation stays clean and on task.

Subagents work in their own context

16

Teach It Reusable Skills

Deploy steps clutter every session even when you're nowhere near deploying. Write a Skill in .claude/skills/<name>/SKILL.md and it loads only when the task calls for it. The playbook appears when you deploy, and hides otherwise.

A Skill loads only when needed

17

Let It Think First

A race condition that only shows up under load gets a fast guess and a wrong patch. Ask it to reason the problem through before it acts, spending the thinking up front. The first attempt hits the real cause, not another loop.

More reasoning, fewer wrong tries

18

Run It Headless

You want a security pass on every diff without babysitting a chat. Run claude -p "..." to fire it non-interactively, so it slots into scripts and pipes. Try git diff | claude -p "flag any security risks" for plain-text output.

claude -p pipes it into any script

19

Make It Verify Itself

It says the form works, but build it and confirm every field saves has burned you before. With the Playwright tool it runs your app, screenshots the result, and checks its own work first. You get code that passed a browser test.

Playwright lets it test its own work

20

Plan Before It Touches Code

Letting it edit before anyone agreed on the approach is the fastest way to waste an hour. Press Shift+Tab into plan mode: it explores your code, proposes a plan, and waits for your yes before touching a file. Decide, then build.

Shift+Tab to plan before any edit

More practical AI guides, without the hour-long lecture.

Subscribe on YouTube