What Claude Code Can Do That You Haven't Tried

Claude Code has roughly a hundred slash commands, and most of us use about five of them. That’s not laziness - it’s that the tool is powerful enough that you hit a productivity jump early, stop digging, and never discover the other 90%. Then the product ships something new every week and the gap widens.

This guide closes some of that gap. It’s a distillation of Gui Ferreira’s rapid-fire NDC AI 2026 talk, What Claude Code Can Do That You Haven’t Tried - about 40 features he actually uses day to day, grouped into four buckets: things you set up once, moves for your daily loop, ways Claude Code is a platform you can extend, and uses that have nothing to do with code. Every command below is verified against the current Claude Code docs.

Tip

Don’t try to adopt all 40. If two or three of these make it into your week, you’ve won. And if you only run one command from this page, make it /insights at the end.

What you’ll walk away with

• A CLAUDE.md that helps instead of bloating your context - and the three questions to prune it with
• Personal, shared, and global instruction layers that don’t step on each other
• A .claude/settings.json that stops secrets from ever reaching your context window
• Daily-loop moves: edit the plan instead of re-prompting, rewind instead of patching forward, match model and effort to the task, and keep working while Claude works
• Claude Code as a platform: hooks, skills that bundle real scripts, the skills Anthropic already ships, and project-scoped MCP
• Uses beyond code: your notes, your brag document, and your junk-drawer folders

Set it up once

These are the “do it now, benefit forever” configuration wins.

One source of truth in CLAUDE.md

CLAUDE.md is the heart of the agent in a project (the same idea as AGENTS.md in other tools). After a while you notice the same rules duplicated across a README, a couple of markdown files, and CLAUDE.md itself. Kill the duplication with @ imports: reference a path and Claude loads that file into context at session start.

See @./README.md for how to run the pipeline.
Coding rules live in @./docs/conventions.md.
API shape: @./openapi.yaml

It works for non-markdown files too (schemas, config), and relative paths are fine.

Less is more - the three-question prune

The instinct is to make CLAUDE.md exhaustive. Gui cites a study from ETH Zurich that tested projects with no instruction file, a machine-generated one, and a human-curated one - and found that piling in ultra-specific instructions eventually drops answer quality while pushing cost up by 20%+. Human-curated beat machine-maintained. Before a line earns its place, ask:

1. Do I need this for (almost) every conversation? If it’s relevant to maybe 5% of chats, move it out.
2. Is it specific or occasional - or only for certain files? Then it doesn’t belong in the always-on file. Put it in an Agent Skill, or in a rules file under .claude/rules/ that uses a paths: glob so it only loads when you touch those files.
3. Can the agent just find it? File trees and “where do controllers live” go stale and waste tokens - a modern agent discovers your layout on its own. Skip it.

Personal, shared, and global layers

Your CLAUDE.md is shared with the team, so team-specific things belong there. But some rules are yours:

• Personal, per-project: a git-ignored CLAUDE.local.md picks up your own preferences (say you love TDD and your teammates don’t) without imposing them on anyone.
• Global, every project: ~/.claude/CLAUDE.md in your user profile applies to every session on your machine. Put durable style preferences there - “be concise,” “answer in bullet points.”

Lock secrets out of your context window

When Claude debugs a database error, it will happily read your .env, app settings, and secrets files chasing the connection string - and everything it reads goes into the context window, and therefore to Anthropic. Get ahead of it. In .claude/settings.json, deny reads and dangerous commands:

{
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./**/appsettings*.json)",
      "Bash(dotnet user-secrets*)"
    ]
  }
}

Nobody should commit production keys to a local repo - but it happens, so protect the whole team from the default behavior. The same layering as memory applies: set global denies in ~/.claude/settings.json so you never forget them on the next project.

A status line you actually read

Juggling several terminals and losing track of which is which? Run /statusline and describe, in plain language, what you want shown under the prompt. Favorites: current git branch, active model, and remaining context (are you at 2% or 80%?). Not sure what’s available? Ask Claude - it’ll suggest fields.

Sharpen your daily loop

The high-frequency moves. This is where the minutes add up.

Plan first - then edit the plan, don’t re-prompt it

If you’re already using plan mode (cycle into it with Shift+Tab), here’s the upgrade: when the plan is 90% right but one or two lines are wrong, don’t argue with it in a new prompt. Edit the plan directly and hand it back. In the talk Gui pops the plan open as a markdown file (Ctrl+G in his setup), fixes the lines, saves, and continues. You save a round-trip, tokens, and your sanity.

Going further with spec-driven work, the failure mode is Claude silently filling gaps with assumptions you only discover after it builds the wrong thing. Flip it around - make Claude interview you:

Before writing any plan, interview me about every assumption in this
document. Ask one question at a time and don't stop until nothing is
ambiguous.

This surfaces decisions you never knew you were making. (It leans on the same multiple-choice “ask the user” prompting you see when plan mode offers you Option A / Option B.)

