What is Claude Code? It Made 400 Commits to My Repos

By Lazar Milicevic · Published June 21, 2026 · 9 min read

You've heard the name. You're not sure if it's a chat window, a VS Code extension, or another SaaS subscription. Here's the cleanest way to understand Claude Code: stop looking at the tool and look at the artifact it leaves behind — the git log of a production app you actually ship.

The reframe: it's not a chatbot, it's a contributor with commit access

When most people hear "Claude," they picture the chat box at claude.ai. You paste a question, you get an answer, you copy something out. Claude Code is not that.

Claude Code lives in your terminal. You point it at a folder, give it a task, and it reads your actual files, edits them, runs your tests, and commits the result to git. The output isn't a message in a window. The output is a commit in your repo.

That distinction sounds small. It isn't. Once you internalize it, your mental model of working with AI changes:

• You stop thinking "assistant I prompt"
• You start thinking "junior contributor with commit access"
• Your job stops being "write code" and becomes "review code"

Everything downstream — how you set it up, how you measure it, how you avoid blowing up production — flows from that single reframe.

What the git log actually looks like

Here's a slice of git log from one of the production apps I maintain — a SaaS invoicing tool with paying users and live billing:

commit 8f3a2c1d
Author: Lazar Milićević <lazar@...>

    fix tax calculation rounding for invoices over $50k

    Co-authored-by: Claude <noreply@anthropic.com>

commit 4b9e7d22
Author: Lazar Milićević <lazar@...>

    add retry logic to email webhook with exponential backoff

    Co-authored-by: Claude <noreply@anthropic.com>

commit 1a55c0fe
Author: Lazar Milićević <lazar@...>

    migrate user_settings to include locale column

    Co-authored-by: Claude <noreply@anthropic.com>

Two things to notice.

First, the Co-authored-by: Claude trailer. That isn't something I bolt on. Claude Code writes it into the commit itself. Every change it makes is attributable, auditable, and reviewable like any other teammate's work. If you ever get audited, get a security review, or onboard a real engineer six months from now, you can answer the question "who wrote this?" honestly.

Second, the messages. Not "refactor stuff." Not "updates." Real ones — "fix tax calculation rounding for invoices over $50k", "add retry logic to email webhook with exponential backoff", "migrate user_settings to include locale column." Those read like commits from a senior dev because the agent read the surrounding code, the test file, and the existing commit history before it wrote the message.

That's a different category of output from "ChatGPT wrote me a function and I pasted it in."

Real numbers: 412 commits, 25 reverts, 6% revert rate

I went back and ran git log --author=Claude --since="90 days ago" | grep ^commit | wc -l across two production apps. Here's what I got:

The agent's revert rate is roughly half of mine when I was moving fast solo. Not because it's smarter than me. Because:

• It doesn't get tired at 11 PM and skip the test file
• It re-reads the surrounding code every single time
• It writes a commit message before moving on, while context is fresh
• It doesn't have the "I'll fix that later" instinct

That last one is the real edge. Most of my reverts in year one weren't from being wrong. They were from being lazy at the wrong moment. The agent doesn't have a "lazy at the wrong moment."

That's the upside. The downside — we'll get to it — is that the agent also doesn't have a "wait, this feels wrong, let me stop and ask." You are that instinct now.

The workflow nobody talks about: queue, sleep, review

Here is where most people go wrong. They open the terminal, type a prompt, and stare at the screen like it's a chat. Wrong tool, wrong posture. You will burn out in three days.

What I actually do:

1. Queue tasks at night or over morning coffee. I write 3–8 well-scoped tasks into a tasks.md or directly invoke Claude Code with each one as a prompt. Each task has acceptance criteria — what file changes, what tests pass, what edge cases matter.
2. Let it work. I close the laptop or work on something else (client calls, design, the next product). No staring.
3. Review in batches. One in the morning, one in the late afternoon. I open git log and treat every Claude commit like a PR from a junior teammate. Read the message. Read the diff. Run the tests locally if it touched anything critical.
4. Keep or revert. If it's clean, it stays. If it's wrong, git revert and I add a note to CLAUDE.md so the same mistake doesn't repeat.

The CLAUDE.md file at the repo root is the most under-discussed part of the whole system. It's how you turn a generic agent into a teammate who knows your project. Mine looks roughly like this:

# Project context for Claude Code

## Stack
- Python 3.11, FastAPI, Postgres 15, SQLAlchemy 2.0
- Frontend: Next.js 14, TailwindCSS
- Tests: pytest, run with `make test`
- Lint: ruff, run with `make lint`

## Coding style
- Type hints on every function signature
- No bare `except:` — always catch specific exceptions
- Prefer composition over inheritance
- Max function length: 40 lines

