コーディングエージェントとGitを組み合わせる — Simon Willison のパターン集を読むThis article reviews Simon Willison's practical patterns for combining coding…

Coding agents such as GitHub Copilot's agent mode, Claude Code, OpenAI's Codex CLI, and similar tools can now edit files, run commands, and iterate on a codebase with limited human intervention. That autonomy raises an obvious question: how do you keep an agent's changes reviewable, reversible, and safe? A recent Zenn post takes up that question by walking through Simon Willison's practical patterns for pairing coding agents with Git, and it is worth reading because it treats version control not as an afterthought but as the primary control surface for working with AI-driven automation.

The central idea is that Git is what makes agentic coding tolerable. When an agent can rewrite dozens of files in a single run, the ability to inspect a clean diff, discard unwanted work, and return to a known-good state becomes essential rather than optional. Willison has long argued that the risk profile of these tools changes dramatically once every change is captured as a commit, because a bad edit is no longer a disaster but simply something to revert. The article frames Git less as a backup mechanism and more as an interactive safety net that lets developers grant agents more freedom precisely because mistakes are cheap to undo.

Branch management is one of the load-bearing patterns. The recommendation is to let an agent operate on a dedicated feature branch rather than directly on main, so its output can be evaluated in isolation and merged only after review. This mirrors ordinary team practice, but it takes on extra importance when the "contributor" is a model that may misunderstand intent or introduce subtle regressions. Keeping agent work on separate branches also makes it straightforward to run more than one experiment, compare approaches, and abandon the ones that do not pan out without polluting the main line of history.

Commit strategy is the other pillar. The patterns favor frequent, small, well-scoped commits so that each unit of work is easy to understand and easy to roll back. Committing before handing control to an agent establishes a clean checkpoint, and committing after a successful step preserves progress incrementally. This granularity pays off during review, because a reviewer can read the diff for a single logical change instead of trying to reason about a sprawling, monolithic edit. It also improves the quality of the model's own context, since a coherent commit history gives the agent a clearer picture of how the project has evolved.

The article also touches on Git worktrees, a feature that lets you check out multiple branches into separate directories from the same repository. Worktrees appear to be a natural fit for running several agents, or several attempts, in parallel without the overhead of cloning the repository repeatedly. Each worktree gives an agent its own isolated working copy, which reduces the chance of concurrent runs stepping on one another. This is an area where tooling is still maturing, and the practicality of heavy parallelism likely depends on the size of the project and the compute available.

Underlying all of this is the discipline of reviewing diffs before merging. None of the patterns advocate trusting agent output blindly. Instead they position the human as the reviewer of record, using Git's diffing and staging tools to accept, amend, or reject work chunk by chunk. That posture aligns with a broader industry consensus that current models remain capable of confident errors, so a human checkpoint before code reaches production is prudent.

For context, these patterns sit alongside a wave of related moves across the tooling landscape. GitHub has been extending Copilot toward more autonomous, pull-request-oriented workflows; Anthropic's Claude Code and OpenAI's Codex CLI operate directly in the terminal against local repositories; and editors like Cursor and Windsurf lean heavily on the same review-and-revert loop. A prerequisite for benefiting from any of them is basic fluency with Git branching, staging, diffing, and reverting, since those primitives are exactly what turn an unpredictable agent into a manageable collaborator.

The takeaway from the article is measured rather than triumphant. Combining coding agents with Git does not eliminate the need for judgment, but it lowers the cost of experimentation and makes agent-generated changes auditable. For developers weighing how much autonomy to grant these tools, adopting deliberate branch and commit conventions appears to be a low-effort way to capture more of the upside while containing the downside.