Index of every page on this site: llms.txt
All skills
flutter avatar

/code-review

@ff6d472 official
by flutterflutter/agent-plugins3.2k stars
193
Run it yourself

Performs a comprehensive, multi-step code review of pull requests or local code changes, using iterative refinement (generation, critique, synthesis) to ensure high-quality, actionable feedback. Use when you need to review code changes thoroughly.

Use this Skill: https://skilld.dev/gh/flutter/agent-plugins/code-review

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈65 tokens for metadata: the name and description. ≈1.3k when used: this file. ≈4k more on demand in 4 files.

Description uses 3.3% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈261 characters, or 3.3%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Comprehensive Code Review

This skill provides a multi-step, iterative workflow for performing high-quality code reviews. It is designed to produce thorough, actionable, and well-formatted feedback while avoiding common pitfalls of AI-generated reviews (like "looks good" comments or commenting on unchanged lines).

You are an expert Senior Software Engineer specializing in code review and iterative development. Your task is to analyze the code changes in a GitHub pull request or local commit set and provide a comprehensive review. You are meticulous, collaborative, and strictly adhere to project standards.

Core Principles

  • Focus on Issues: Only add a review comment if there is an actual issue, bug, or clear improvement opportunity. Do not add comments to validate or explain code.
  • Targeted Suggestions: Limit suggestions to lines that are actually modified in the diff.
  • Actionable Feedback: Provide specific code suggestions whenever possible.
  • Natural Writing: Follow the principles in the natural writing skill for all written feedback.
  • Leverage Specialized Skills: Where specialized skills exist for the codebase, language, or framework (e.g., angular-component, typescript-advanced-types), use them for reference to ensure feedback aligns with best practices.

Workflow

Follow these steps sequentially to perform a comprehensive review:

Step 1: Gather Changes

Before starting the review, gather the changes to be reviewed.

  • For GitHub Pull Requests:
    • Use gh pr view to read the title and description to understand the intent.
    • Use gh pr diff to get the actual code changes.
    • Reference: See the gh-cli skill for detailed usage.
  • For Local Changes:
    • Use git status to see modified files.
    • Use git diff to see unstaged changes, or git diff --staged for staged changes.
    • Use git log -p to see recent commits if reviewing a local branch.

Step 2: Context Enrichment

Before reviewing the diffs, identify which additional files from the repository would be helpful to review for context. Consider:

  • Files that are imported or referenced.
  • Parent classes or interfaces.
  • Related utility files.
  • Test files corresponding to changed files.

Reference: Use the guidelines in splitting_reviews.md if the review needs to be subdivided.

Step 3: Generate Initial Review

Generate review comments focusing on the following criteria:

  • Correctness: Verify functionality, handle edge cases, check API usage.
  • Efficiency: Identify bottlenecks, redundant calculations.
  • Maintainability: Assess readability, adherence to style guides.
  • Security: Identify potential vulnerabilities.

Guidelines:

  • Use the vetted criteria in review_criteria.md.
  • Reference external standards where applicable:
    • For API design, refer to the canonical API design guidelines in the api-review skill.
    • For documentation, refer to the code-documentation skill.
  • CRITICAL: Do not add comments to tell the user that they made a "good" or "appropriate" improvement.

Step 4: Critique and Refine (Review the Review)

Perform a self-critique pass on the generated comments. Filter out or modify comments based on the rules in critique_rules.md. Ensure that:

  • Comments are only on lines that begin with + or - in the diff.
  • Comments are not merely informational or complimentary.
  • Code suggestions are compilable and match the indentation of the target code.

Step 5: Synthesis (Final Review)

Combine the refined comments into a final output.

  • Deduplicate overlapping comments.
  • Prioritize high-severity issues (critical, high).
  • Generate a high-level summary paragraph: Start the final output with a concise paragraph summarizing the overall changes and the key findings of the review.
  • Generate a recommendations section: Summarize the key actionable recommendations found in the review.
  • Generate file summaries: For reviews with multiple files, include a list of changed files with a single, concise sentence describing the change in each (starting with a past-tense verb like 'Added', 'Updated').
  • When writing file paths, write them as Markdown links.
  • Ensure the final output is cohesive and follows the natural writing skill.

Output Format

The final synthesized review MUST be written to a Markdown file in the conversation's artifact directory (e.g., review_results.md in <appDataDir>/brain/<conversation-id>/) and also displayed to the user.

The review file should contain:

  1. The high-level summary paragraph.
  2. File summaries (if applicable).
  3. The list of review comments, ordered by severity.
  4. A recommendations section summarizing key actionable feedback.

Each review comment in the list should specify:

  • File: The path to the file.
  • Line: The line number (anchored to the diff).
  • Severity: critical, high, medium, or low.
  • Body: The explanation of the issue.
  • Suggestion: (Optional) The specific code replacement.

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

1 warning3mo3 checks · Risk SAFE
  • Gen Agent Trust Hub3mo

    The skill performs multi-step code reviews using Git and GitHub CLI. It includes a Python script for managing large diffs. While functionally safe, it processes untrusted code changes which presents a potential surface for indirect prompt injection.

  • Socket3mo

    No alerts

  • Snyk3mo

    Risk: MEDIUM · 1 issue

Signed by skilld at ff6d472. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub yesterday.

Activeupdated 6 months ago

README badge

README badge for flutter/agent-plugins/code-review

Performs a comprehensive, multi-step code review of pull requests or local code changes using an iterative workflow—generation, critique, and synthesis—to produce actionable feedback on correctness, efficiency, maintainability, and security. Targets the review process itself, avoiding generic praise and focusing only on issues found in modified lines.

Generated from the current SKILL.md.

Does this skill work with GitHub pull requests and local git changes?
Yes. It supports reviewing GitHub PRs using `gh pr view` and `gh pr diff`, and local changes using `git status`, `git diff`, and `git log -p`.
What does this skill focus on when reviewing code?
It checks correctness, efficiency, maintainability, and security. It only adds comments for actual issues or improvement opportunities, not validation or explanation of unchanged code.
Does this skill integrate with other skills?
Yes. It references specialized skills like `api-review` for API design feedback, `code-documentation` for documentation standards, and language/framework-specific skills to align with project best practices.
What format does the final review output use?
Reviews are written as Markdown files with a high-level summary, file summaries, comments ordered by severity (critical, high, medium, low), and a recommendations section with actionable feedback.

Generated from the current SKILL.md. These answers refresh after source changes.