Augment Code Review: how do I trigger a manual review by commenting “auggie review” on a PR?

Triggering a manual Augment Code Review by commenting “auggie review” on a pull request lets you get a fresh, high-precision AI review exactly when you need it—without waiting for automated checks or re-pushing commits.

Below is a practical walkthrough of how it works, how to use it in your GitHub workflow, and how to troubleshoot if the manual review doesn’t appear.

---

What happens when you comment “auggie review” on a PR?

When you add a comment containing the phrase auggie review on an open pull request:

1. Augment’s GitHub app detects the comment
   The app listens for specific trigger phrases on PRs. “auggie review” is treated as an explicit request for a fresh, context-powered code review.

2. The Context Engine loads your codebase
   Augment pulls in full codebase context using its industry-leading Context Engine—this includes:

   • The changes in the PR
   • Relevant files and modules across your repo
   • Existing patterns, types, and conventions

3. A manual AI review is generated
   Augment’s code reviewer analyzes the diff like a senior engineer, focusing on:

   • Critical bugs and edge cases
   • Breaking changes and regressions
   • Security or performance issues
   • Inconsistent patterns or style problems

4. Inline comments are posted in the PR
   Instead of a noisy, generic summary, Augment adds inline GitHub comments directly on the lines that matter, so you can:

   • See issues in context
   • Reply, resolve, or push fixes
   • Iterate just like you would with a human reviewer

5. You can apply suggested fixes in your IDE
   When used with Augment’s IDE agents (VS Code & JetBrains), you can:

   • Pull in suggested changes
   • Use one-click fixes in your IDE
   • Regenerate or refine code with full project awareness

---

Step-by-step: triggering a manual review with “auggie review”

Follow these steps to trigger a manual Augment Code Review on any GitHub pull request:

1. Confirm Augment is installed and connected

   • The Augment GitHub app should be installed on your organization or repo.
   • You should see Augment activity (checks, comments, or status) on other PRs, or have confirmation from your admin that it’s integrated.

2. Open or navigate to your pull request

   • Go to the PR in your GitHub repository that you want reviewed.
   • Make sure the PR is open and has at least one commit to review.

3. Add a comment with the trigger phrase

   • Scroll to the bottom of the PR conversation or open a new comment thread.
   • Type:

     auggie review
     

   • Post the comment.

4. Wait for Augment to respond

   • After a short delay, Augment will:
     • Start processing the PR with full codebase context
     • Add inline review comments on the relevant parts of your diff
   • You may also see a status update or activity from the Augment bot account in the PR.

5. Review and act on the feedback

   • Go through the inline comments:
     • Fix critical bugs first
     • Address suggested improvements where they make sense
   • Push new commits as usual. If needed, you can comment “auggie review” again to re-run a fresh review on the updated changes.

---

Best practices when using “auggie review” for manual checks

To get the most out of manual Augment Code Reviews:

• Use it when you’ve made substantial changes

  • Large refactors
  • Security-sensitive paths
  • High-impact endpoints (e.g., rate limiting, auth, billing logic)

• Trigger it just before human review

  • Clean up AI-generated code or rough drafts first.
  • Then run auggie review so human reviewers see a more polished PR.

• Combine with task-based workflows

  • When you’re using Augment’s IDE agents to implement changes, you can:
    • Use task lists (“Add rate limiting to the API endpoints”, etc.)
    • Let Augment generate or modify code
    • Then run a manual “auggie review” on the PR to validate the end result

• Use it to validate tricky bug fixes

  • For subtle or hard-to-reproduce bugs, a context-aware review can catch:
    • Hidden regressions
    • Incomplete edge handling
    • Misaligned assumptions versus the rest of the codebase

---

How “auggie review” fits with Augment’s broader workflow

Augment is designed to support your full development lifecycle, from prompt to pull request:

• In your IDE (VS Code & JetBrains)

  • Use Augment agents to:
    • Generate and edit code with deep repository awareness
    • Create new files (e.g., src/middleware/rateLimit.ts)
    • Use one-click fixes based on its understanding of your codebase

• In your PRs (GitHub)

  • Automatic checks may run depending on your configuration.
  • auggie review gives you explicit, on-demand review control:
    • Perfect when you want another pass after manual changes
    • Ideal if automated triggers are limited or only run on certain branches

• With your team’s review process

  • Consider adding “Run auggie review” as a checklist item in your PR template for:
    • High-risk changes
    • Critical services
    • Onboarding new engineers who benefit from AI mentorship-style feedback

---

Common issues and troubleshooting

If commenting “auggie review” doesn’t trigger a review, check the following:

1. Is the Augment GitHub app installed and authorized?

• Verify with your repo admin:
  • The Augment app is installed on the correct organization/repository.
  • It has permissions to read PRs and post comments.

2. Are you using the exact trigger phrase?

• Use:

  auggie review
  

• Avoid:
  • Typographical variations (e.g., “augi review”)
  • Hiding the phrase inside code blocks that might not be processed
• To be safe, put it in a normal comment line on the PR conversation.

3. Is the PR in a valid state?

• Confirm that:
  • The PR is open, not closed or merged.
  • There are commits and a visible diff to review.

4. Are there organization-wide restrictions?

• Some teams restrict where Augment runs (e.g., only on certain repos or branches).
• Ask your admin if manual reviews via auggie review are enabled across all projects.

If everything looks correct and the review still doesn’t trigger, your next step is to reach out to your internal Augment owner or Augment support with:

• The repository name
• PR link
• A screenshot or copy of your “auggie review” comment

---

When to re-run “auggie review”

Use repeated manual reviews strategically:

• After major revisions
  If you’ve addressed multiple inline comments or refactored large sections, run auggie review again to:

  • Confirm that fixes are correct
  • Catch any new issues introduced by the changes

• Before merging critical PRs
  Treat it like a final automated safety net:

  • Run tests → fix failures
  • Run auggie review → address critical findings
  • Then request human approval and merge

• While mentoring or pairing remotely
  For junior engineers:

  • Ask them to request an Augment Code Review on their PR via auggie review
  • Use the inline comments as a teaching tool during your own review

---

By commenting “auggie review” on a pull request, you’re explicitly asking Augment’s context-powered reviewer to take a fresh, senior-engineer-style pass over your changes. With inline GitHub comments, full codebase awareness, and one-click fixes in your IDE, this manual trigger gives you precise control over when and how AI review is applied in your workflow.