Owning Your Pull Requests

Do not wait for others to code review. Review your own work. Merge when ready. You are not blocked on humans.

This sounds radical in a world where code review is considered essential to quality. Teams spend significant time reviewing each other's code. Processes require approval before merging. The assumption is that fresh eyes catch bugs that the author misses.

For human developers, this assumption has merit. Humans make mistakes their own eyes don't see. They miss edge cases. They overlook style issues. Another human brings a different perspective.

For AI agents, the calculus changes completely.

Claude can review code systematically. It doesn't get tired. It doesn't rush because it's Friday afternoon. It applies the same rigor to line three thousand as to line three. The limitations that make human self-review unreliable don't apply.

The ownership mentality extends beyond PRs. When you pick up an issue, assign it to yourself. Mark it as in-progress. Complete the work. Close the issue when the PR merges. The entire lifecycle is owned.

This isn't about avoiding review entirely. The Claude GitHub app can provide automated code review comments on PRs. CI pipelines run tests and linting. Pre-commit hooks catch issues before they're even committed. Multiple layers of automated review exist.

What's eliminated is waiting for human review. The PR goes up. Automated checks run. The agent reviews the diff. If everything passes, it merges. Minutes, not days.

The speed difference is dramatic. A PR that might sit in a review queue for a day merges in minutes. Features ship faster. Iteration cycles compress. The feedback loop between writing code and seeing results tightens.

Quality concerns are legitimate. What if the agent merges something broken? This is what main branch ownership addresses. If main breaks, the agent drops everything to fix it. The accountability loop is immediate. Breaking changes don't persist because the agent that broke them fixes them.

The GitHub integration adds additional perspective. When Claude reviews a PR and posts comments, the authoring agent should read those comments and address concerns. It's still automated review, but it's a second perspective from a fresh context window that might catch something the original session missed.

Human review still happens—just not as a blocking gate. Humans can review merged code at their leisure. They can create issues for concerns. They can request changes through the normal issue process. What they don't do is sit in a review queue blocking progress.

The trust model is explicit. Claude can merge to develop or main because the documentation says it can. The CLAUDE.md file establishes this authority. New instances read it and understand their permissions.

Multiple agents operating in parallel coordinate through GitHub. Assignments prevent duplicate work. Branch names prevent conflicts. Each agent owns their work end-to-end without stepping on others.

The traditional model assumed human time was expensive and human attention was the bottleneck. In AI-first development, compute time is cheap and human attention is better spent on direction and verification than on blocking review queues.

This is what autonomous operation looks like. The agent picks up work, does the work, verifies the work, and ships the work. Humans set priorities and verify outcomes. The middle steps don't require human attention.

The ownership mentality applies to issues too. When you start an issue, you own it until completion. You don't hand it off. You don't mark it partially complete. You finish it, merge the PR, close the issue, and move on.

Feature branches and PRs as the unit of work integrate naturally. Each feature is a branch. Each branch becomes a PR. Each PR is reviewed and merged by its author. The atomic unit of shipped work is one person (or agent) taking a feature from conception to production.

The adjustment for teams is cultural. Human developers might resist the idea that code can merge without their review. The evidence that changes this: quality remains high, velocity increases dramatically, and humans can focus on higher-level work.

Own your PRs. Review them. Merge them. Move on to the next. This is the pace of AI-first development.