go-review

Identify Go architecture and style issues across files, packages, and repos.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/kengou/go-guardian --skill go-review-kengou
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: go-review
Source: https://github.com/kengou/go-guardian/tree/main/skills/go-review
Command: npx skills add https://github.com/kengou/go-guardian --skill go-review-kengou

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Go codebases often suffer from architectural erosion, subtle concurrency issues, and inconsistent idiomatic usage as teams evolve. This skill provides structured, multi-dimension reviews that catch these issues across files, packages, and entire repositories, guiding improvements through actionable feedback.

Core Features & Use Cases

  • Automated checks: validate builds and tooling (go build, go vet, golangci-lint) to surface defects early.
  • Multi-dimension review: escalate to team-wide reviews for large changesets to examine security, performance, and architecture.
  • Learning-driven feedback: integrate learned patterns from prior sessions to prevent regressions and improve consistency.
  • Use case: review a new module for architectural boundaries, idiomatic usage, and robust error handling.

Quick Start

Review the provided Go files to identify architecture, concurrency, and style improvements.

Frequently Asked Questions about go-review

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

FAQPage Schema
How do I review Go code for architecture and concurrency issues?

You can review Go code for architecture and concurrency issues by applying a multi-phase workflow with automated checks like go build, go vet, and golangci-lint. This skill identifies structural defects and style inconsistencies across individual files, packages, and whole repositories.

What is the best way to handle large Go changesets during code review?

Handling large Go changesets during code review requires escalating to a parallel multi-dimension review. For changesets exceeding 10 files or 500 lines, this approach examines security, performance, and architecture simultaneously to manage complexity.

When do I need automated checks for idiomatic Go static analysis?

You need automated checks for idiomatic Go static analysis to prevent architectural erosion and catch subtle concurrency issues as teams evolve. Validating builds and tooling with go build, go vet, and golangci-lint surfaces defects early in the development lifecycle.

How do I prevent Go code regressions using learned patterns?

You prevent Go code regressions using learned patterns by loading prior session data into the review workflow. This learning-driven feedback integrates historical patterns to improve consistency and guide architectural boundaries during new module reviews.

Can I use golangci-lint and go vet for whole-repo Go reviews?

Yes, you can use golangci-lint and go vet for whole-repo Go reviews. This skill implements a multi-phase workflow applying these automated checks across individual files, packages, and entire repositories to identify style improvements and robust error handling.