A Month of Claude Code: Why I'm Writing This Series

I open my terminal before I open anything else. Before Slack, before email, before whatever's on fire. The first thing I type most mornings is claude. Not because I'm some Anthropic evangelist. Because it's become the fastest way for me to get things done.

I've been using Claude Code daily since late 2025. What started as an experiment with a CLI tool turned into a complete rethinking of how I develop software, manage projects, and honestly, organize chunks of my life. I use it to write code, review pull requests, plan features, track what I eat, automate grocery runs, and build presentations. It sounds like I'm exaggerating. I'm not. Over the next month, I'm going to show all of it.

This is the first post in a 20-part series called Month of Claude Code, running every weekday through March 2026. Each post covers one specific aspect of how I use this tool. No fluff. No sponsored content. Just what I've learned from obsessive daily use.

What Claude Code Actually Is

There's a lot of confusion about what Claude Code is and isn't, so let me be precise.

Claude Code is not an IDE. It doesn't have a file tree, tabs, a status bar, or a GUI. It doesn't try to be VS Code or Cursor or any of those.

Claude Code is not autocomplete. It doesn't sit inside your editor waiting for you to pause typing so it can suggest the next line. That's Copilot. Copilot is a smart autocomplete engine. A very good one, and I used it for years, but fundamentally it's reactive. You type, it suggests.

Claude Code is not a chat window bolted onto an editor. That's Cursor. Cursor takes the Claude or GPT model and embeds it in a VS Code fork with nice inline diffs and file context. It's a good product. But it's still an IDE-first experience where AI is a feature.

Claude Code is an autonomous agent that lives in your terminal. You launch it. It reads your codebase. You tell it what you want done. It thinks about the problem, makes a plan, reads the relevant files, writes code, edits existing files, runs commands, manages git, and reports back. It doesn't suggest changes for you to accept line by line. It makes the changes. You review the result.

The mental model shift matters. With Copilot, you're the driver and AI is the passenger suggesting directions. With Cursor, you're co-driving with AI in the passenger seat, hands occasionally on the wheel. With Claude Code, you're describing the destination and the agent is driving. You're still in the car. You can intervene. You should review the route. But the agency has shifted.

This isn't just a UX difference. It changes what's possible. When the tool can autonomously read ten files, understand how they relate, refactor across all of them, run the tests, and fix what breaks, that's a categorically different capability than autocompleting one line at a time.

Why Terminal-First Matters

The terminal is the most powerful interface on your computer. Every developer knows this intellectually. Most developers spend their time in GUIs anyway.

There's a reason for that. GUIs are more discoverable. You can see the buttons. You can click around and figure things out. The terminal requires you to already know what you want to do, or at least know how to ask.

Claude Code changes that equation. It gives you the power of the terminal, which is everything your computer can do, expressed through commands, with the discoverability of natural language. You don't need to remember the exact git incantation to cherry-pick a commit from another branch, rebase it, and resolve the conflicts. You describe what you want, and the agent figures out the commands.

No Electron wrapper. No extension marketplace. No UI chrome eating your screen real estate. Just a prompt, your codebase, and an agent that can operate on both.

There's a philosophical commitment here that I respect. Claude Code isn't trying to be everything. It's trying to be the best thing that runs in your terminal. That constraint forces clarity. Every interaction is text in, action out. There's no ambiguity about what the tool did, because you can see every command it ran and every file it touched.

For developers who already live in the terminal, this feels native. For developers who don't, it might feel spartan. Both reactions are valid. But I'll say this: after months of using Claude Code, going back to an IDE-based AI tool feels like putting on a glove to type.

How I Actually Use It

My daily workflow looks nothing like what I expected when I first installed Claude Code.

The development work is what you'd guess. I use it to build features, fix bugs, refactor code, write tests, review PRs. This portfolio site you're reading was largely built and maintained with Claude Code. Same with my other projects. The tool reads the codebase, understands the patterns, and executes. That part works the way you'd hope.

But here's where it gets interesting. I've built a stack of plugins and skills around Claude Code that extend it well beyond coding.

Superpowers is a plugin that turns Claude Code into a brainstorming and ideation partner. When I'm starting a new project or feature, I don't open a Google Doc. I open Claude Code with Superpowers and talk through the idea. It pushes back. It asks questions I haven't considered. It generates alternatives. I'll cover this in detail in a future post.

