Stop Installing Plugins on Claude Code: Everything You Need Is Built In

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

/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%)

/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

/resume
/resume "auth-refactor"

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% used

for 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 available

i 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 reasoning

renaming 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

/cost
Session costs:
Input tokens: 45,230
Output tokens: 12,450
Total cost: $0.47
Context window: 67% used

/model sonnet    # 日常工作用，便宜又快
/model opus      # 复杂问题用，深度推理
/model           # 查看可用模型

/effort low      # 简单任务，快速响应
/effort medium   # 默认
/effort high     # 复杂推理

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

/init           # 根据代码库生成 CLAUDE.md
/doctor         # 验证所有配置是否正确

# .claudeignore
node_modules/
.next/
.git/
*.log
dist/
coverage/
public/images/

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

/review              # 审查所有最近的改动
/diff                # 准确查看改了什么
/security-review     # 安全专项审计

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 issue

now /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

# .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 issue

# .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

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

https://github.com/obra/superpowers

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

https://github.com/forrestchang/andrej-karpathy-skills

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

https://github.com/d-e-s-o/claude-context-mode

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