How I Actually Use Claude Code

I’ve been using Claude Code for almost a year now. Over that year, both Claude Code and the Claude models themselves have improved enormously. As one of the early users, I want to share some of the ways I use it beyond writing code.

Let me start with my setup:

1. Hardware. About 80% of the time, my Claude Code runs on a Mac mini at home.
2. Remote access & networking. I use Tailscale to put the Mac mini, my phone, and my laptop on the same network.
3. Persistent workflow. I generally open a separate tmux session per project. So anytime, anywhere, whether I connect from my phone or laptop, the connection never drops and the process keeps running in the background — very convenient.

Writing code

The most important feature is, of course, using it to write code. In my current workflow I rarely write code by hand — my own hands-on share is maybe 5–10%.

Along the way I refactor and clean up periodically, then let Claude Code carry on. In short, I use it to bootstrap a project and to stack the first ~10 features on top; but once there are more than ~10 features and the logic gets complex, a human has to step in and refactor. If you don’t, the codebase eventually piles into an unmaintainable “ball of mud.” There are exceptions, of course — a pure static site or blog usually needs no refactoring.

Here’s how I tend to organize things:

Project structure. I prefer a “monorepo” plus multiple submodules: under one main app directory, the frontend, backend, and landing page each sit as their own GitHub repo, side by side; the outermost layer holds shared contracts and files — the Schema definitions, and CLAUDE.md.

app/                  # root repo: launch Claude Code here, works across both ends
├── CLAUDE.md         # global conventions
├── schema/           # shared contracts / Schema
├── frontend/         # ← submodule (its own GitHub repo)
├── backend/          # ← submodule (its own GitHub repo)
└── landing/          # ← submodule (its own GitHub repo)

Running & collaboration. I usually run the Claude Code session from the outermost root repo, so it can operate on both the frontend and backend code. When I make a cross-cutting request, it can coordinate the two ends much better.

Contract alignment. I like to define the spec on the backend and export an OpenAPI JSON file; the frontend then auto-generates its client request code from that OpenAPI file. This way the two ends stay aligned automatically and efficiently, with no hand-written, overly complex protocol.

Deep Research

Deep Research, as a feature, was probably first introduced in Google’s Gemini. But when I first tried Google’s version I didn’t find it that useful — it basically searched a pile of things and stitched them into one big document, with a lot of low-credibility content, some of it SEO-hacked into the results.

So how do I do Deep Research with Claude Code? I usually give it a topic first — e.g. “look into the whole upstream/downstream supply chain of a data center, including the important players” — then add specifics — e.g. “I need the leading company for each niche in the chain; list their official sites and core products, and lay it all out as a web page I can browse.”

A few key points:

Make the ask clear (a tree structure). It works best as a top-down, shallow-to-deep request: state the overall goal, then the specifics of one part, then the details of a sub-part of that part. This is essentially a tree with many nodes — Claude Code walks it node by node, then aggregates everything into a whole.

Deep research with cross-validation. Run this way, it does genuinely deep research; and because Claude Code reasons fairly well, it cross-validates the various data points — something I really like.

Visualized output. It also has one big trick: it can turn the results directly into a website, presenting the data visually with charts (bar charts, line charts, etc.). It looks clean and pleasant at a glance — one of my favorite features.

For example, this piece I put together that way — The AI Inference Chip Spectrum — lays the whole inference-chip supply chain (players and products) out as a web page with a comparison table.

Turning conversations into notes

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

The flow goes roughly like this: start from a question, then keep discussing and branching out with the AI; I’ll paraphrase things back and ask the AI to point out where I’m wrong, using the conversation to probe the edges of my own knowledge.

The trouble is that such conversations get very long and painful to review. So I drop the whole long conversation into Claude Code and have it generate a website straight from the chat, summarizing the key points; reviewing it later is then a much nicer visual experience. While summarizing, if it needs images, charts, data, or reference files, it can search for them and insert them into the key points itself.

For instance, this piece — Storage in CPUs and GPUs — is one I produced by dropping a long discussion about storage into it and having it summarize the result into a web page, complete with diagrams and tables.

That way, looking back is effortless — I can quickly recall what I was discussing with Claude, which speeds up learning a lot.

Tidying up files on the desktop

Although Claude Code is a code-first tool, its tool calls include a lot of Bash capability. On a Mac especially, it can seamlessly invoke these Linux-style commands, which is very nice.

A simple example: I download a folder that’s a total mess (say 100 images), each named differently, and I want to sort them — doing it by hand is miserable. My approach now:

1. Open a Claude Code session right in that folder;
2. Tell it I want to organize these files;
3. Have it sort them by image content or by date.

Claude runs through this fast, because it’s multimodal — it can’t generate images, but it can read them, recognize what’s inside, and effortlessly sort a big, messy folder. Genuinely handy.

Images

A lot of image-related needs I now hand to Claude Code too. It can’t generate images directly, but its image-handling is strong, in three main ways:

Drawing SVG vector graphics. It can draw SVG vector graphics in code — especially flowcharts, explanatory diagrams, or code-execution / architecture diagrams, which it renders beautifully.

Searching for and managing images. It can search the web for images on demand and download them straight into my article or wherever else — my current desktop wallpaper, for instance, was something I had it find for me. Worth noting: it’s very copyright-conscious — when finding images it mainly pulls from sources like Wikipedia, so they’re safe to use directly. I think that’s really well done.

Post-processing. Because it can write code, it can naturally call OpenCV to process images — cutouts, cropping, simple color-channel transforms: anything OpenCV can do, it can basically handle.

So while it doesn’t “paint” directly, these abilities combined are already very powerful.

Video

Beyond images, you can even make videos with Claude Code.

I haven’t spent much time on this, but I’ve seen a few examples and tried it myself, and the experience is decent. It works through Remotion — a framework for making videos in code. The idea: you write the video as React-like components, turning the video content into code, then render it locally.

For the “I have a bunch of assets and want to stitch them into a video” kind of need, having Claude Code write the Remotion code and render it is very efficient. Check the Remotion site for details.

Other

Claude Code has plenty of other tricks, especially now that there are Skills — mount the right Skill and it can do an enormous range of things. For example:

• I’ve seen people connect Claude Code to AutoCAD and have it draw a CAD drawing;
• And others connect it to 3D-modeling software like Blender and have it build a 3D model directly.

In short, anything that can be serialized as code, Claude Code can pretty much support. So it’s genuinely a powerful tool — there’s a lot I still haven’t tried, but the room to play with it is huge.