PR

pr-readiness-review

Final quality gate for verifying PR readiness before submission.

Install

mkdir -p .claude/skills/pr-readiness-review && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/10415" && unzip -o skill.zip -d .claude/skills/pr-readiness-review && rm skill.zip

Installs to .claude/skills/pr-readiness-review

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Performs a comprehensive pre-PR readiness review covering tests, code quality, security, and commit conventions. Use at the end of implementation before submitting a pull request.
179 charsno explicit “when” trigger
Intermediate

Key capabilities

  • →Validate test coverage
  • →Review code quality and YARD docs
  • →Verify Git documentation compliance
  • →Check commit message format
  • →Generate PR summary

How it works

It performs a multi-point inspection of tests, code, documentation, and commit history to ensure a merge-ready state.

Inputs & outputs

You give it
Implementation completion status
You get back
PR readiness report

When to use pr-readiness-review

  • →Final review before opening PR
  • →Validating testing coverage
  • →Ensuring commit quality

About this skill

PR Readiness Review Workflow

Use this at the end of implementation to prepare for PR submission. Example request:

I've completed the implementation. Please perform a comprehensive PR readiness review.

Contents

How to use this skill

Attach this file to your Copilot Chat context, then invoke it after implementation is complete and before opening a pull request. This workflow is a final quality gate and reporting template.

Prerequisites

Before starting, you MUST load the following skill(s) in their entirety:

  • YARD Documentation — authoritative source for YARD formatting rules and writing standards;

Related skills

1. Run Final Validation

Execute and report results for:

  • bundle exec rake default - all tests and linters must pass
  • Check test output for any Ruby warnings

2. Verify Testing Quality

Unit Tests (Critical):

  • 100% coverage of all changed code - every branch, edge case, error condition
  • All external dependencies properly mocked (execution_context, git commands)
  • Each test verifies one specific behavior
  • Comprehensive coverage: success paths, failures, edge cases, error handling
  • Test only through public interfaces (the rule on testing only through the public interface in the RSpec base standards)
  • Apply the RSpec Unit Testing Standards in full to every new or modified unit spec; the checks above are the ones most often missed, not the whole list

Integration Tests (Essential Only):

  • Apply the RSpec Integration Testing Standards in full to every new or modified integration spec. Its changes most often missed are the bullets named Exact values, Error patterns, Pinning git, Starting git, and No sleep, and the plugin rule most often missed is the one against covering a conditional path a unit spec covers. Check those first, from the skill itself rather than from memory.

Command Tests (if any Git::Commands::* specs are included):

  • Apply the Command Test Conventions skill to every new or modified unit and integration spec file for command classes. Resolve all findings before proceeding.

3. Review Code Quality

  • YARD documentation complete for all public methods/classes
  • Include @api public or @api private tags appropriately
  • Usage examples in YARD docs show common patterns
  • Command YARD Docs (if any Git::Commands::* source files are included): Apply the Command YARD Documentation skill to every new or modified command source file. Resolve all findings before proceeding.
  • No breaking changes (or properly marked with ! in commits)
  • Cross-platform compatible on all supported OSes; any platform-specific logic is properly guarded and tested
  • No security issues (command injection, path traversal, etc.)
  • Uses Arguments DSL for building git commands

4. Verify Against Git Documentation

  • Determine the repository's minimum supported Git version from project metadata
  • Read version-matched upstream documentation for the implemented command
  • Inspect version-matched upstream source when docs are ambiguous about exact option forms
  • Use local git <command> -h output only as a supplemental check for the installed Git
  • Confirm all documented options are considered
  • All edge cases from git documentation are tested
  • Error handling matches git's actual behavior
  • Exit codes handled correctly (especially partial failures)

5. Check Commit Quality

  • All commits follow Conventional Commits format: type: description
  • Description is lowercase, no ending period, under 100 chars
  • Valid types: feat, fix, docs, test, refactor, chore, perf, build, ci, style, revert
  • Breaking changes marked with ! and include BREAKING CHANGE: footer
  • Each commit is atomic and has a clear purpose

6. Review Documentation

  • If a new pattern was introduced, the skill that documents that pattern is updated in the same PR (.github/skills/)
  • README.md updated if public API changed
  • Examples are clear and demonstrate common use cases
  • All @param, @return, @raise tags are accurate
  • Skill docs (if any .github/skills/** files are included): Apply the Reviewing Skills skill to every new or modified skill. Verify TOC anchors, relative links, cross-skill deep links, referenced files, and any stated inheritance/override relationships.

7. Verify Branch Placement

Before creating the PR, confirm the branch situation:

  • Changes are on a feature branch (not main or 5.x), named <type>/<short-description>
  • Branch targets the correct base: main for features/breaking changes; 5.x for backports of fixes already on main that pass the rescue-compatibility test in Branch & PR Strategy, and for security fixes and backward-compatible changes that apply only to that series

If changes are on the wrong branch: Create a new branch from the appropriate base (origin/main or origin/5.x) and relocate the existing work using the most appropriate Git approach — cherry-pick (specific commits), rebase (linear history), or recommit (uncommitted changes) — based on the situation.

8. Generate PR Summary

Provide a comprehensive report with:

Implementation Summary:

  • What was implemented and why
  • Key design decisions made
  • Any trade-offs or limitations

Test Coverage:

  • Unit tests: X examples covering Y scenarios
  • Integration tests: Z examples validating specific git interactions
  • Coverage: 100% of changed lines (or explain gaps)
  • Edge cases tested: [list critical ones]

Quality Verification:

  • ✅ Items that passed all checks
  • ⚠️ Items that need attention (if any)
  • Reference to relevant documentation verified

Suggested PR Materials:

  • PR Title: type: clear description of change
  • PR Description draft including:
    • Summary of changes
    • Why this change is needed
    • Test coverage details
    • Breaking changes (if any)
    • Checklist from .github/pull_request_template.md

PR Body Editing Safety:

  • The terminal tool mangles multi-line markdown (backticks, asterisks, newlines) in any shell command, including heredocs. Always write the PR body using the create_file tool (the VS Code Copilot agent tool that writes file content directly, bypassing the terminal entirely), then reference the file:
    • gh pr create --body-file <path> when opening
    • gh pr edit <number> --body-file <path> when updating
  • Never use inline --body "..." or cat > file << 'EOF' heredocs for PR bodies
  • After any body update, verify the stored text with:
    • gh pr view <number> --json body --jq '.body'
  • If the body is garbled, rewrite the file with create_file and re-run gh pr edit

Next Steps:

  • Any remaining items to address before PR submission
  • Confirmation that all checklist items are complete
  • Make sure to create a feature branch for the PR -- never push directly to main

When not to use it

  • →Early implementation stages

Prerequisites

YARD Documentation skill

Limitations

  • →Requires external skill dependencies

How it compares

This acts as a final quality gate using a standardized checklist, rather than relying on informal self-review.

Compared to similar skills

pr-readiness-review side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
pr-readiness-review (this skill)06moReviewIntermediate
dependency-upgrade268moReviewIntermediate
finishing-a-development-branch46moReviewBeginner
positron-pr-helper16moReviewBeginner

Try saying

Example prompts that trigger this skill in your AI assistant.

Search skills

Search the agent skills registry