## Commit message format
- Lowercase, imperative mood
- One line summary, then blank line, then body if needed
- No conventional commits prefix (no "feat:", "fix:")

## No-go zones
- Do NOT touch `migrations/` without explicit instruction
- Do NOT modify `billing/stripe_webhook.py` — ask first
- Do NOT add new dependencies without listing them in the commit body

Every time I revert a Claude commit, I ask: was this a one-off, or did the rules fail? If the rules failed, the rules get updated. That feedback loop is the entire job.

Why this matters for solopreneurs and small teams

You've been told you need to hire a junior developer to scale. You probably don't. What you need is a review habit.

Run the math. A junior in the US runs you $75k–$110k a year fully loaded. Thirty minutes a day reading commits costs you $0 and a coffee. The throughput is higher than any junior could deliver in their first six months, because Claude Code:

• Doesn't need onboarding for the 50th time you've explained your stack
• Works while you sleep, in parallel across repos
• Doesn't need code review on style — CLAUDE.md handles that
• Doesn't ask for a raise after shipping a good feature

But — and this is the part the hype crowd skips — if you cannot review the commits, you should not be using Claude Code. If you don't read code, don't run tests, just trust the agent and ship, you will drop your production database inside a month. I've seen it happen to two people already this year.

The tool is powerful because it's autonomous. Autonomy without review is just damage at scale. The honest answer to "should I use this?" is:

• Yes if you can read a diff and run make test
• No if you can't, even if you're technical-adjacent
• Maybe if you have one technical person on the team who owns the review queue

There is no middle path where you skip review and stay safe.

How this compares to Cursor, Copilot, and chat-based AI

People ask me constantly: isn't this just Cursor? Isn't this Copilot with extra steps? No.

The difference isn't the model. It's the review unit. With Copilot you accept or reject suggestions in real time, which means you're glued to the keyboard. With Claude Code the review unit is a commit you read later, which means you reclaim your time and shift to async work.

That's also why the failure modes are different. Copilot fails by suggesting subtly wrong code you accept while typing fast. Claude Code fails by committing a chunk of work you have to revert. The first failure is invisible and stays in your codebase. The second is loud, attributable, and reversible with one git revert.

I'd rather have the loud failures.

Why bizflowai.io helps with this

A lot of the client work we do at bizflowai.io is exactly this pattern applied beyond code — setting up autonomous agents for small teams (lead follow-up, invoice processing, customer support triage) where the agent does the work and the operator reviews the output in batches instead of staring at a screen. The CLAUDE.md-style guardrails, the queued task model, the daily review habit — those translate directly to non-code automations, and they're how we keep client systems running unattended without surprises.

Frequently asked questions

What is Claude Code?

Claude Code is a terminal-based AI agent that works directly inside your code repository. Unlike the Claude chat interface at claude.ai, it reads your actual files, edits them, runs tests, and commits changes to git. Its output isn't a chat message — it's a commit, automatically tagged with a Co-authored-by Claude trailer, making every change attributable and reviewable like work from any teammate.

How do I use Claude Code effectively?

Don't sit and watch it work like a chatbot. Instead, queue tasks with clear acceptance criteria in a CLAUDE.md file at your repo root, specifying coding style, test commands, commit message format, and no-go zones. Let it run while you're away, then review its commits in batches — typically morning and late afternoon — reading messages and diffs like a pull request from a junior developer.

Why does reviewing commits matter when using Claude Code?

Claude Code is autonomous, which makes review non-negotiable. Without review, autonomy becomes damage at scale — you risk burning your production database within a month. If you can't read code, run tests, or evaluate diffs, you shouldn't use Claude Code. The tool replaces writing code with reviewing it; thirty minutes a day reading commits is the entire job and the safety mechanism.

When should I use Claude Code instead of hiring a junior developer?

Use Claude Code if you're a solopreneur or small team who can review code but can't justify a salary. Over 90 days across two apps, it authored 412 commits with a 6% revert rate — lower than the speaker's own 11% solo revert rate. Throughput exceeds what a junior delivers in six months. However, hire a junior if you can't personally review code and run tests.

How does Claude Code attribute its work in git?

Claude Code automatically writes a Co-authored-by Claude trailer line into every commit it makes. This isn't added manually — the agent writes it into the commit itself. The author field shows Claude on agent-generated commits, making each change auditable and reviewable. Commit messages also read like senior-developer work because the agent reads surrounding code for context before writing them.

Want more like this?

I publish practical AI automation, GenAI engineering, and faceless content workflows on YouTube every week.

Subscribe to bizflowai.io on YouTube — never miss a new tutorial.

Planning an AI automation project or need a second opinion on your architecture?

Connect with me on LinkedIn — Lazar Milicevic, GenAI Engineer & bizflowai.io Founder.

Visit bizflowai.io for our services, case studies, and AI consulting.