You get the best results from Claude Code by staying in control, using Plan mode, creating focused agents and skills, being explicit over implicit, trusting but verifying, and still writing code yourself when it is faster or clearer. I do not run Claude Code in a loop, I do not live code, and I prefer a workflow where Claude proposes a plan, I edit that plan, and then I approve the execution so I know exactly what is about to change.
Day to day, I install the extension, run Claude in multiple panes, prefer /model opus with a fallback to Sonnet, clear often, use the up arrow to revisit past chats, queue prompts, and launch with `claude –dangerously-skip-permissions` so it does not pester me for every file edit or lint command. I add the GitHub app for PR reviews and customize the review prompt to focus on bugs and security only, let Claude configure terminal behavior so Shift+Enter adds a newline, drag files with Shift so it references them, paste screenshots with Ctrl+V, press Esc to stop, press Esc twice to browse prior messages, and I keep Vim mode optional.
Efficient Claude Code Strategies: Stay in control
I do not loop, I do not Rolf, I stay in control. There is a lot of hype around handing a detailed product document to a Rolf loop that automatically works through every step, but I have not seen convincing results. Planning matters a lot, but I do not want the agent to run the plan on its own.
I use Claude Code on the Max plan for generous usage, but I still do not let it run unattended. AI is a great tool for developers, but I get better outcomes when I direct it and approve each stage.
Efficient Claude Code Strategies: Plan mode for safer changes
Plan mode is amazing because it gathers information, explores the codebase, and proposes a plan before editing anything. It saves weak prompts by asking clarifying questions and it shows what it intends to do.
Do not just accept the plan. Edit the plan so it matches your intentions, then approve it. That avoids unwanted edits, wasted tokens, and painful fixes later.
Good prompts still matter
Plan mode can rescue you, but good prompts with the right context are still essential. The output quality tracks the input quality, and there is randomness.
If your prompt already is solid, you still get a plan you can review, tweak, and approve. That visibility is the point.
Efficient Claude Code Strategies: Agents and skills that scale
I create sub-agents with dedicated context windows so the main session stays lean. My favorite is a Docs Explorer agent with web search and the Context7 MCP to browse documentation effectively.
MCP tools can be token heavy, so I prefer built-in tools and keep MCP usage focused. I also add project-specific skills that encode my preferences, like Next.js best practices and patterns I expect in this repo.
Skills are lazily discovered and loaded when relevant, which feeds Claude targeted rules without bloating the context. For a curated set you can adapt to your projects, see examples of high-value Claude Code skills.
Efficient Claude Code Strategies: Be explicit
I do not hope Claude guesses the path I want. I tell it exactly what to do.
If I am using BetterAuth with Google, I say so explicitly. I also instruct it to use the Docs Explorer agent to consult the relevant BetterAuth docs before implementing, so I do not find out later it skipped the research step.
Efficient Claude Code Strategies: Trust, but verify
If you provide a strong prompt and the right context, the results can be very good. Still, review the code and think critically about design choices, patterns, and long term maintenance.
Give Claude tools for self-verification. It can run unit tests, E2E tests, linters, or even a Playwright MCP session for browser checks, but be mindful that browser automation can burn a lot of tokens.
A quick verification flow
Have Claude generate or update tests, run the tests, and show the logs. Double check that tests validate behavior instead of being shaped to the implementation.
Run your own checks and keep responsibility for merges. You are in control.
Efficient Claude Code Strategies: You can still write code
You do not have to ask the agent to bump a margin from 0.5rem to 1rem. If a small change is obvious, I make it myself and save tokens.
I avoid outsourcing so much that I lose touch with the codebase. I read everything Claude proposes, I learn from it, and I stay able to jump back in and implement directly.
Efficient Claude Code Strategies: Terminal tips and daily workflow
Setup and launch
Install the Claude Code extension for VS Code, Cursor, or Windsurf. I often open Claude in multiple panes so I can run tasks in parallel on different files while keeping context relevant.
Claude uses a terminal UI that works well for tagging and including files. To stop permission prompts on every edit or lint, launch with `claude –dangerously-skip-permissions` after starting the session.
Model choice and tokens
I use `/model` and prefer Opus. If Opus has issues, I switch to Sonnet, and the defaults can auto-downgrade after about half of your usage is reached.
I use clear frequently when starting a new task to avoid long chat history compaction, which is another model call that costs tokens. The up arrow navigates back to past chats, even from prior sessions.
Navigation and control
Press Esc to stop Claude cleanly. Press Esc twice to see previous messages and jump around.
Let Claude configure your terminal so Shift+Enter inserts new lines. Drag files in with Shift to reference them, and paste images with Ctrl+V.
For an IDE-first experience with a visual UI that matches Claude Code’s mechanics, try a dedicated desktop approach. You can review an in-depth desktop IDE setup for Claude Code to see how it compares to the terminal UI.
Queue and memory
Claude supports queued prompts. I queue several follow ups, walk away, and it runs them intelligently when the current task completes or pauses for feedback if needed.
For memory, I use the # shortcut to add preferences and rules quickly. Store them in hierarchical Claude.md files, with project-level and nested directories, and Claude will prioritize the most specific file when relevant.
You can also maintain global user memory for reusable preferences. For team repos, keep project memory checked in and put personal memory in git-ignored locations.
Hooks, settings, and slash commands
Ask Claude to add default hooks, commands, and settings so it learns your build and lint commands once. It can run Prettier before edits are accepted and a type check after edits so only correct files get applied.
Create custom slash commands by adding files under `claude/commands`. Use an arguments string placeholder and Claude will inject your parameter into the prompt, and subfolders like `builder/plugin.md` map to slash paths like `builder:plugin`.
Efficient Claude Code Strategies: PR reviews in GitHub
Install the GitHub app so Claude automatically reviews each PR. I cut the noise by editing the added `claude-code-review.yaml` prompt to say: focus on bugs and security issues only, and be concise.
Claude often flags real bugs that humans miss while humans tend to nitpick names. With a tight prompt, you get a strong reviewer that scales as your PR count rises.
Efficient Claude Code Strategies: Large codebases and reliability
I have an 18,000 line React component that other agents struggle to update. Claude Code edits it reliably, applies patches without rewriting entire files, and rarely stalls.
It is excellent at navigating big repos, finding patterns, and understanding relationships between components and shared state. Anthropic builds both the model and the agent, which shows in stability and accuracy, and Max plan pricing gives generous model access.
Final thoughts
The core of my approach is simple. Stay in control, use Plan mode, add the right agents and skills, be explicit, verify results, and keep coding yourself when it is faster.
Tune your terminal workflow, queue work, add memory and hooks, and keep prompts tight. Claude Code rewards clarity, and these habits consistently produce strong results.