Claude Code & CLI workflows: shipping from your terminal

Most people who try Claude Code or aider after a stint in Cursor or Bolt have one of two reactions in the first hour. "Wait, this is faster?" Or, "I miss having a sidebar." Both are true. The terminal feels alien for two days, then it doesn't.

This guide is for the version of you that just deployed something real and is wondering whether the next step is to leave the GUI behind. Short answer: probably yes, at least for some of your work.

What you're trading

A web IDE holds your hand. File tree on the left, code in the middle, preview on the right, AI in a panel you can ignore. Everything is a click away.

A terminal agent strips that down to a prompt and your repo. The agent can read every file, run every command, edit every line. That's the upside, full repo context, no UI overhead, the same workflow whether you're in a Next.js app or a 200-line Python script.

The cost is real. No real-time preview pinned next to your code. No syntax-highlighted diff in a side panel. You'll flip windows between your terminal and your browser, or split-pane your terminal and your editor. After a week you stop noticing.

A real morning

Here's what a normal session looks like.

Open the terminal in your project folder. Start a session.

cd ~/code/my-app
claude

Describe the change you want, in the same plain English you'd use in Cursor.

The /pricing page is doing client-side fetching for the plans.
Move that to a server component so it doesn't flash empty on load.
Update the tests.

Watch it work. It'll read files, ask a clarifying question if it needs to, edit two or three files, run your test command, and report back. You're not babysitting, but you're not in another tab either. The output scrolling past is your loop.

When it says it's done, you check the work yourself.

git diff
npm test

If the diff looks right and tests pass, commit and push.

git add .
git commit -m "move pricing page to server component"
git push

Optional, deploy.

vercel --prod

Total time on a focused task, ten to twenty minutes. The agent handled the typing. You handled the judgment.

Multi-file refactors

This is where terminal agents earn their keep. A real example, you renamed a concept in your app from "workspace" to "project" and it's referenced across four files.

Rename the concept "workspace" to "project" everywhere in the app.
Variable names, type names, route paths, UI copy, and the database
column. Update tests. Don't touch the migration history, just add a
new migration for the column rename.

It will edit your model, your API routes, your components, your tests, your migrations file. It'll write the commit message too if you ask.

git diff --stat
git commit -m "$(claude --commit-message)"

The agent just did 45 minutes of careful find-replace in four. Your job was scoping the task and reading the diff.

CLI muscle memory

You don't need to be a terminal wizard. You need maybe six commands to feel oriented.

git diff              # what changed since the last commit
git log --oneline     # recent commits, one per line
git checkout .        # throw away uncommitted changes
gh pr create          # open a pull request from this branch
npm test              # run your test suite
vercel logs           # tail production logs

That's it. Pick them up as you need them. Nobody memorizes the terminal upfront, you learn one command per real problem.

Trust, but verify

The agent edits multiple files at once. That makes it powerful and makes the review step matter more, not less. The checklist from the "Catching AI-generated bugs" guide applies double here, read every line of the diff, search docs for any function name you don't recognize, run on edge inputs, grep for hardcoded secrets.

The single most important habit, commit before any non-trivial agent task. If the run goes sideways, one command puts you back where you started.

git reset --hard HEAD

A clean baseline before each task means you're never afraid to let the agent try something ambitious.

Aider, the open-source version

If you'd rather bring your own model or stay off Anthropic's billing, aider is the open-source terminal agent that does the same shape of work. Point it at a repo, give it your OpenAI or Anthropic API key, and you get the same edit-and-commit loop. It even writes git commit messages by default. Different defaults, same idea.

Pick whichever fits your taste. The skill transfers.

Closing Pillar 4

Across this pillar you took a working prototype, picked a host, deployed it, and now you're shipping changes from a terminal without leaning on a web IDE. You own the stack. Nobody is going to delete your project on a pricing change.

Pillar 5 is the productivity playbooks. The patterns that compound when you've got the tooling sorted, prompt libraries, agent loops you reuse, the small habits that turn "I built a thing" into "I ship one of these every weekend."