How International Experts Use Claude Code? (With Best Tips)

node ByteNotebook 2025-07-12 16:34

July 11, 2025, Author: Steve Sewell

https://www.builder.io/blog/claude-code

Original Translation:

I've been a heavy Cursor user for over a year. I've written Cursor tip guides that thousands of developers reference weekly. I've dug deep into every advanced feature of Cursor and best practices for agentic patterns.

Yet I abandoned all of that and switched to Claude Code.

For several weeks, I've been using Claude Code exclusively instead of Cursor's agent features. Honestly, there's no going back.

Here's how I use Claude Code and tips for getting the best experience.

Use VS Code Extension

First: Install the Claude Code extension. It works for VS Code, Cursor, and probably Windsurf too. Don't expect any surprises—it's basically just a launcher. But it makes opening Claude Code super simple, and as long as they're working on different parts of the codebase, you can run multiple instances in parallel in different panes of your IDE.

I still use Cursor for quick Command+K completions and tab completions. But the agent sidebar? I only touch it when Claude is down.

It's strange how my workflow has evolved. I used to have Claude as a small sidebar while coding in the main editor. Now I default to Claude first and only glance at code when reviewing changes. It's become my primary interface, not secondary.

Terminal UI is Pretty Good

Yes, I was skeptical too. Terminal interface for chat-based code editing? Sounds like going backward. But Anthropic did it well.

You can easily tag files with @, use slash commands (very helpful), and precisely select what context to include. Unless Opus has issues, I mainly use Opus, then switch to Sonnet. Most people should probably use the default setting—it uses Opus until you hit 50% usage, then switches to Sonnet for cost efficiency.

Pro tip: Use /clear frequently. Every time you start a new task, clear the chat history. You don't need all that history eating your tokens, and you definitely don't need Claude running compression calls to summarize old conversations. Just clear and move on.

Up arrow lets you browse past chat history, even from previous sessions. Handy when you need to reference something from yesterday.

Permission System Will Drive You Crazy

The most annoying thing about Claude Code: it asks for permission for everything. You type a prompt, it starts working, you go check Slack, come back five minutes later, and it's sitting there asking "Can I edit this file?"

Yes, you can edit the file. That's the whole point.

Same with running basic commands. "Can I run lint?" Yes. For heaven's sake, of course.

But there's a solution. Every time I open Claude Code, I hit Command+C and run claude --dangerously-skip-permissions. It's not as dangerous as it sounds—think of it as Cursor's old yolo mode. Could a rogue agent theoretically run destructive commands? Sure. Have I seen this happen in my weeks of usage? Never.

It depends on your risk tolerance, but I sleep soundly at night.

GitHub Integration is Actually Useful

One of the cooler slash commands is /install-github-app. After running it, Claude will automatically review your PRs.

This is actually useful because as you use more AI tools, your PR count increases. Honestly? Claude often catches bugs that humans miss. Humans nitpick variable names. Claude finds actual logic errors and security issues.

The key is customizing the review prompt. The out-of-the-box prompt is too verbose and comments on every little detail. Claude will add a claude-code-review.yml file with a prompt already there. Here's the alternative version I use:

# claude-code-review.yml
direct_prompt: |
  Please review this pull request and look for bugs and security issues. Only report errors and potential vulnerabilities you find. Please be concise.

We found the original issue with this tool was it was really verbose. It would comment on all sorts of minor, unimportant things and write a whole essay on every PR. What we really care most about are bugs and potential vulnerabilities. So we explicitly tell it that and ask for conciseness.

It can also do other cool things like pull comments from GitHub pull requests and resolve them, or directly review pull requests.

Quirks You Need to Know

Since it's a terminal interface, there are some non-obvious behaviors:

• Shift+Enter doesn't line break by default. Just tell Claude to set up your terminal with /terminal-setup and it'll fix it for you.
• Dragging files will usually open them in new tabs like in Cursor or VS Code. Hold Shift while dragging to properly reference them in Claude.
• Pasting images from clipboard doesn't work with Command+V. Use Control+V. Took me forever to figure this out.
• Stopping Claude isn't Control+C (that exits completely). Use Escape to actually stop Claude.
• Jump to previous messages: Press Escape twice to show a list of all previous messages you can jump back to.

There's also a Vim mode if you're into that. I'm not.

Claude Code Handles Large Codebases Better

Here's the real difference: We have an 18,000-line React component at Builder. (Don't @ me about code organization, I know.) No AI agent except Claude Code has successfully updated this file.

With Cursor, I still run into lots of small issues. It struggles with resolving patches, often needs to rewrite files, and really struggles with updating extremely large files.

It's not just about file size—Claude Code excels at complex tasks. I find it rarely gets stuck (I'm not even sure I've noticed it happening). With Cursor, I feel like I have to babysit it more, and when it gets stuck, I have to stop it and realize maybe this isn't a good task.

Claude is also incredibly good at navigating large codebases, searching for patterns, understanding relationships between different parts of code, components, shared state, etc. It's really incredible.

Economics Make Sense

Think about it: Cursor built a generic agent supporting multiple models. They need a whole team, plus they train custom models, plus they need to profit on top of paying Anthropic for underlying model costs.

Anthropic definitely makes the best coding models, and they make Claude Code use those models best. When they encounter challenges with Claude Code, they go improve the models.

They know everything about how models work, how to train them, and how to use them deeply. They continue training models to work well with their needs for Claude Code.

This also means Anthropic can give you the most value at the lowest price because you only need to worry about paying them.

