end-of-turn-review

Review code diffs and implementation plans for correctness and regressions.

1|Updated Apr 27, 2026
One-click install
npx skills add https://github.com/darkmatter/skills --skill end-of-turn-review
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: end-of-turn-review
Source: https://github.com/darkmatter/skills/tree/main/skills/end-of-turn-review
Command: npx skills add https://github.com/darkmatter/skills --skill end-of-turn-review

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires bash, git, grep, jq, curl, and includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill adds a second-opinion review pass over newly produced work so you can catch bugs, regressions, unsafe assumptions, and weak plans before they reach a commit or a follow-up turn.

Core Features & Use Cases

  • Diff critique: Reviews non-trivial code changes and returns a verdict with specific issues and file references.
  • Plan critique: Evaluates proposed implementation plans for hidden dependencies, missing failure handling, and load-bearing mistakes.
  • Hook-based workflow: Fits end-of-turn automation, pre-commit checks, and explicit review requests without editing the work itself.

Quick Start

Ask the assistant to run the end-of-turn-review skill on the latest diff or plan before you commit.

Frequently Asked Questions about end-of-turn-review

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

FAQPage Schema
How do I automate code review for a git diff before committing?

Automating code review for a git diff requires a hook-based script that evaluates newly produced changes for correctness and edge cases. This process applies end-of-turn review passes to your working tree, returning structured verdicts with specific issues and file references before you finalize a commit.

What is plan critique in software engineering and when do I need it?

Plan critique is the evaluation of proposed implementation plans for hidden dependencies, missing failure handling, and load-bearing mistakes. You need this second-opinion review pass before executing a plan to catch weak assumptions, bugs, and regressions early in the design phase.

Do I need LiteLLM to run automated LLM reviewer scripts?

Yes, you need LiteLLM to access the reviewer model for automated LLM reviewer scripts. The workflow requires a git working tree, shell-based hook execution via bash, and LiteLLM connectivity to generate structured verdict outputs from the code diff analysis.

Can I use bash scripts and git hooks for pre-commit code review checks?

Yes, you can use bash scripts and git hooks for pre-commit code review checks. This approach fits end-of-turn automation by running shell-based scripts over your working tree to catch regressions and unsafe assumptions without directly editing the work itself.

What's the best way to catch regressions and broken assumptions in new code?

The best way to catch regressions and broken assumptions is applying a second-opinion review pass over newly produced work. By analyzing non-trivial code changes through a reviewer model, you get a structured verdict highlighting specific issues and file references before they reach a commit.

What are the limitations of using shell scripts for diff analysis?

Limitations of using shell scripts for diff analysis include dependencies on a git working tree and external tools like grep, jq, and curl. The process requires shell-based hook execution access and cannot review changes outside the current working tree or without LiteLLM model connectivity.