goat-review

Perform two-pass code reviews with blast radius analysis and systemic pattern detection.

Updated Feb 19, 2026
One-click install
npx skills add https://github.com/blundergoat/ambient-scribe --skill goat-review
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: goat-review
Source: https://github.com/blundergoat/ambient-scribe/tree/main/.agents/skills/goat-review
Command: npx skills add https://github.com/blundergoat/ambient-scribe --skill goat-review

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses the lack of depth in standard code reviews by enforcing a structured, two-pass verification process that prevents superficial approvals and ensures systemic issues are identified.

Core Features & Use Cases

  • Two-Pass Discipline: Separates blind suspicion (Pass 1) from grounded verification (Pass 2) to prevent confirmation bias.
  • Blast Radius Analysis: Mandates external call-site verification for contract changes to prevent integration breakages.
  • Systemic Pattern Detection: Automatically groups related findings to identify root causes rather than just symptoms.
  • Use Case: Use this during a complex PR review to ensure that a refactor doesn't silently break downstream consumers or violate established architectural patterns.

Quick Start

Use the goat-review skill to perform a full audit of the current pull request changes.

Frequently Asked Questions about goat-review

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I perform a rigorous code review to catch architectural regressions in a pull request?

A rigorous code review uses a two-pass verification process to prevent superficial approvals and identify systemic issues. This method enforces strict architectural integrity checks on pull request diffs to catch regressions.

What is blast radius analysis in code review and when do I need it?

Blast radius analysis is a code review technique that mandates external call-site verification for contract changes. You need it during refactoring to prevent integration breakages and ensure downstream consumers are not silently affected.

How do I identify systemic root causes instead of individual symptoms during static analysis?

Systemic pattern detection during static analysis automatically groups related findings to identify root causes rather than just symptoms. This ensures your codebase audit addresses underlying architectural flaws instead of isolated defects.

Does this multi-pass code review approach work for branch comparisons and area-specific audits?

Yes, the multi-pass code review approach applies to branch comparisons and area-specific quality assessments. It enforces a structured verification process that prevents confirmation bias and ensures systemic issues are identified across different scopes.

What's the best way to prevent confirmation bias when reviewing complex refactoring changes?

The best way to prevent confirmation bias during refactoring reviews is separating blind suspicion in a first pass from grounded verification in a second pass. This two-pass discipline ensures findings are validated before approval.

Why does standard code review miss integration breakages and how can I prevent them?

Standard code review misses integration breakages because it lacks external call-site verification. You can prevent them by applying blast radius analysis to your pull request diffs, which verifies that contract changes do not break downstream consumers.