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.

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 serves different needs. The PR layer is useful 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 ($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.

How to use it:

• Comment @copilot fix this on a specific line or file in a PR
• Comment @copilot add tests for this function
• Use Copilot Workspace for larger changes — describe what you want, it plans and generates a PR

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 $10/month 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, 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

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.

The key is matching the tool to the task. Don't use Claude's sophisticated reasoning for "fix this typo" — that's what Copilot is for.

The Cost Reality

Let's be honest about costs:

• Copilot: $10/month flat. Unlimited use.
• 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 are useful but not transformative. They 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.

But they don't replace thinking about code. The architecture decisions, the subtle bugs, the "is this the right approach" questions — those still need human judgment. AI in the PR layer is an assistant, not a reviewer.

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

Use all three, 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

Related

• My Developer Second Brain — Knowledge management and documentation
• Frontend Best Practices — Where AI review helps catch issues

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