PR-level AI agents: Copilot, Claude, and Gemini in your GitHub workflow

This is Part 3 of my AI coding workflow series. Part 1 covers terminal agents. Part 2 covers editor-level AI. This post focuses on the PR layer: using AI directly in GitHub.

A note on timing: the AI tooling space moves fast. The tools, models, and prices here are a snapshot of what I use right now, not a fixed recipe, and some details will date quickly. I keep these posts updated as my workflow shifts.

The stack has layers

After months of using AI coding tools, I've settled into a three-layer approach:

Layer 1: Session-level orchestration. This is Claude Code, OpenCode, or similar. Terminal agents with filesystem access, command execution, and persistent context within a session. Good for complex, multi-file changes.

Layer 2: Editor-level. Zed or VS Code with AI completions and agent panels. Covered in Part 2. Fast inline suggestions, plus full agents running inside your editor.

Layer 3: PR-level agents. GitHub Apps that respond to @mentions in PRs and issues. This is what we're covering today.

Each layer covers different needs. The PR layer is for quick fixes, code review, and tasks that benefit from GitHub's native context: the diff, the CI output, the issue thread.

The three PR agents

GitHub Copilot (Pro from $10/month)

Copilot is the most integrated option. It's tied to your GitHub account, not to specific repositories. If you can access a repo, your Copilot works there.

Pricing as of early 2026: Copilot Pro is $10/month, Pro+ $39/month, Business $19/user/month. From June 2026 all plans move to usage-based billing on AI Credits, so "unlimited" no longer applies the way it used to. Check the current pricing page before assuming.

How to use it:

• Comment @copilot fix this on a specific line or file in a PR
• Comment @copilot add tests for this function
• For larger changes, use the Copilot Coding Agent (assign an issue or PR to @copilot). The standalone "Copilot Workspace" preview was sunset in May 2025 — its agentic planning is now folded into Coding Agent and VS Code Agent Mode

What it's good at:

• Quick fixes when CI fails
• Adding tests for existing code
• Refactoring suggestions
• Understanding the PR context (what changed, what the diff shows)

The account-level thing matters. If you're a contractor working on client repos, Copilot travels with you. You don't need the client to set anything up. Your subscription works on any repo you can access.

Claude GitHub App (API credits)

Anthropic's Claude is available as a GitHub App. You install it on repositories you own or have admin access to.

How to use it:

• Install the Claude app on your repo
• Comment @claude review this PR or @claude explain this change
• It uses your Anthropic API credits

What it's good at:

