Claude Code - Insider Tips For Success
Claude Code: Why Some Love It and Others Hate It - My Essential Tips for Success
I'm honestly blown away by the huge disconnect I see in the developer community when it comes to Claude Code. On one side, I have people saying "I tried Claude Code on your recommendation and I have a very different opinion than the others. It was horrible." On the other side, developers are telling me "Claude Code made programming fun again."
As someone who falls firmly on the "love it" side, I've been thinking a lot about why this divide exists. Maybe it's just the way people are using it. Today, I want to share all the techniques I've learned that make Claude Code incredibly powerful and enjoyable to use.
1. Master Plan Mode (Shift + Tab + Tab)
This is a brand new feature that I absolutely love, and it might be one of the reasons people still prefer VS Code. Hit `Shift + Tab + Tab` and you'll see "plan mode on" at the bottom of your terminal.
In plan mode, you can have a conversation with Claude where it generates a comprehensive plan of everything it's going to do, and then you can kick it off to run automatically. It's magical. This feature just released a few days ago, so definitely try it out.
2. Talk to It Like a Teammate
Think about how you'd communicate with another engineer. Ask Claude questions about your code:
- "What does this class do?"
- "When onboarding starts, what API am I calling?"
- "Change the login button" (you don't even need to specify the component name or file)
- "There's a button that says 'create campaign.' When clicked, I get a 500 server error from the API. Here is the log."
Claude works incredibly well with natural language. I used that last example just yesterday when I was getting a weird 500 error for a missing field, and it fixed it for me without me having to dig deep into debugging.
3. Be Precise and Surgical
While casual conversation works great, being more precise gets better results:
**Good:** "In this file, I need you to add a function that validates XYZ before letting the user click sign up."
**Better:** "In this file, the calculated LTV last 90 is different from what shows on this file. In this case, the number of customers is the same but the LTV is different. Work through the likely cause and a proposed plan to fix it."
Notice in that second example, I'm not asking it to code anything immediately. I want it to analyze and propose a plan first. I can kick this off and work on something else, then review its analysis.
4. Use XML Tags for Complex Prompts
For bigger features or complex requests, I use XML formatting. I know it sounds crazy, but I have multiple notepads open on my desktop (yes, my desktop is a mess) with these structured prompts.
Here's the format I use:
```xml
<instructions>
Build a serverless user authentication system using AWS Cognito, Lambda, CDK
</instructions>
<requirements>
- Specific requirement 1
- Specific requirement 2
- Specific requirement 3
</requirements>
<testing>
- How to test this feature
- Expected outcomes
</testing>
```
Claude has been specifically trained to follow XML-based tags really well. You can even reference these sections later in your prompt: "Make sure you refer back to the requirements section" or "Follow the testing guidelines above."
I build these prompts outside of Claude Code, then copy and paste them in when I'm ready.
5. Maintain Your claude.md File
Make sure you use the `/init` command to create a claude.md file, and tell Claude to update it regularly. This file helps maintain context about your project across sessions.
6. Use claude --continue for Session Recovery
Here's something many people don't know: if you end your day and close Claude Code, you can simply run `claude --continue` to load up your previous conversation. Super helpful for maintaining context.
You can also look at your Claude logs and grab specific conversation IDs, but `claude --continue` is what I use most since I rarely want to resume really old conversations.
7. Built-in Git Integration
For the longest time, I was exiting Claude or opening another terminal to interact with GitHub. There's no need for that! You can literally just type `commit` into Claude Code and it will:
- Ask if you want to `git add` files
- Generate a commit message
- Execute the commit
I love the commit messages it generates. You can also tell it to "generate a commit message for me" if you prefer to handle the actual commit yourself.
You can even use `push branch` or `push to dev` to have it handle pushes (assuming your git is configured correctly).
8. Background Processing with claude -p
This is where things get really exciting. If I'm about to go to lunch and have an idea, I'll use `claude -p` (for "private" or background mode):
```bash
claude -p "I want you to make it so that I can attach a user avatar via URL to my user record. I need an API model update."
```
This runs completely in the background without any interaction needed. When I come back, all the work is done and I can review it. Think of this like a local Codex - you can kick off multiple tasks in different parts of your codebase and review them later.
The trade-off is you lose interactivity, but it's perfect for getting a head start on isolated tasks.
9. Create Custom Slash Commands
You can create your own slash commands by:
1. Going to your `.claude` folder
2. Creating a `commands` folder
3. Making markdown files for each command
For example, I created an "update docs" command:
```markdown
Evaluate the current project, evaluate the current documentation, update claude.md with any new functionality, update other documentation as needed.
```
Now I can just type `/update-docs` and it runs automatically. I have several of these for my main repository - they're incredibly useful.
10. Have Claude Review Claude's Work
This is a powerful workflow: have Claude review work that Claude created. I'll often have something built in one window, then open a fresh Claude Code session and say "This is a new file I created. Go review this. Look for issues."
Having a fresh context review the work catches things the original session might miss. You can even create custom prompts with specific review guidelines.
11. Use Screenshots Liberally
Don't underestimate the power of visual input. You can drag and drop screenshots directly into the terminal. This works great on WSL and Linux too.
I regularly drag UI screenshots in when there are design issues or bugs. Claude can see what's wrong and help fix it much more effectively than trying to describe the problem in text.
12. Test-Driven Development Prompts
Here's a TDD prompt format I use frequently:
```xml
<test>
Describe what you want to test
</test>
<implementation>
Describe the functionality needed
</implementation>
<rules>
Any specific constraints or requirements
</rules>
We are doing test-driven development. The implementation does not exist yet. Please implement my test, then implement the functionality to pass the test.
```
This makes Claude Code incredibly powerful for isolated features where you can iterate to make tests pass.
13. Ultra Think Mode for Complex Tasks
For really complex implementations, I use this "ultra think" prompt:
```
Please ultra think through this. Start by exploring the codebase and gathering the necessary context. You should use sub agents where it makes sense. I want you to explore, plan, and implement the following: [your request]
```
This triggers Claude's deeper reasoning mode (you'll see "thinking..." appear), and it creates comprehensive task lists and implementations. I get amazing results with Sonnet 4, though I hear Opus gives even better results.
14. Don't Be Afraid to Throw Away Work
This might be the most important tip: **don't fight AI when it goes off the rails**. Code is now cheap to generate. If Claude messes something up, just:
- `git commit` your current state
- Throw away the problematic changes
- Start over with better wording
I see too many people spending time trying to get AI back on track when it would be faster to start fresh.
Why the Divide Exists
After using these techniques extensively, I think the massive divide between "love it" and "hate it" comes down to approach and expectations. Some developers may simply prefer GUI-based tools over CLI interfaces, and that's totally valid.
I still use and love VS Code daily, but Claude Code has made programming genuinely fun for me. The level of control I have - from one-shot requests to deep, planned implementations - is incredible.
Conclusion
These tips represent my personal approach to Claude Code after extensive use. I'm sure there are techniques I haven't discovered yet, and I'd love to hear about them in the comments.
The key is treating Claude Code as a powerful teammate rather than just a code generator. With the right approach, it can transform how you build software.
Comments
Post a Comment