Rewind instead of patching forward

Picked MVC, saw the result, and now want minimal APIs instead? Re-prompting keeps all the old research and the abandoned implementation in context, where it costs tokens and skews the next iteration. Claude Code has a time machine: double-Esc or /rewind jumps the conversation (and your code) back to a checkpoint. Go back to where you chose Option A, choose differently, and move forward clean.

Right model, right effort

Planning is the heavy lifting - use a strong model there. Once the plan is detailed, switch to a cheaper model to execute; it’s just following instructions. You don’t commit to one model for the whole session:

• /model swaps the model mid-conversation (your status line shows which one is live).
• /effort sets the reasoning level (low → max) from that point on - great for hard stretches, pricier per turn.
• For a single high-stakes prompt, just write ultrathink in it (Claude escalates through think → think hard → ultrathink). It tells Claude to spend the tokens it needs on this one.

Ask a side question without interrupting

Claude’s mid-task and you have a quick question - but a normal prompt just queues behind the current job. Use /btw (as in “by the way”): it answers your side question in parallel, using the existing context, without derailing the run.

Watch cost and context

• /usage shows what you’ve spent and which models you lean on (and end-of-year, it makes a great LinkedIn screenshot). With API-key billing it shows cost right in the terminal, in more detail than the website.
• /context visualizes what’s filling your window. Try this today: open a fresh session and run /context before doing anything. If you’re already at 4-6%, some MCP server or skill you installed months ago is loading by default on every run. Audit it.
• The dumb zone: above roughly 40-50% context use, quality, accuracy, and grounding start to slip (a term from HumanLayer’s Dexter Horthy). When you cross it, don’t soldier on.
• /compact summarizes the conversation and drops you from ~99% back to ~15-20%, keeping the key facts. Claude does it automatically at the limit, but you can - and should - trigger it yourself in the dumb zone. And don’t ride one session forever: /clear for a genuinely fresh start.

Prune memory before it misleads you

Auto memory is great - tell Claude “show this kind of thing as a diagram” and it remembers. But memories are just files, they live forever in that project, and they go stale. Run /memory to audit and delete entries that no longer serve you. (If you’ve ever read your ChatGPT memories and found it convinced your name is Emily, you know the value of a cleanup.)

Shell out fast with bash mode

Start a line with ! to drop into bash mode: everything after runs as a shell command directly, skipping the reasoning step (Claude won’t stop to think about your npm test or dotnet run). One caveat - the command’s output still lands in the context window, so don’t run something that prints secrets.

Resume where you left off

Closed everything to travel and want back in next week? claude --continue (-c) reopens the most recent session in this project; claude --resume (-r) or /resume lists past conversations so you can pick the exact one. Great for bouncing between tasks without losing context.

Leave your desk

/remote-control (alias /rc) makes the session available from claude.ai, so you can keep driving it from your phone while your laptop stays home. Define the plan, start the run, go for a walk - approve or reject changes from your phone as the notifications arrive. Say what you like about work-life balance, but it beats being chained to the desk.

Talk instead of type

Rubber-ducking works because speaking unlocks connections that writing doesn’t. /voice turns on dictation - hold the spacebar and talk. Worried you ramble when you speak? The model doesn’t care; it finds the meaning, and you can always edit the transcribed prompt before sending.

Paste a picture

Claude Code is multimodal in the terminal, not just in the apps. Paste an image (on macOS that’s Ctrl+V, not Cmd+V) or drag-and-drop it. Screenshot a design, a competitor’s UI, or a Figma frame and ask Claude to build something like it - now it has a visual to match, not just your words.

Run several things at once

Working in parallel is the new normal - waiting on one job while it asks “accept? accept?” is a waste. A few features make parallelism sane:

• Worktrees. Claude Code can isolate a session in its own git worktree (claude --worktree <name> / -w), so a feature, a bugfix, and a code review run side by side without fighting over the same working tree.
• /color and /rename tag each session with a color and a name (“red = the bug, blue = the feature”), so you recognize terminals at a glance.
• /goal sets a completion condition and Claude works across turns until it’s met - “build the invoice endpoint; don’t stop until a test produces a PDF invoice like this one.”
• Auto-accept mode lets Claude approve steps it judges safe instead of prompting for each one (cycle permission modes with Shift+Tab). It costs more tokens, so scope it - but it pairs perfectly with /goal for long unattended runs.
• claude agents opens the agent view: a dashboard of your background sessions (in progress, blocked, done) where you can launch new ones from a single window. (/tasks is the in-session version.)

Treat Claude Code as a platform

Claude Code is a set of tools you can extend - sub-agents, skills, hooks, MCP. Two extension points are badly underused.

Hooks: save tokens and catch mistakes early

