10 Claude Code Tips From the Guy Who Built It (Boris Cherny)

< p class= "lead" > Boris Cherny created Claude Code.Every few weeks, he drops tips on X about how to use it more effectively.The problem is a lot of his techniques are hard to interpret without examples.Here is the complete breakdown with hands - on demonstrations.

This guide is based on a breakdown by Nick Saraev, who walked through each of Boris's tips with practical examples.

1. Git Worktrees for Parallel Development

Git worktrees let you check out different branches into separate folders. Combined with Claude Code, this enables true parallel development—you can build 3-5x faster depending on how many instances you run.

How it works:

Say you have a website project in a folder called leftclick-agency. Instead of building pages sequentially, create three duplicate folders:

• leftclick-about
• leftclick-contact
• leftclick-services

Open a Claude Code instance in each folder. Give each one a task:

Navigate to leftclick-contact. Your task is to build a new contact page
in a new git worktree. Develop in the same style as the original.
Research the company, do whatever else you need to ensure this
accurately reflects a high-quality contact page.

Run all three simultaneously. Each instance works on its own branch with full context. When all three finish, go back to one instance and say:

Could you merge the three branches I just did development on for me—
leftclick-services, leftclick-about, and leftclick-contact.
I'd like all three merged with the main branch. No conflicts.

Claude handles the merge. You now have three new pages built in parallel.

This applies to anything—websites, full-stack apps, automated workflows, agentic systems. The merge process is not instantaneous, but the overall speedup is significant.

2. Plan Mode: Research Before Building

A minute of effective Plan Mode will save you hours and many dollars of building.

Instead of rushing to code, force Claude to build an in-depth plan first. Research happens 10-100x faster than actual implementation. Only after the plan is perfect should you start building.

Example workflow:

Say you want to build a video editing automation that removes silences. Open Claude Code and enable Plan Mode at the bottom. Then describe what you want:

My goal is to develop a simple video editing workflow. I want to provide
a video between 5-15 minutes and have you edit out all the silences
using automated silence detection.

The most common issues I've found: the voice detection library cuts into
or slightly after speech segments. I want high-quality voice detection.
Give me a video, detect silences, cut them, return the optimized file.

Claude will research, find the right libraries (like Silero VAD for voice activity detection), and show you a complete implementation plan with tunable parameters.

Read the plan. If something looks off, edit it. It is much easier to fix a plan than to fix broken code after implementation.

This is like freelance scoping—spend time clarifying upfront rather than saying "I'll figure it out," doing all the work, then having to revise when it is wrong.

3. Iterate Through Your Claude.md

Your claude.md is your system prompt. It gets injected at the top of every conversation. A tight claude.md prevents Claude from making mistakes it tends to make.

Boris's point: if something happens that you do not like, update your claude.md to prevent it from happening again.

The workflow hack:

Every time Claude makes a prototypical mistake or you solve something non-obvious, say:

Add this to claude.md such that a future version of Claude
with no context would be able to oneshot what we just did.

Claude will reread your claude.md and update it automatically. You do not have to do this manually.

For example, after using the git worktree merge workflow:

Update claude.md to reflect everything we just did here.
I want to be able to say "merge with git worktree" and you'll
automatically know how to do all of this.

Now future sessions can execute that workflow with a single command.

4. Skills: Git Commit Them

Skills are Claude Code's way of standardizing procedures—like SOPs that execute the same way every time.

Boris recommends creating a skills GitHub repository and storing all valuable skills there. Anyone on your team can pull skills as needed into their own repos.

Setup:

1. Create a dedicated GitHub repo for Claude skills
2. Store skills with documentation
3. In any project, tell Claude: grab skill [name] from [repo-url]

Claude will find the skills workspace, download the specific skill, and load it locally. Share the repo across your team so everyone benefits from proven skills.

5. Feed Error Codes Directly

Boris is confident you can oneshot most bug fixes by feeding in error codes directly.

If you have a bug fix channel in Slack, connect Claude Code using the Slack MCP. Copy and paste errors directly. Claude handles them.

