My Claude Code Practices

I’ve been using Claude Code for nearly a year now. Over that year, both Claude Code and the Claude models themselves have improved enormously. As one of its earliest long-time users, I’d like to share some of what I’ve learned and how I use it “beyond writing code.”

Let me start with my setup:

1. Hardware environment. About 80% of the time, my Claude Code runs on a Mac mini at home.
2. Remote access and networking. I use Tailscale to put the host, my phone, and my laptop on the same network.
3. Persistent workflow. I basically spin up a separate tmux session for each project. That way, anytime and anywhere — whether I’m on my phone or laptop — the connection never drops, and the program keeps running in the background. It’s incredibly convenient.

Writing Code

The most important use is, of course, writing code with it. In my current workflow, I rarely write code myself anymore — the part I do by hand is probably only 5% to 10%.

Along the way, I periodically refactor and clean things up, then let it keep going. In short, I use it to bootstrap a project at the start, and I keep letting it stack on the first 10 or so features. But once the feature count exceeds 10 and the logic gets complex, human intervention is needed for a round of refactoring. Without it, the code eventually piles up into a completely unmaintainable “ball of mud” — really bad. There are exceptions, of course: for something as simple as a static website or a blog, you usually don’t need to refactor at all.

For coding with Claude Code, I usually organize things like this:

Project structure management. I prefer to use a “monorepo” plus multiple submodules: under a main app directory, the frontend, backend, and landing page each sit side by side as independent GitHub repositories; the outermost layer holds shared protocols or files, such as schema definitions and CLAUDE.md.

app/                  # Root repo: start Claude Code here to work on both front and back end at once
├── CLAUDE.md         # Global conventions
├── Makefile          # Common commands (build / test / deploy)
├── .gitignore
├── .gitmodules       # Submodule manifest
├── .claude/          # Claude Code config / commands
├── .github/          # CI workflows
├── schemas/          # Shared protocols / schema definitions
├── docs/             # Shared docs
├── web/              # ← submodule (independent GitHub repo)
├── server/           # ← submodule (independent GitHub repo)
└── landing/          # ← submodule (independent GitHub repo)

Running and collaboration. I usually run the Claude Code session in the outermost root repo, so it can operate on both the frontend and backend code at the same time. When I describe a cross-cutting requirement, it can coordinate the frontend and backend much better.

Aligning the communication protocol. I like to define the spec on the backend and export an OpenAPI JSON file; the frontend then automatically generates client request code straight from that OpenAPI file. This lets the frontend and backend stay aligned very efficiently and automatically, without hand-writing an overly complex protocol.

Doing Deep Research

The Deep Research feature was, I believe, first introduced in Google’s Gemini. But when I first tried Google’s Deep Research, I found it not very useful — it basically just searched for a pile of stuff and merged it into one big document, with a lot of low-credibility content, some of it even stuffed in via SEO hacks.

So how do you do Deep Research with Claude Code? I usually start by giving it a topic, such as “look up the entire upstream and downstream supply chain of data centers, including which key players are involved,” and then add specific requirements, like “I need the leading company in each niche of this chain — list their official websites and core products, and finally compile it into a web page so I can review it easily.”

A few key points:

Requirements should be clear (tree-structured). Ideally, frame the request top-down, from shallow to deep: state the overall requirement first, then the specific requirement for one of its parts, and finally the details of the sub-parts of that part. This amounts to a tree with many nodes; Claude Code works through it node by node according to that structure, then synthesizes everything into a whole at the end.

Data center supply chain (topic: tree root)
├── Upstream
│   ├── Chips (list leaders / official sites / core products)
│   └── Networking equipment
├── Midstream
│   ├── Servers
│   └── Contract manufacturing
└── Downstream
    └── Cloud providers

Deep investigation and cross-validation. Running it this way lets it do very deep research, and because Claude Code’s reasoning ability is fairly strong, it can cross-validate various pieces of data — something I really appreciate.