A hook runs a shell command on an event, outside the model’s context window. Add a PostToolUse hook to .claude/settings.json and it fires after a tool call - costing zero tokens and able to hard-stop the run when something breaks. If your CLAUDE.md says “always run the tests after editing,” that’s a hook, not a prompt instruction: hooks are deterministic and free, prompts are neither.

Skills are more than a recipe

An Agent Skill is a folder with a SKILL.md whose description Claude loads by default and invokes when relevant (or you call it with /skill-name). The part people miss: a skill can bundle scripts and reference docs, not just instructions. Need to hit an API with a few odd endpoints? You don’t need to stand up an MCP server - drop the Python script you already have into the skill with a SKILL.md explaining how to run it, plus a “if this fails, try that” reference. It’s a small app packaged inside your .claude folder.

Skills Anthropic already ships

You don’t have to write or shop for everything - Claude Code ships with the skills Anthropic uses to build Claude Code:

• /batch splits a big change into ~5-30 units of work and runs several agents in parallel. Reach for it on sweeping refactors and mass file edits instead of orchestrating that yourself.
• /simplify reviews what you just wrote for needless complexity (LLMs trend toward it) and can apply the cleanups. Try it before hand-rolling a code-review skill.
• /loop re-runs a prompt on an interval - e.g. “every 5 minutes, check the CI run” via the GitHub MCP - so you stop refreshing the Actions tab and just get told when it’s green.

Note

/code-review is another first-party one worth knowing. Browse the plugin marketplace with /plugin - a plugin bundles hooks, skills, and MCP servers together.

Scope MCP and plugins to the project

Install a plugin or MCP server and it lands in your user profile by default - so a GitHub MCP loads even in a project that uses Bitbucket, eating context everywhere. Instead, commit a .mcp.json at the project root listing the servers that project needs. They load only inside that project, your context stays lean, and the whole team gets the same servers.

Headless mode for scripts

Claude Code doesn’t have to wait for you. claude -p "summarize this folder" (--print) runs one prompt non-interactively and prints the result - so you can pipe files in, pipe output to a file, and drop Claude into a shell script or pipeline as the reasoning step.

Beyond code

The name “Claude Code” undersells it. Anything on your disk is fair game.

• Your notes. An Obsidian vault is just plain markdown files - which AI loves. Point Claude Code at the vault to summarize notes, link related ones, or pull a web page into a note. You can even embed Claude Code as a terminal inside your note-taking flow.
• Your brag document. One-on-ones and review season mean reconstructing what you did from Jira and your calendar - painful. Ask Claude Code to summarize what you shipped last week or last month (it can see your code contributions), and wrap it in a skill so next review it’s one command.
• Your junk-drawer folders. A 1,600-item Downloads folder you’re afraid to delete? “Go through Downloads and organize it by type.” Now installers and clone-able code are obvious to remove, and the rest is sorted. The scripty version: point headless mode at a pile of log files or Windows Event Viewer exports and have it summarize the errors, piping the result to a file.

Before you close the terminal

If you run one command from this whole page, run /insights. It generates a report on how you actually use Claude Code - your common project areas, your interaction patterns, where you hit friction, and skills worth creating. It’ll teach you more about your own workflow than a month of LinkedIn posts.

Cheat sheet

Command / trick	What it does
@path in CLAUDE.md	Import a file into context - kill duplication
CLAUDE.local.md	Git-ignored personal instructions per project
~/.claude/CLAUDE.md	Global instructions for every session
.claude/settings.json → permissions.deny	Block reads (.env) and risky Bash
.claude/rules/ + paths:	Rules that load only for matching files
/statusline	Custom status line (branch, model, context left)
Shift+Tab	Cycle permission modes (incl. plan, auto-accept)
Ctrl+G	Open the plan as editable markdown (per the talk)
double-Esc / /rewind	Time-travel the conversation and code back
/model, /effort, ultrathink	Match model / effort to the task
/btw	Side question in parallel, no queue
/usage, /context	See cost; see what fills the window
/compact, /clear	Summarize, or start fresh
/memory	Audit and prune saved memories
! prefix	Bash mode - run a shell command directly
claude -c / -r, /resume	Continue or pick a past session
/remote-control (/rc)	Drive the session from your phone
/voice	Voice dictation
Ctrl+V (macOS)	Paste an image into the terminal
claude -w <name>	Isolate a session in a git worktree
/color, /rename	Color-code and name sessions
/goal	Work until a completion condition is met
claude agents, /tasks	Agent dashboard for parallel work
PostToolUse hook	Run a command after a tool call, off-context
/batch, /simplify, /loop	Built-in skills: fan-out refactor, de-complexify, poll
.mcp.json	Project-scoped MCP servers
/plugin	Plugin marketplace (hooks + skills + MCP)
claude -p "..."	Headless mode for scripts and pipes
/insights	A report on how you use Claude Code

---

Based on Gui Ferreira’s talk at NDC AI 2026, “What Claude Code Can Do That You Haven’t Tried.” Want the fundamentals first? Start with the Claude Code quick start.