If you work solo, just paste errors directly into Claude Code. No channel needed.

6. The "Elegant Solution" Prompt

After a messy fix or build, tell Claude:

Knowing everything you know now, scrap this and implement
the more elegant solution.

Why this works:

Claude searches over a large solution space. Its initial naive search tries many approaches:

• First attempt: does not work
• Second attempt: does not work
• Third attempt: partial success
• Fourth attempt: gets closer
• Fifth attempt: finally works

Now your repo has artifacts from all five attempts when you only needed the fifth one.

The prompt tells Claude to use everything in its context window—all the failed approaches and learnings—to recreate just the valuable part. As if attempts one through four never happened.

Clean repos. No accumulated cruft.

7. Ghost TTY for Terminal Management

Ghost TTY is what Anthropic team members (including those who work with Boris) use daily. It is a faster terminal manager that renders more colors and uses less compute—important when running many parallel Git worktrees.

Key shortcuts:

• Cmd + D: Horizontal split
• Cmd + Shift + D: Vertical split
• Cmd + Arrow keys: Navigate between panes
• Cmd + Shift + Enter: Maximize/restore focused tab

You can open an absurd number of terminal instances—split them horizontally, vertically, scroll through. When something needs attention, jump directly to that pane with keyboard shortcuts instead of clicking.

This pairs perfectly with the git worktree workflow. Run parallel Claude instances, navigate between them instantly, handle notifications as they come.

8. Sub-Agents for Specialized Tasks

Sub-agents used to feel like a waste of time—calling them took longer than just doing the task on the main thread. But the technology has caught up. Now they are solid.

Creating a code review sub-agent:

Tell Claude:

You can now create sub-agents. I'd like you to create a specific
Claude sub-agent that reviews code after you're done writing it.

The main agent will call the sub-agent at the end of every major
write process to confirm code was written efficiently.

Because this sub-agent has no context, it can evaluate objectively—
not polluted by prior work.

Claude creates a markdown file called code-reviewer.md with instructions, tools (read, grep, glob), and evaluation criteria.

Add the sub-agent creation process to your claude.md so next time you can just say "make me another sub-agent."

Using the sub-agent:

Use the code-reviewer sub-agent to review website_email_scraper.py
in executions.

Claude spins up a new task with isolated context. The sub-agent reads the code, evaluates it, and returns findings: "Script is production-ready with minor improvements, well-structured async code..."

Feed that back to the main agent to continuously improve code quality.

9. Stop Writing Manual Database Queries

Boris apparently does a lot of database and analytics work. His advice: stop writing manual SQL.

Quote: "I haven't written a line of SQL in six months."

Let Claude handle database queries. Describe what data you need, let Claude write and execute the queries.

10. Explanatory Output Style and ASCII Diagrams

Inside Claude Code config, you can enable different output styles:

To access: Type output styles in Claude Code. Select from:

• Explanatory: Claude explains its choices and codebase patterns as it works
• Learning: Claude stops and asks you to write small pieces of code for hands-on practice

Explanatory mode is useful when learning new patterns or understanding unfamiliar code.

ASCII diagrams:

After Claude builds something, ask:

Create me a simple ASCII diagram showing what you just did.

Claude produces a visual representation:

┌─────────────────────┐
│  Main Conversation  │
│    (your prompt)    │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│   Spin Up Task      │
│  (isolated context) │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│   Review Code       │
│  (read scraper.py)  │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│   Return Findings   │
└─────────────────────┘

This is the fastest way to get a visual understanding of complex flows without leaving the terminal.

Putting It All Together

The power user stack:

1. Ghost TTY for terminal management with fast splits and navigation
2. Git worktrees for parallel development across branches
3. Plan Mode to research before building
4. Claude.md iteration to prevent repeated mistakes
5. Skills repository shared across your team
6. Sub-agents for specialized parallel tasks
7. Elegant solution prompt to clean up messy fixes
8. ASCII diagrams for instant visual understanding

These techniques come from the person who built Claude Code. If you want to use the tool at its full potential, this is how.