They can compete on giving you access to the biggest models (like Opus) without situations like Cursor has, because Cursor also needs to make money.

It's like buying directly from the manufacturer instead of through a dealer. Of course it's better.

Pricing is Reasonable

I pay the top plan at $100/month. If you think a shockingly intelligent coder working 24/7 isn't worth $100/month, you need to look at what you charge for your own time. Look at the hourly human cost of engineers anywhere in the world—it's orders of magnitude higher than this.

Any manager doing this math would see it's absolutely worth it, even at the highest possible pricing tier.

Queue System is Convenient

A feature I can't live without: message queuing. You can type multiple prompts and Claude will intelligently handle them.

I used to create a notepad and start drafting other prompts I wanted to do. Then when I saw one complete, I'd go paste the next one and hit enter. That's what I did with Cursor, and it was really annoying because I'd usually continue my day, answer Slack messages, answer emails, do other things, then come back to see the agent had been idle for who knows how long.

Now I just queue everything: "Add more comments," "Actually also...," "And... also." Claude is really smart about knowing when it should actually run these things. If it needs your feedback, it won't automatically run queued messages. It's a very intelligent system, but when it finishes something, it starts working on them at appropriate times.

You can queue a lot, continue your day, and in many cases just come back to see tons of work completed in good and smart ways. But check in from time to time because it might need your input.

Customization Goes Pretty Deep

Claude Code supports custom hooks, slash commands, and project-specific configuration. The cool part? You can have Claude build these for you.

I asked Claude to add several default hooks, commands, and settings. It looked at my project and created a settings file I could easily edit, with several notable highlights:

It added a CLAUDE.md file providing some project overview and some key commands it should know about. This prevents it from having to figure these out every time and scan the codebase looking for "Is there a build command or lint command?" It's always aware of these.

It added some hooks for what code should run before accepting edits, like running Prettier on specific files, or after edits, like type-checking specific files to ensure it only accepts good and correct files.

You can create your own hooks through a .claude/hooks.mjs file, for example:

// .claude/hooks.mjs
import { execSync } from 'child_process';
import path from 'path';

// Hook that runs before editing files
export async function preEdit({ filePath, oldContent, newContent }) {  
  // Check if editing TypeScript/JavaScript files
  if (filePath.match(/\.(ts|tsx|js|jsx)$/)) {
    // Ensure file is properly formatted before editing
    try {
      execSync(`yarn prettier --check "${filePath}"`, { stdio: 'pipe' });
    } catch (e) {
      console.log('⚠️  File needs formatting - will format after edit');
    }
  }
  
  // Prevent editing certain protected files
  const protectedFiles = ['yarn.lock', 'package-lock.json', '.env.production', 'firebase.json'];
  const fileName = path.basename(filePath);
  if (protectedFiles.includes(fileName)) {
    throw new Error(`❌ Cannot edit protected file: ${fileName}`);
  }
  return { proceed: true };
}

// Hook that runs after editing files
export async function postEdit({ filePath, oldContent, newContent, success }) {
  if (!success) return;
  
  // Run type checking on TypeScript files
  if (filePath.match(/\.(ts|tsx)$/)) {
    try {
      execSync(`npx tsc --noEmit --skipLibCheck "${filePath}"`, { stdio: 'pipe' });
    } catch (e) {
      console.log('⚠️  TypeScript errors detected - please review');
    }
  }
}

Creating Custom Slash Commands

You can also easily add custom slash commands. To add commands, just create a .claude/commands folder and add command names as files with .md extensions. You just write these in natural language and can use $ARGUMENTS string to put arguments into the prompt.

For example, if I want to output a test, I can create .claude/commands/test.md:

# .claude/hooks/test.md
Please create comprehensive tests for: $ARGUMENTS

Test requirements:
- Use Jest and React Testing Library
- Put tests in __tests__ directory
- Mock Firebase/Firestore dependencies
- Test all major functionality
- Include edge cases and error scenarios
- Test MobX observable state changes
- Verify computed values update correctly
- Test user interactions
- Ensure proper cleanup in afterEach
- Aim for high code coverage

Then /test MyButton does exactly what you'd expect. You can even have subfolders - we can access them like /builder/plugin, which would match a plugin.md file in a builder folder. This is how we easily create new Builder plugins.

Memory System

Another cool feature is you can use the # symbol to add memories super fast. Like "new things always use MUI components" and it'll automatically save to the most relevant file.

CLAUDE.md files can be hierarchical, so you can have a project-level one and also one in nested directories. It looks at all of these and prioritizes the most specific, most nested when relevant.

You can also save it to global user memory preferences you want applied everywhere, or local project memories specific to you and git-ignored. Add to any of these files and it'll write for you.

When You Want Normal UI

The terminal interface isn't always ideal. Sometimes you just want to click and highlight text like a normal person.

That's what our Builder.io extension is for. You can launch a visual interface from your IDE that works exactly like Claude Code underneath. We reverse-engineered it as closely as possible. You get a normal chat interface, live preview, and can even switch to Figma-style design mode for visual editing.

Your whole team can use it—designers, product managers, anyone. They can create prototypes, clean up UI, and submit PRs without understanding the terminal interface.

Internally at Builder, we've been using this to let our engineers focus on hard engineering work while other teams handle UI details and pixel-perfect implementations.

Then when our engineering team needs to update PRs, we can just use @builderio-bot and Claude automatically resolves feedback and pushes commits to fix issues.

(End)

ByteNotebook WeChat public account reader group is temporarily open for free, add WeChat iweico.