GSD is a development methodology plugin that structures how Claude Code plans and executes work. It breaks down tasks, creates actionable plans, and tracks progress. It turned Claude Code from a tool I use ad-hoc into a tool that manages my development workflow end to end.

claude-mem is a memory plugin. Claude Code, by default, doesn't remember anything between sessions. claude-mem fixes that. It stores observations, lessons, and context that persist across sessions and projects. When I start working in a new area of a codebase, it surfaces relevant things I've learned before. It's one of the most underrated parts of my setup.

Subagents let me run multiple Claude Code instances in parallel. One agent does research while another writes code while a third reviews the output. I'll dedicate an entire post to this because the workflow is genuinely powerful.

But it's not just development. I use Claude Code with custom skills and MCP servers to track my daily calories, generate grocery lists based on my meal plan, and build slide decks. It sounds absurd. It's also true, and it works better than any dedicated app I've tried for most of these things.

Each of these topics gets its own post. This is just the trailer.

What This Series Covers

Twenty posts, four weeks, one topic per weekday. Here's the structure.

Week 1: Foundations. The basics that most people skip or misconfigure. How to actually set up Claude Code. How to write a CLAUDE.md file that makes the agent dramatically more useful. How context management works and why it matters. How to configure your exact setup. If you've been using Claude Code for a while, you might be tempted to skip this week. Don't. I discovered things months into my usage that changed how the tool performed for me.

Week 2: Plugins and Methodology. This is where it gets opinionated. I'll cover claude-mem for persistent memory, the GSD methodology for structured development, autonomous coding loops where the agent works unsupervised, and my PR review toolkit. These are the plugins and workflows that turned Claude Code from "useful" to "I can't imagine working without this."

Week 3: Skills and MCP. Custom skills are Claude Code's most underused feature. They let you define reusable workflows that the agent can execute on command. I'll walk through building custom skills, the lifestyle automation I mentioned earlier, and how MCP servers connect Claude Code to external services like Slack, databases, and APIs. If you read my earlier post on MCP being the USB of AI, this is where that theory becomes practice.

Week 4: Advanced Workflows. Hooks for customizing Claude Code's behavior at a system level. End-to-end workflows that chain everything together. Subagent orchestration for parallel execution. Custom slash commands. This is the power-user week.

Final Posts: Opinions. Where I step back and share what I think this all means. What Claude Code gets right and wrong. Where AI-assisted development is heading. Why I believe Claude Code is a new way to use a computer, not just a coding tool.

Each post builds on the previous ones, but you can read any of them standalone. If you're only interested in the memory plugin, skip to that post. If you want the full picture, read them in order.

Who This Is For

If you've never heard of Claude Code, this series will take you from zero to a fully configured power-user setup.

If you installed it last week and you're still figuring out what it can do, this will save you the months of experimentation I went through.

If you've been using it for a while but haven't explored skills, plugins, or MCP, this will open up capabilities you probably didn't know existed.

If you're an experienced user who has a strong workflow already, you might still find something useful. At minimum, you'll see how someone else approaches the same tool and can compare notes.

This is not an Anthropic-sponsored series. Nobody asked me to write this. Nobody's paying me for it. I'm writing it because I use this tool obsessively and I think most people dramatically underuse it. The documentation is good but sparse. The community knowledge is scattered across Discord threads and Twitter posts. There isn't a single comprehensive resource that goes from setup to advanced workflows. This series is my attempt at building that resource.

Why a Series Instead of One Post

I tried writing a single "Complete Guide to Claude Code" post. It was 15,000 words and still felt incomplete. The tool has too many surfaces, too many configurations, too many workflows that only make sense when you see them in context. A single post either stays shallow or becomes unreadable.

A series lets me go deep on each topic without losing the reader. It lets me build concepts incrementally. And honestly, it forces me to be disciplined about organizing what I know. Writing is thinking, and I have months of accumulated knowledge that needs structure.

Twenty posts is a lot. I've already drafted most of them. The schedule is set. The content is real, drawn from my actual daily usage, not theoretical scenarios. Every workflow I describe is one I actually use. Every configuration is one I actually run.

Let's Start

The best way to learn a tool is to watch someone who uses it obsessively. Someone who has pushed it to its limits, found the sharp edges, built workarounds, and developed strong opinions about how it should be used.

That's what this series is. Tomorrow, we start with setup. How to install Claude Code, configure it properly, and get it running in a way that sets you up for everything that comes after.

See you then.