Claude Code shipped and quietly became the default way serious engineers write software. Not because of hype — because it works. A terminal-based AI agent that reads your codebase, writes code, runs tests, and iterates until things pass. No GUI. No plugins. Just your terminal and a model that understands your entire project.
But most people are using maybe 20% of what it can do. They type a prompt, get some code, and call it a day. That is like buying a race car and only driving it to the grocery store.
These 15 tips come from building our entire company on Claude Code — every feature, every deploy, every bug fix. Some are obvious in hindsight. All of them changed how we work.
1. Write a CLAUDE.md File Before You Write Code
The single highest-leverage thing you can do. A CLAUDE.md file in your project root is a persistent system prompt that loads every time Claude Code starts in that directory.
What to include:
- Your tech stack and key dependencies
- Build and test commands (
npm test,swift build, whatever) - Code style rules — the ones your linter does not catch
- Architecture decisions and why you made them
- File structure overview so Claude knows where things live
A 30-line CLAUDE.md eliminates the re-explaining problem permanently. Claude reads it, understands your project, and starts every session with full context. This is the same principle behind custom instructions but scoped to your codebase.
2. Let It Run Tests — Then Fix Them
Most people ask Claude Code to write code. Power users ask it to write code, run the tests, and fix whatever breaks. This is the agentic loop in action: observe, act, observe, act — until the tests pass.
The prompt is simple: "Add the email validation to the signup form. Run the tests. Fix anything that fails." Claude Code will write the code, execute your test suite, read the failures, and iterate. Three rounds is typical. Five if it is a hairy change. The result is code that actually works against your existing test suite, not code that looks right in isolation.
3. Use Subagents for Parallel Research
Claude Code can spawn subagents — independent Claude instances that research a question without polluting your main context window. Use them for:
- Exploring unfamiliar parts of the codebase
- Investigating multiple potential solutions simultaneously
- Reading documentation while the main agent keeps working
Think of subagents as interns you send on research errands while you focus on the main task. They return with findings, you incorporate what matters.
4. Commit Discipline: Never Auto-Commit
Claude Code can create commits, but you should always review them first. The best workflow: let Claude Code make all changes, then review the diff yourself before committing. This catches hallucinated imports, unnecessary refactors, and subtle bugs that look correct but are not.
Good prompt: "Make the changes but do not commit. I will review the diff first."
5. Use the Todo Tool for Multi-Step Tasks
For complex tasks, tell Claude Code to break the work into a todo list first. It uses an internal todo tracker that persists across the session. Each task gets checked off as it completes, and you can see progress in real time.
This prevents the "it tried to do everything at once and made a mess" problem. Structured work produces structured results.
6. MCP Servers Are Your Secret Weapon
The Model Context Protocol lets Claude Code talk to external systems — databases, APIs, deployment platforms, anything with an MCP server. This turns Claude Code from a coding assistant into an operations platform.
Real examples from our setup:
- A brain MCP server that gives Claude Code access to our persistent memory database
- A Supabase MCP server for direct database queries
- A deployment MCP server that pushes code through our CI pipeline
If you are not using MCP servers, you are making Claude Code work with one hand tied behind its back. Check the MCP security checklist before deploying any server to production.
7. Scope Your Prompts Tightly
"Fix the app" is a bad prompt. "Fix the 403 error on the /api/auth/callback route when the session cookie is expired — the handler is in src/routes/auth.ts" is a good prompt. The more specific your prompt, the less Claude Code wanders.
Include: the file path, the function name, the expected behavior, the actual behavior. Claude Code will find these things on its own, but telling it upfront saves 2-3 rounds of exploration and keeps the context window focused.
8. Read Before You Edit
Always read a file before modifying it. This sounds obvious, but Claude Code's edit tool requires reading first for a reason — it prevents blind edits that break existing functionality. When reviewing Claude Code's work, check that it read the relevant files before making changes. If it did not, the changes are suspect.
9. Use Plan Mode for Architecture Decisions
Before building a major feature, put Claude Code in plan mode. It thinks through the approach without writing code. You review the plan, adjust it, then let Claude Code execute. This prevents the expensive mistake of building the wrong thing correctly.
Plan mode is especially valuable when you are building AI agents or designing systems with multiple interacting components.
10. Chain Commands With &&
When Claude Code needs to run sequential commands, chain them: swift build && swift test instead of running them separately. This is faster and gives Claude Code the full output in one shot, so it can correlate build warnings with test failures.
11. Keep Your Context Window Clean
The context window is finite. Every file read, every tool output, every long error log takes up space. When working on a long session:
- Start new conversations for unrelated tasks
- Use subagents for exploratory reads
- Be specific about which files to read — "read src/auth.ts lines 50-80" not "read the auth module"
A clean context window means better responses later in the session. A polluted one means Claude Code forgets what it was doing.
12. The Glob-Grep-Read Pattern
When Claude Code needs to find something in your codebase, the efficient pattern is: Glob to find files by name pattern, Grep to search content, Read to examine specific files. This is faster than bash commands and gives Claude Code structured results it can reason about.
If you notice Claude Code running find and cat commands, your CLAUDE.md should tell it to prefer the built-in tools.
13. Write Tests First, Then Implement
Flip the typical workflow. Ask Claude Code to write failing tests for the behavior you want, THEN implement the code to make them pass. This gives Claude Code a concrete target and a built-in verification loop. TDD works even better with an AI agent because the feedback cycle is instantaneous.
14. Use Git Worktrees for Parallel Work
Claude Code supports git worktrees — separate working directories for different branches. Use them to work on two features simultaneously without context switching. One Claude Code session in the main worktree, another in a feature branch worktree.
15. Build Your Own Skills
Claude Code supports custom skills — reusable prompt templates you invoke with a slash command. Build skills for your common workflows:
/review— code review with your team's standards/deploy— your deployment checklist/debug— structured debugging with logs and reproduction steps
Skills turn tribal knowledge into repeatable processes. Instead of remembering "how do we deploy again?", you type /deploy and Claude Code follows the same steps every time.
16. Master Permission Modes
Claude Code has three permission modes that control how much autonomy the agent has. Understanding these saves constant approve/deny friction:
- Default mode — Claude asks before running commands, editing files, or making network requests. Best for unfamiliar codebases where you want to review every action.
- Auto-approve mode — Claude executes without asking. Dramatically faster for trusted workflows like test-driven development or bulk refactoring. Enable with
--dangerously-skip-permissionsor configure per-tool in settings. - Plan mode — Claude analyzes and plans but does not execute. Use for architecture decisions or when you want a second opinion before making changes.
The power move: start in plan mode for complex tasks, review the plan, then switch to auto-approve for execution. This gives you strategic oversight without tactical friction.
17. Hooks for Automated Quality Gates
Hooks are shell commands that execute in response to Claude Code events — before or after tool calls, on session start, or on session stop. They are the key to building automated quality gates:
- Pre-commit hooks — Run linters and formatters before every commit. Claude will see the output and fix issues automatically.
- Post-edit hooks — Run type checking after file edits. Catch type errors immediately rather than discovering them during build.
- Session start hooks — Load project context, check git status, or run health checks automatically when Claude Code launches.
Configure hooks in ~/.claude/settings.json or per-project in .claude/settings.json. The best hooks are invisible — they catch problems before you even know they exist.
18. Context Window Management for Large Projects
Claude Code automatically compresses conversation history as you approach context limits, but proactive management makes a difference:
- Use subagents for research. Delegating file exploration to subagents keeps the main context clean for decision-making. The subagent reads dozens of files; your main context only sees the summary.
- Reset context between tasks. After completing a major task, start a fresh conversation. Stale context from previous work can confuse the model on new tasks.
- Front-load important information. Put critical constraints in CLAUDE.md rather than repeating them in prompts. CLAUDE.md loads into every conversation automatically and survives context compression.
For large codebases (100K+ lines), expect to reset context 2-3 times during a full feature implementation. Each reset is cheap — CLAUDE.md and your todo list carry forward automatically.
19. Custom Slash Commands for Repeated Workflows
If you run the same multi-step workflow regularly, build it into a custom slash command. Claude Code supports user-defined skills that trigger with a / prefix:
- Deployment commands —
/deploythat runs tests, builds, commits, and pushes in sequence with quality gates at each step. - Review commands —
/reviewthat reads changed files, checks for common issues, and suggests improvements. - Setup commands —
/setupthat installs dependencies, checks environment variables, and validates configuration for new team members.
Define skills in your project's .claude/ directory. Each skill is a prompt template that Claude Code expands and executes. The investment in writing a good skill pays back every time you use it — and your team can share the same skills for consistent workflows.
20. Debug Faster With Structured Error Prompts
When Claude Code encounters an error, the quality of your follow-up prompt determines how fast you reach a fix. Instead of "fix this error," provide structured context:
Team Enablement
Want to level up your entire engineering team with Claude Code? Our consulting services include workflow design, custom instruction templates, and team onboarding.
- What you expected — "The API should return a 200 with the user object."
- What actually happened — "It returns a 401 with 'invalid token' even though the token is valid in Postman."
- What you already tried — "I checked the token format and the auth middleware. Both look correct."
- How to Use Claude for Data Analysis
This pattern prevents Claude from investigating paths you already eliminated. It focuses the agent on the actual unknown rather than re-treading your debugging steps. For complex bugs, paste the full error trace — Claude Code handles long error output well and extracts root causes faster than scanning manually.
The Meta-Tip: Think in Systems, Not Prompts
The difference between someone who uses Claude Code and someone who builds with Claude Code is systems thinking. Individual prompts get individual results. A system — CLAUDE.md + MCP servers + custom skills + structured workflows — gets compounding results.
Every tip in this list is a component. Combined, they create an engineering environment where the AI handles the mechanics and you focus on the decisions. That is not incremental improvement. That is a different way of building software.
Not sure which Claude model to pair with Claude Code? Our Claude Sonnet vs Opus comparison breaks down when to use each.
The engineers who figure this out first will ship faster, with fewer bugs, at lower cost. The ones who treat Claude Code like a fancy autocomplete will wonder why.
Choose your category.
---
Want structured training on building with AI agents? The Like One Academy covers everything from RAG systems to self-improving agent architectures — with hands-on projects, not slides.