Claude Code: AI That Reads Git History & Writes Pull Requests

💡 TL;DR - The 30 Seconds Version

🤖 Claude Code builds entire features and reads git history instead of just completing code lines like other AI tools

⚡ Anthropic cut technical onboarding time from 2-3 weeks to 2-3 days using Claude Code for codebase Q&A

🔧 Works in any terminal with any IDE, integrates with existing team tools, and keeps your code local

🎯 Start with codebase questions before coding - Claude Code analyzes git commits and explains why code exists

🚀 Power users run multiple sessions in parallel and use it for CI pipelines and automated incident response

Most AI coding tools complete your next line of code. Claude Code builds entire features, debugs complex bugs, and even writes your commit messages.

I watched Boris from Anthropic walk through Claude Code's real capabilities, and frankly, it made every IDE plugin I've used look like a toy. This isn't another autocomplete tool. It's an AI engineer that works in your terminal, with your tools, in your workflow.

Start with Questions, Not Code

Here's what most people get wrong: they open Claude Code and immediately ask it to build something. That's like hiring a developer and throwing them into production code on day one.

Boris shared how Anthropic onboards new technical hires. They used to spend 2-3 weeks getting people productive. Now it takes 2-3 days. The secret? Start with codebase Q&A.

Ask Claude Code questions like:

"How is this User class instantiated?"
"Why does this function have 15 arguments?"
"What did I ship this week?"

The third question is my favorite. Boris runs this every Monday for standup. Claude Code scans the git log, finds his commits, and summarizes everything he shipped. Copy, paste, done.

The second question shows Claude Code's real power. It doesn't just search for text. It digs through git history to understand why code exists. It finds the commits that added those 15 arguments, reads the linked issues, and explains the context. No human has time for that kind of archaeological work.

Claude Code does this without any setup. No indexing, no uploading your code anywhere, no waiting. Your code stays local. Start it up and ask questions immediately.

Build Features the Right Way

Once you understand your codebase, you can start building. But here's the key insight: ask Claude Code to think before it codes.

I watched someone build a conversation history feature for their AI tutoring app. Instead of jumping straight to implementation, they asked Claude Code to:

Understand the current architecture
Write a product requirements document
Plan the implementation
Get approval before writing code

The PRD it generated was better than most I see in professional settings. It included success metrics (30% of users enable the feature within 30 days), technical requirements, and even GDPR compliance considerations after doing its own web research.

For the actual implementation, Claude Code:

Removed the 30-day TTL from the database
Built new API endpoints to list conversations
Updated the frontend toggle functionality
Created the conversation list UI

When the first implementation didn't work, the developer didn't just say "it's broken." They investigated. They checked the network tab, saw that conversations were saving to the database but not displaying, and gave Claude Code that specific context.

Claude Code fixed it in the next iteration.

Give It Tools and Watch Magic Happen

The breakthrough moment comes when you give Claude Code your team's tools. Boris showed a simple pattern:

# Tell Claude about your CLI tools
Use the barley CLI to deploy staging environments. 
Use --help to figure out commands.

That's it. Claude Code figures out how to use your tools from their help text. It works with MCP servers, bash commands, whatever your team already uses.

At Anthropic, their app repository includes a Puppeteer MCP server. Any engineer working in that repo can tell Claude Code to take screenshots of their UI changes and iterate based on visual feedback. They don't each install Puppeteer individually - it's shared team configuration.

Here's the pattern that creates magic: give Claude Code a way to check its work. Whether that's unit tests, screenshots, or integration tests, Claude Code will iterate until it gets things right. I've seen it turn a rough UI mockup into pixel-perfect implementation through three rounds of screenshot feedback.

Context Makes Everything Better

Claude Code gets smarter with context. The more you tell it about your systems, architecture, and conventions, the better decisions it makes.

Use .claude files to share knowledge:

Put one in your project root with common commands and architectural decisions
Create local .claude files that don't get checked in for personal preferences
Use enterprise policies to roll out team-wide configurations

Boris keeps it simple in the Anthropic codebase: common bash commands, style guide, core files. That's enough to make Claude Code feel like a team member who actually understands the project.

The #remember command lets you teach Claude Code during sessions. If it's not using a tool correctly, type #remember followed by the right way to do it. Claude Code incorporates that into its memory automatically.

Power User Techniques

A few key bindings transform how you work with Claude Code:

Shift+Tab: Auto-accept edits mode. Use this when Claude Code is iterating on tests or clearly on the right track
!command: Drop to bash while keeping the command and output in context
Escape: Stop Claude Code safely anytime, then redirect with new instructions

The Claude CLI opens up automation possibilities. Boris uses it in CI pipelines and incident response. It's like having a Unix utility that happens to be superintelligent:

git status | claude "summarize what's changed" | jq '.summary'

Power users run multiple Claude Code sessions in parallel. They use Git worktrees for isolation and SSH tunnels to access remote development environments. Boris sees this pattern among the most productive users both inside and outside Anthropic.

Why This Actually Works

Claude Code works because it makes a bet on the future. Instead of building elaborate IDE integrations, they built for the terminal - the common denominator every developer uses.

The underlying model does the heavy lifting. Boris mentioned there's almost no system prompting telling Claude Code how to use Git or analyze codebases. The model just knows. That's why it can read git history, understand your tools, and write coherent commit messages without special programming.

This is what agentic AI looks like when it's done right. Not flashy demos, but a tool that slots into your existing workflow and makes you more productive from day one. Claude Code doesn't replace your IDE - it makes everything you already do work better.

The terminal might seem like a step backward from sleek IDE plugins. But when your AI assistant can read git history, write pull requests, and iterate on feedback, the interface doesn't matter. The capability does.