How I Use Claude Code to Develop Software

Introduction

I have been using Claude Code as part of my regular development workflow for a while now, and it has changed how I approach building software. This is not a getting-started tutorial — it is a first-person account of how I actually use it day to day.

Claude Code is Anthropic's CLI tool that gives you a Claude model with full access to your local filesystem, shell, and git history. It runs in your terminal (or inside VS Code via an extension) and can read files, write code, run commands, and reason about your entire project in context.

Exploring an Unfamiliar Codebase

One of the first things I reach for Claude Code on is understanding code I did not write, or code I wrote long enough ago that it may as well be someone else's.

Instead of manually tracing call stacks through files, I can ask:

"How does authentication work in this project? Walk me through the request lifecycle from the route handler to the token validation."

Claude Code will read the relevant files, follow imports, and give me a clear walkthrough — often surfacing things I would have missed in a grep-and-read session.

Writing New Features

My typical workflow for a new feature:

Describe what I want in plain English, including constraints and any decisions I have already made.
Let Claude Code explore — it reads the relevant parts of the codebase before writing anything.
Review the diff before accepting changes.
Iterate — I almost always have follow-up corrections or adjustments.

The key insight is that Claude Code does not just generate code in isolation. Because it reads the existing codebase first, the output tends to follow the project's existing patterns and conventions rather than producing generic boilerplate.

Debugging

When I hit a bug I cannot quickly explain, I describe the symptom and any relevant context:

"This function returns undefined when called from the middleware, but returns the correct value in tests. Here is the stack trace."

Claude Code reads the referenced files, reasons about the control flow, and usually either identifies the root cause or narrows it down significantly. It also points me toward logs or assertions I should add if the cause is still ambiguous.

Code Review and Cleanup

Before committing, I often run:

/code-review

This reviews the current diff for bugs and simplification opportunities. The /simplify skill focuses specifically on reuse, efficiency, and unnecessary complexity. Neither one makes changes unless I ask it to — I can review the findings first.

This acts as a fast pre-commit sanity check that catches things I glossed over while writing.

Working with Git

Claude Code is git-aware. It can:

Summarize what changed between branches
Help write commit messages that reflect the why, not just the what
Explain what a specific past commit was doing

I also use it to audit what is left before opening a pull request — uncommitted changes, missing tests, config that needs updating.

Tips From My Workflow

Be specific about constraints. The more context you give upfront (performance requirements, existing patterns you want to follow, things you have already ruled out), the less back-and-forth you need.

Read the diff before approving. Claude Code shows you what it intends to change. I always read it. Blindly accepting edits is how subtle bugs get introduced.

Use it for the boring parts. Renaming things consistently across a codebase, updating repetitive test cases, converting a chunk of code from one pattern to another — these are tedious and error-prone by hand. Claude Code handles them reliably.

Give feedback in the same session. If Claude Code does something wrong or in a style I do not like, I correct it immediately. It adjusts for the rest of the session, and I can save persistent preferences to memory so the same correction does not need to happen again.

Do not skip reviewing. Claude Code is fast and usually accurate, but it can make mistakes, particularly around edge cases and implicit invariants. Treat it as a capable collaborator, not an oracle.

Conclusion

Claude Code has become a genuine part of how I write and maintain software. It is most valuable not as a code generator but as a collaborator that understands the full context of my project — one I can describe a problem to and get a grounded, specific response rather than a generic answer.

The productivity gains are real, but the bigger shift is in how I think about the work. More time is spent on decisions, design, and review; less on mechanical implementation and boilerplate. That is a trade I am happy to make.