I Let AI Handle My Git Operations, and Now I Almost Never Commit by Myself

I Noticed Something Recently

Recently, I noticed something.

I almost never make Git commits by myself anymore.

It is not that I have stopped using Git.

I look at GitHub every day.

I check pull requests.

I understand the branch structure.

But the number of times I actually commit with my own hands has dropped sharply.

The reason is simple.

I let Claude Code handle it.

I Still Use SourceTree, But Mostly for Looking

I used to use SourceTree.

I still use it today.

But now I mostly use it just to look at things.

The readability of a GUI tool is still useful.

But Git operations contain a surprising amount of small, tedious work.

Checking diffs.

Staging files.

Writing commit messages.

Pushing changes.

Each one only takes a few seconds.

But when you do them dozens of times every day, the accumulated friction becomes surprisingly annoying.

And Git has a habit of getting into a bad mood from time to time.

A branch will not switch.

A merge gets stuck halfway.

A conflict appears.

In the past, whenever that happened, I investigated it myself.

I read the error message.

I looked at the logs.

I searched the web.

In the end, I opened the terminal.

That was usually the flow.

Now I Just Ask Claude

Recently, it is different.

I tell Claude:

“Commit this.”

Then it checks the diff on its own.

It summarizes the changes.

It comes up with a commit message.

It commits.

It pushes.

Done.

At first, I felt a little uneasy.

I thought commit messages were something humans were supposed to write.

But after actually using it, I found that Claude often writes better ones than I do.

What changed.

Why it changed.

Which feature is affected.

It organizes those points properly.

I sometimes make small corrections, but most of the time I use the message as it is.

The Quietly Useful Part Is Troubleshooting

The quietly convenient part is how it handles trouble.

When a Git error occurs, Claude starts investigating the cause on its own.

It checks the current state.

It looks at the logs.

It runs additional commands when needed.

Then it reports back:

“This was the cause.”

“I handled it this way.”

I just wait while drinking a Coke.

Conflict resolution was especially impressive.

In the past, conflicts felt a little heavy.

I had to check the conflicting parts, decide which side to keep, confirm the impact, and resolve everything carefully.

Now Claude says:

“This part is in conflict.”

“For this change, I think this side is the more natural one to keep.”

“Here is why.”

Of course, I make the final decision myself.

But the amount of work has dropped dramatically.

Git Is a Tool, Not the Main Character

Git operations themselves are not the goal.

What I want to do is build systems.

Git is a necessary tool, but it is not the main character.

Developers in the past argued about editors.

Vim or Emacs.

When I was younger, there were also debates about GUI versus CUI.

But recently, the discussion feels a little different.

Now there is another option: the AI approach.

This does not mean you no longer need to understand Git.

On the contrary, because I understand how Git works, I can judge whether the AI’s suggestions are reasonable.

It is similar to driving a car without assembling the engine yourself.

My Current Rule

My current operating rule is simple.

Local work.

Commit.

Push.

I leave those steps to Claude.

On the other hand, pull requests to shared branches and merges are still handled by humans.

I think the final confirmation should remain my responsibility.

For now, this feels like the best balance.

AI that writes code.

AI that reviews code.

AI that commits code.

And me, drinking a Coke while checking what it did.

For now, this division of roles is working well.