I’d been using AI coding assistants in my editor for a while when I decided to try something different: working primarily from the terminal with Claude Code. A month in, my workflow looks nothing like it did before — and I mean that in the best way.

What Claude Code Actually Is

For those who haven’t tried it, Claude Code is a CLI tool from Anthropic that lets you work with Claude directly in your terminal. It’s not an editor plugin. It reads your files, understands your project structure, and can edit code, run commands, and manage your development workflow through conversation.

The first time I used it, I expected glorified autocomplete in the terminal. What I got was closer to a junior developer sitting next to me who happens to type at 500 words per minute.

The Workflow Shift

My old workflow: open editor, write code, test, debug, repeat.

My new workflow: describe what I want, review what Claude Code produces, test, refine through conversation, repeat.

The difference sounds small, but it changes the rhythm of development completely. Instead of staring at a blank file thinking about implementation, I start by talking about what I want. The conversation forces me to clarify my own thinking before any code is written.

Here’s a typical interaction:

me: Add rate limiting to the /api/submit endpoint.
    Limit to 10 requests per minute per IP address.
    Use an in-memory store — we don't need Redis for this.

claude: I'll add rate limiting to the submit endpoint...
        [reads the current code, creates a rate limiter,
         modifies the endpoint, adds the middleware]

It reads the existing code, understands the project context, and makes changes that fit. I review the diff, maybe ask for adjustments, and move on.

What Surprised Me

It understands project context better than I expected. Claude Code doesn’t just look at the file you’re working on. It explores your project structure, reads related files, and understands how things connect. When I asked it to add a new API endpoint, it automatically followed the patterns established in existing endpoints — same error handling, same response format, same naming conventions.

The terminal is a surprisingly good interface for coding. I was skeptical about this. I love my editor with syntax highlighting and file trees. But working in the terminal cuts out a lot of noise. You’re focused on one thing at a time: the change you’re making right now. It’s like the difference between writing in a cluttered room and writing at a clean desk.

It’s great for tasks I usually procrastinate on. Writing tests, updating documentation, refactoring messy code — the stuff that’s important but not exciting. I find myself actually doing these things now because the effort required dropped by 80%. “Write tests for the authentication module” takes thirty seconds to type and a few minutes to review. No excuse to skip it.

What Works Best

After a month, here are the tasks where Claude Code adds the most value for me:

Refactoring. Describing a refactor in natural language is so much easier than doing it manually. “Move all database queries from the route handlers into a separate repository module” — and it just does it, across multiple files, maintaining consistency.

Exploring unfamiliar codebases. When I pick up an open source project or an old codebase, I can ask “How does the authentication flow work in this project?” and get a walkthrough without reading every file myself.

Multi-file changes. Any change that touches more than two or three files is dramatically faster. Adding a new feature that needs a database migration, a model, an API endpoint, and a test? One conversation.

Git workflows. Creating commits with good messages, reviewing diffs, managing branches — all through conversation. It’s surprisingly natural.

Where I Still Reach for My Editor

I haven’t abandoned my editor entirely. There are still things I prefer to do the traditional way:

  • Fine-tuning CSS — when I’m adjusting pixels and colors, I want to see the result live
  • Complex debugging sessions — sometimes I need to set breakpoints and step through code
  • Reading large files — scrolling through code with syntax highlighting is still more comfortable in an editor

The workflow that’s emerged is a hybrid: Claude Code for building and modifying, editor for reviewing and fine-tuning. They complement each other well.

Tips If You’re Getting Started

Start with a real task, not a toy project. Claude Code’s value shows most when it’s working with real code that has real complexity. Give it something meaningful to do.

Be specific about what you want. “Make the API faster” is too vague. “Add caching to the get_user endpoint with a 5-minute TTL” is actionable.

Review everything. This isn’t optional. Read the diffs, understand the changes, and test the results. Trust but verify.

Use it for the boring stuff. The biggest productivity gain isn’t in writing new features — it’s in all the surrounding work that usually slows you down. Tests, docs, refactoring, boilerplate.

The Bigger Picture

What excites me most about this workflow isn’t the speed — it’s the shift in what I spend my time on. I’m making more decisions and writing less boilerplate. I’m thinking about architecture more and syntax less. I’m building more ambitious things because the cost of implementation dropped.

That feels like the right direction for software development. Not replacing developers, but freeing them up to focus on the parts of the job that require human judgment.

If you haven’t tried a terminal-based AI coding workflow, give it a week. You might not go back.