• Complex reasoning about architecture decisions
• Explaining why code works (or doesn't)
• Longer, more thoughtful code reviews
• Understanding nuanced requirements

The limitation: You need admin access to install the app. Can't use it on client repos where you're just a collaborator.

Gemini Code Assist (Free tier available)

Google's option. Similar installation model to Claude, it's a GitHub App you add to repos. Set it up at codeassist.google.

How to use it:

• Install Gemini Code Assist on your repo
• Comment @gemini-code-assist review or similar
• Free tier available, ties to your personal Google account (not Workspace)

What it's good at:

• Quick PR reviews
• Suggesting improvements
• Good enough for most review tasks

Important ownership note: Gemini Code Assist only runs on repositories you own or where the owner has explicitly enabled it. The docs say "applies to all current and future repositories owned by the resource owner", meaning your repos, not client repos where you're a collaborator. Same limitation as Claude.

Trade-off: Less capable than Claude for complex reasoning, but free is compelling for high-volume repos.

When to use each

Here's my current decision tree:

Working on my own repos:

• Quick fixes → Copilot (fastest, most integrated)
• Complex review → Claude (better reasoning)
• High volume PRs → Gemini (free tier)

Working on client repos (collaborator access only):

• Everything → Copilot (only option that works)

Team repos where I'm admin:

• Install all three, use contextually
• Let team members use whichever they prefer

Practical setup

Installing the GitHub Apps

For Claude:

1. Go to github.com/apps/claude (or search GitHub Marketplace)
2. Install on selected repositories
3. Configure Anthropic API key in app settings

For Gemini:

1. Search "Gemini Code Assist" in GitHub Marketplace
2. Install on selected repos
3. Sign in with Google account

Copilot is different. It's account-level:

1. Subscribe at github.com/features/copilot
2. Enable for your account
3. Works everywhere automatically

Other PR review tools

The three above are what I use, but there are alternatives worth knowing about.

CodeRabbit

Automated PR review that runs on every pull request. No @mention needed, it just reviews automatically.

• Cost: Free tier for PR summaries. £24/month per developer for full reviews.
• How it works: Install the GitHub App and it reviews every PR automatically.
• Standout features: Generates architectural diagrams, learns from your feedback over time, runs 40+ linters.
• Trade-off: Per-seat pricing adds up on larger teams. The free tier only gives you summaries, not actionable review comments.

I haven't used CodeRabbit extensively, but the automatic review on every PR is appealing if you want consistent coverage without remembering to @mention anything.

Sweep

Turns GitHub issues into pull requests automatically.

• Cost: Free tier available.
• How it works: Label an issue, Sweep generates a PR to fix it.
• Good for: Routine bug fixes, small features, dependency updates.
• Trade-off: Works best for well-scoped, isolated changes.

Sourcery

Python-focused code quality tool.

• Cost: Free for open source. £10/month for individuals.
• Focus: Python-specific analysis, refactoring suggestions, quality metrics.
• Good for: Python-heavy codebases that want opinionated quality gates.

Quick comparison

Prices as of early 2026 — verify before purchase.

The workflow in practice

Here's how a typical PR review goes with the layered approach:

1. I write code using Claude Code or OpenCode (Layer 1). Multi-file changes, running tests locally, iterating on implementation.

2. I push and open a PR. GitHub Actions run tests, linting, whatever CI I've configured.

3. If CI fails, I comment @copilot fix the failing test on the error. Quick, integrated, usually works.

4. Before merging, I might ask @claude review this PR for security issues if it touches auth or user data. More thorough than Copilot for complex review.

5. For routine PRs, Gemini handles basic review without burning API credits.

Match the tool to the task. Don't use Claude's reasoning budget for "fix this typo". That's what Copilot is for.

The cost reality

The actual costs (early 2026):

• Copilot: Pro from $10/month. From June 2026 all plans move to usage-based AI Credits, so "unlimited" no longer applies the way it used to.
• Claude: Pay per API call. Varies with usage. A heavy review day might cost £1-2.
• Gemini: Free tier exists. Generous enough for many use cases.

For me, Copilot is the baseline. It's cheap, works everywhere, and handles 80% of PR-level tasks. Claude is for when I need better reasoning. Gemini is for when I want free.

What doesn't work

Complex multi-file refactors in PRs. The PR agents see the diff, not your full codebase context. For big changes, Layer 1 (terminal agents) is still better.

Architectural decisions. Same as with any AI tool, they'll suggest confidently wrong approaches. Use PR agents for implementation review, not design review.

Client repos without admin. Only Copilot works here. If you need Claude-level review on client code, either get admin access or use the terminal agent locally before pushing.

The honest take

PR-level agents save time on routine tasks: fixing CI failures, catching obvious issues, adding test cases. The 10 minutes you'd spend debugging a linter error becomes 30 seconds of @copilot fix this.

They don't replace thinking about code. Architecture decisions, subtle bugs, the "is this the right approach" questions still need human judgement. AI in the PR layer is an assistant, not a reviewer.

And the easier these agents make it to open and review pull requests, the more there are to clear. Theo Browne describes pointing background agents at bug reports and ending up with hundreds of pull requests just sitting there. One analysis of more than 10,000 developers found pull-request volume up around 98% with AI in the loop, and review time up around 91%. The agents generate faster than a person can approve, so the queue, not the writing speed, is the thing to watch.

The multi-layer approach works because each layer handles different scales:

• Terminal agents: full codebase context, complex multi-step tasks.
• Editor agents: fast completions while writing.
• PR agents: quick fixes and reviews in GitHub's context.

Match the tool to the task and don't expect any of them to replace understanding your own code.

Series navigation

AI Coding Workflow Series:

• Part 1: Terminal Agents — Claude Code, OpenCode, session-level orchestration.
• Part 2: Editor-Level AI — Zed, inline completions, agent panels.
• Part 3: PR-Level Agents (this post) — GitHub Apps, automated review.
• Part 4: Persistent VPS Agent — OpenClaw, Tailscale, Syncthing.
• Part 5: Claude Code Skills Setup (coming soon) — extending Claude Code with custom and vendor skills.

Related

• My developer second brain — knowledge management and documentation.
• Frontend best practices — where AI review helps catch issues.
• Type-safe GTM event tracking — another example of where automated review catches issues early.

This series covers my actual AI coding workflow. I'll update as tools evolve.