i had 23 plugins installed on claude code. 8 skills. 5 MCP servers. 3 custom agent frameworks. some context management tool i found on twitter at 2am
my sessions were slow. my context window was filling up before i typed my first real prompt. i was hitting limits faster than people on the free tier
then i ran /context for the first time and saw the breakdown:
62,000 tokens consumed before i even said hello
that’s 31% of my entire context window - gone. eaten by plugins that were supposed to make claude code better. and i hadn’t written a single prompt yet
i spent that weekend deleting everything. every plugin. every skill. every MCP server i wasn’t using daily. stripped it all back to built-in features only
my sessions got 3x longer. my outputs got sharper. my token spend dropped by half
turns out claude code already ships with everything i was paying plugins to do. i just never learned what was already there
here’s every built-in feature that replaced a plugin i was using
1 // context management
this alone replaces 5 plugins
context is the single most important resource in claude code. you have a 200k token window. everything competes for it - your conversation, system prompts, tools, files claude reads, command outputs. when it fills up, claude starts forgetting things, hallucinating, and producing garbage
most people install plugins to “manage context.” i had two. both were unnecessary because claude code has three built-in commands that do it better
/context - see exactly where your tokens are going
this is the command i wish i’d known about on day one. type /context and you get a full breakdown: how many tokens the system prompt uses, how much your tools take, how much conversation history is eating, how much space you have left
/context
Context Usage claude-opus-4-6
51k/200k tokens (26%)
System prompt: 2.6k tokens (1.3%)
Skills/plugins: 0 tokens (0%)
MCP servers: 3.2k tokens (1.6%)
Conversation: 45k tokens (22.5%)
Available: 149k tokens (74%)that’s what my context looks like now - after the cleanup. before, the skills and plugins line alone was 14k tokens. that’s 7% of my total context consumed by extensions sitting idle, waiting to be called, most of which i used maybe once a week
practical rule: run /context at the start of every serious session. if your baseline is above 30k before you type anything, you have a structural problem. fix that before doing any work
/compact - compress your conversation without losing context
this is the most underused command in all of claude code. experienced users run it every 20-30 minutes during active work. most people have never typed it once
when your conversation gets long, every new message costs more tokens because claude re-reads the entire history. by message 30, a single exchange burns 31x more tokens than your first one. /compact compresses all that history into a dense summary, freeing up space while keeping the important context
/compact focus on the auth module and current test failures
you can even tell it what to prioritize in the summary. “keep the database schema decisions, compress everything else.” it’s surgical
the difference between running /compact regularly and not running it: 30-minute sessions vs 3+ hour sessions on the same token budget
/clear - nuclear reset when you need it
/clear wipes everything. conversation history gone. fresh start. file edits stay on disk but the context is completely empty
the distinction matters:
- /compact keeps claude oriented on what happened.
- /clear starts from absolute zero.
- use /clear when you’re switching to something completely unrelated.
- use /compact when you’re continuing but need more room
before i learned these three commands, i was installing plugins that did worse versions of the same thing while eating thousands of tokens in overhead. now i just type a slash command and it’s done
2 // session control
stop losing your work
i used to have a plugin that saved my session state so i could resume later. turns out claude code has had this built in the whole time
/resume - pick up exactly where you left off
your terminal crashed. your laptop died. you closed the window by accident. doesn’t matter. type /resume and you get a list of every recent session. pick one and you’re back exactly where you were
/resume
/resume "auth-refactor"without arguments it opens a session picker. with a name it jumps straight there. you can even name sessions with /name so they’re easy to find later
/rewind - undo anything, anytime
claude rewrote your auth module and made it worse. /rewind rolls everything back - code and conversation - to an earlier checkpoint
Esc Esc - the hidden superpower
single Esc stops generation. everyone knows that. but double Esc opens something most people have never seen - a scrollable list of every checkpoint claude code created during your session. every file state. every conversation state. fully restorable
four options: restore code and conversation, conversation only, code only, or summarize from checkpoint forward
this changes how aggressively you can experiment. zero risk. full undo. let claude try wild approaches - if they fail, rewind costs nothing. i had a plugin that did a worse version of this. deleted it the same day i discovered Esc Esc
3 // cost and model control
stop overpaying for simple tasks
/cost - know what you’re spending in real time
if you’re on the API, /cost shows your running spend for the current session. no plugin needed. no external dashboard. just type the command
/cost
Session costs:
Input tokens: 45,230
Output tokens: 12,450
Total cost: $0.47
Context window: 67% usedfor Pro and Max subscribers, /stats shows your progress against your usage limits - both the 5-hour session limit and weekly cap
/model - switch models mid-session
this one saved me more money than any optimization trick i’ve ever tried
opus is powerful but expensive. it consumes roughly 2x the tokens of sonnet. and here’s the thing: sonnet is the right choice for 80% of coding work. it’s fast, capable, and cost-efficient. opus only matters for complex architectural decisions and deep debugging
/model lets you switch mid-session:
/model sonnet # cheap and fast for routine work
/model opus # deep reasoning for the hard stuff
/model # see what's availablei used to run opus for everything - formatting files, writing tests, renaming variables. now i switch to sonnet for simple tasks and flip back to opus only when i need it. same work, half the cost
/effort - control how hard claude thinks
/effort low # simple tasks, quick responses
/effort medium # default
/effort high # complex reasoningrenaming a variable doesn’t need the same cognitive effort as designing a database schema. /effort lets you tell claude how much thinking to invest. low effort on simple tasks = fewer tokens = longer sessions
Option+T - toggle extended thinking per message
extended thinking is powerful but expensive. adds significant tokens to every response. Option+T toggles it on and off per message instead of leaving it always-on
quick formatting question? leave it off. complex architecture decision? flip it on. back to a simple rename? off again. the toggle takes 0.2 seconds. the menu path takes 4
4 // project setup
10 minutes that save you hours
/init - let claude code set itself up
run /init in any project root and claude code generates a starter CLAUDE.md by scanning your codebase. it detects your stack, your file structure, your conventions, and writes a config file that every future session will read automatically
then customize it. add your conventions, your architecture decisions, your rules. the generated version is a starting point - you make it yours
/init # generate CLAUDE.md from your codebase
/doctor # verify everything is configured correctly/doctor checks that your MCP servers are connected, your skills are loaded, your permissions are set right. run it after any config change
.claudeignore - keep junk out of context
just like .gitignore keeps files out of git, .claudeignore keeps files out of claude code’s context window
# .claudeignore
node_modules/
.next/
.git/
*.log
dist/
coverage/
public/images/every file claude reads eats tokens. every directory it scans costs context. .claudeignore is the simplest way to keep your sessions lean. i had a plugin that “optimized file reading.” turns out .claudeignore does the same thing in 5 lines
5 // code quality
better than most review plugins
/review - built-in code review
type /review and claude analyzes your recent changes. it checks for bugs, style issues, potential problems, and suggests improvements. more targeted and context-aware than asking “review my changes” in a freeform prompt
/review # review all recent changes
/diff # see exactly what changed
/security-review # security-focused audit/diff shows every change in your working directory. /security-review scans specifically for vulnerabilities. i was using a separate security plugin for this - deleted it after discovering /security-review does the same thing with zero overhead
/plan - think before coding
before claude starts writing code, reading files, and running commands, /plan makes it produce a structured breakdown of what it intends to do - without actually doing any of it
this saves tokens because you catch misunderstandings early. if claude plans to read six files when you only need two, you correct that before it burns context reading files it doesn’t need
switch to plan mode before any complex task. review the plan. adjust. then execute. it’s the difference between precise work and expensive guesswork
6 // keyboard shortcuts
the fastest way to do everything
these aren’t commands, they’re muscle memory. once you learn them, you’ll never go back
Shift+Tab - cycle permission modes
claude code asks permission for every file edit and every command. safe but slow. Shift+Tab cycles through three modes:
- normal: asks permission for everything (safe, slow)
- auto-accept: executes without asking (fast, trust required)
- plan: shows what it will do but doesn’t execute (review first)
switch to auto-accept when you’re iterating fast on code you understand. switch to plan when claude is doing something risky. back to normal for sensitive code. one keypress changes the entire interaction speed
Ctrl+R - search your prompt history
claude code keeps your full prompt history across sessions. Ctrl+R lets you fuzzy-search through all of it
you ran a complex prompt three days ago that worked perfectly. instead of retyping it or scrolling through terminal history: Ctrl+R, type two keywords, it’s back. after a month of use your prompt history is a personal library of everything that worked
Ctrl+G - write prompts in a real editor
the terminal input is one line. writing a multi-paragraph prompt with specific instructions in a single terminal line is painful. Ctrl+G opens your default text editor - vim, VS Code, whatever you have set. write your prompt properly. save and close. it sends
mandatory for anyone writing detailed prompts. the terminal input wasn’t built for paragraphs. your editor was
/btw - ask a side question without interrupting
claude is mid-task, three files deep in a refactor. you suddenly need to know something - “what file has the auth middleware?”
before /btw: cancel the whole task, ask your question, then re-prompt the original task. all context from the interrupted work - gone
/btw lets you ask a side question while claude keeps working. the answer comes without touching the main task’s conversation history
7 // custom commands
build your own plugins in 30 seconds
here’s the thing most people don’t realize: the majority of plugins are just markdown files with instructions. you can build the same thing yourself in .claude/commands/
create a markdown file. put instructions in it. it becomes a slash command
# .claude/commands/fix-issue.md
Read GitHub issue #$ARGUMENTS
Create a branch named fix/issue-$ARGUMENTS
Write a fix with tests
Open a PR with a description referencing the issuenow /fix-issue 456 does exactly what a plugin would do - but with zero overhead, zero dependencies, and zero extra tokens consumed in your context window
# .claude/commands/review-pr.md
Review the current PR diff
Check for: security issues, missing tests, style violations
Provide a summary of changes and a pass/fail verdict/review-pr. custom workflow. zero tokens in baseline overhead. you wrote it in 30 seconds
for teams: commit these to your repo in .claude/commands/. everyone gets the same workflows. treat them like code - review them in PRs, iterate on them, version them
this is literally what most plugin marketplaces sell you. except it’s free, weighs nothing in context, and you control every word of it
the configuration paradox
here’s what nobody in the claude code ecosystem talks about: every plugin, every skill, every MCP server you install adds baseline overhead to your context window. they’re loaded at the start of every session whether you use them or not
claude code caps individual rule files at 6,000 characters and total combined rules at 12,000. those limits exist for a reason. anthropic’s own docs say it plainly: “for each line, ask: would removing this cause Claude to make mistakes? if not, cut it”
i had 62,000 tokens of overhead before typing my first prompt. that’s nearly a third of my entire context window - consumed by tools sitting idle
after the cleanup: 6,000 tokens of baseline overhead. 156,000 tokens available for actual work. sessions that used to die at 30 minutes now run for 3+ hours
the math is simple: fewer plugins = more context = longer sessions = better output
the exceptions (what’s actually worth installing)
i’m not saying never install anything. i’m saying install with intention. here’s what survived my cleanup:
> superpowers - the only skills framework worth the overhead. structured dev methodology that actually changes how claude approaches work. 170k+ stars for a reason
> karpathy’s 4 lines - 4 behavioral rules that prevent claude from assuming, overcomplicating, touching code you didn’t ask about, and shipping without verification. 60k+ stars
> context-mode MCP - if you do use MCP servers, this one sandboxes their output so they don’t dump 10,000 tokens of raw JSON into your conversation. routes tool outputs into a separate knowledge base. your context stays clean
three extensions. total overhead: ~4,000 tokens. everything else? built-in commands that cost zero
the full list
every single one is built in. every single one costs $0. every single one is available right now in your terminal
stop installing plugins. start using what’s already there
follow me @regent0x_to study and research only pure alpha thx for reading. don’t forget to bookmark this