claude code

Part 1 introduced Claude Code and got it installed. Part 2 walked through building a real feature on hexutil, backed by a CLAUDE.md file and a plan-then-act loop. Both of those posts assumed a single person, sitting at a keyboard, working on one task at a time. That’s a fine place to start, but it’s not where Claude Code stays useful. This post is about the other side of it: getting it to work with the tools you already use, and getting it to work when you’re not sitting there at all.

Git Is Not an Afterthought

Claude Code doesn’t treat version control as something you handle separately after it’s done editing. It works directly with git: staging changes, writing commit messages, creating branches, opening pull requests. When I finished the --batch flag from Part 2, I didn’t switch over to my terminal history and write a commit message myself:

> commit these changes with a descriptive message, then open a PR

It looked at the diff it had just made, wrote a commit message that actually described what changed instead of “update files,” and opened the PR. For a change that small, this saves maybe ninety seconds. For a project where you’re doing this a dozen times a day, it adds up to not context-switching out of the problem you’re actually thinking about just to write prose about it.

The same idea extends to CI. GitHub Actions and GitLab CI/CD integrations let Claude Code review pull requests and triage issues automatically, so code review starts before a human ever opens the diff.

MCP: Giving It Access to Everything Else

Your codebase is rarely the only source of truth for a project. Design decisions live in Google Drive. Tickets live in Jira. Discussion happens in Slack. The Model Context Protocol (MCP) is an open standard for connecting AI tools to exactly that kind of external data, and it’s how Claude Code reaches outside your repository without you copy-pasting context into the chat by hand.

Once an MCP server is connected, Claude Code can pull from it the same way it reads a local file. Ask it to implement a feature described in a Jira ticket, and instead of you summarizing the ticket, it reads the ticket itself. Ask it why a design decision was made, and it can check the doc where someone actually wrote that down, instead of guessing from code comments.

I won’t walk through setting up a specific server here, because which one is worth connecting depends entirely on where your team actually keeps things. Claude Code has a built-in MCP quickstart that walks through connecting your first server end to end, and that’s the right starting point regardless of which tool you’re connecting.

Taking Yourself Out of the Loop

Everything so far has still had me typing a prompt and waiting for a response. The last piece is having Claude Code do work on a schedule, without me starting the session at all.

Routines run in the cloud, so they keep going even when your laptop is closed, and they can trigger on a schedule, an API call, or a GitHub event. For hexutil, I set one up to run every morning: check for open pull requests, review them against the conventions in CLAUDE.md, and leave comments on anything that doesn’t match. I didn’t have to be awake for that to happen.

If you want the automation tied to your local machine instead of the cloud, desktop scheduled tasks run the same way but with direct access to your local files and tools, which matters if the task depends on something that only exists on your machine. And for quick, short-lived polling inside a single session, like watching a log stream, /loop repeats a prompt without you needing a full scheduled job for it.

None of these replace judgment. They replace the parts of the job where the judgment was already made, and the only thing left was remembering to do it.

Where This Leaves Us

Three posts ago, this was a terminal command that could edit a file. By the end of Part 2, it was reading project context and shipping a tested feature from a sentence. Now it’s opening its own pull requests, pulling context from wherever your team actually keeps it, and reviewing code before you’ve had coffee. That’s the actual shape of what “agentic” means here: not a smarter autocomplete, but a system that takes a goal, plans toward it, and acts, with you setting the boundaries of how much it does before it checks back in.

If you’re starting from scratch, the path through this series is the right order to build it: get Claude Code installed and understand what it’s doing, give it real project context and watch it build something, then open it up to the tools and schedules that make it part of your workflow instead of a thing you occasionally remember to use.

Conclusion

That’s the series. Install it, teach it your project, then let it out of the sandbox a little at a time; version control, external context, and eventually a schedule of its own. Start small, review what it does, and expand its permissions only as far as you’ve actually verified it earns them.