Data visualization. It has another big strength: it can turn the research results directly into a website that displays the data intuitively with charts (bar charts, line charts, etc.), so at a glance everything is clear and pleasant. This is one of my favorite features.

For example, this piece I put together this way, “The AI Inference Chip Spectrum,” organizes the players and products across the entire inference-chip supply chain into a web page with a comparison table.

Organizing Conversation Notes

Now that AI is so convenient, I like to learn and look things up through conversation.

The flow goes roughly like this: start with a question and keep discussing and expanding on it with the AI; I’ll proactively restate things in my own words and have the AI point out my mistakes, using this kind of dialogue to explore the boundaries of my own knowledge.

This easily makes conversations very long, which is a pain to review. So I’ll throw the whole long conversation into Claude Code and have it generate a website directly from the conversation, summarizing the core takeaways; reviewing it afterward is a very pleasant visual experience. When summarizing the key points, if it needs to find images, charts, data, or reference files, it can also proactively search for them and insert them into the takeaways.

For instance, this piece, “Storage in CPUs and GPUs,” is a web page it produced by summarizing a long series of discussions about storage I handed to it — with figures and tables, it’s very pleasant to revisit.

This way, looking back later is crystal clear: I can quickly recall what topic I was discussing with Claude at the time, which helps a great deal in speeding up how fast I expand my knowledge.

Organizing Desktop Files

Although Claude Code is a tool primarily for writing code, its tool calls integrate a lot of Bash capabilities. On Mac in particular, it can seamlessly invoke these Linux-style commands, which is very nice.

Here’s a simple example: I download a folder that’s extremely messy (say, with 100 images), each named differently, and I want to sort them into categories — doing it by hand would be miserable. Here’s what I do now:

1. Open a Claude Code session right in that folder’s directory;
2. Tell it I want to organize these files;
3. Have it sort them neatly into categories by image content or chronological order.

At this point Claude runs very fast, because it has multimodal recognition — although it can’t generate images, it can read images and identify what’s in them, making it easy to organize a large, messy folder. This kind of usage really is incredibly handy.

Images

In fact, I now hand many image-related tasks to Claude Code as well. While it can’t generate images directly, its ability to process images is very strong, mainly in three areas:

Drawing SVG vector graphics. It can draw SVG vector graphics with code — especially flowcharts, explanatory diagrams, or things like code-execution flows and architecture diagrams, which it can draw beautifully.

Searching for and managing images from the web. It can search for and download images from the web based on a requirement and drop them straight into my articles or elsewhere — for instance, my current desktop wallpaper is one it found for me. Worth noting is its strong awareness of copyright: when finding images, it pulls mainly from sources like Wikipedia, so you can use them directly without any copyright risk. I think it does this very well.

Post-processing images. Because it can write code, it can naturally call OpenCV to process images. Whether it’s cutting out a subject, cropping, or simple color-channel transformations — basically anything OpenCV can do, it can handle.

All in all, even though it doesn’t “draw” directly, these capabilities combined are already very powerful.

Video

Beyond images, you can even use Claude Code to make videos.

I haven’t spent much time on this, but I’ve seen some examples and tried it myself, and the experience is actually decent. It works through Remotion — a framework for making videos with code. The idea is to write the video in a React-component-like way, turning the video content directly into “programmable” form, and then render it locally.

For the kind of task where you “have a lot of footage on hand and want to stitch it into a video,” having Claude Code write the Remotion code and render it directly is very efficient. Check out the Remotion website for the details.

Other Uses

Claude Code has many other tricks up its sleeve, especially with Skills — just hook up the right Skill and it can do an enormous range of things. For example:

• Some people have connected Claude Code to AutoCAD and had it draw a CAD drawing;
• Others have connected it to 3D modeling software like Blender and had it build a 3D model for them directly.

In short, just about anything that can be serialized as code, Claude Code can handle. So it’s really a very powerful tool — there’s plenty more fun stuff I haven’t gotten to try yet, but it certainly offers a lot to play with.