requesting-code-review

Dispatch a code-reviewer subagent with precisely scoped context (git SHAs, task description, requirements) to review a diff and return Critical, Important, and Minor findings. Use after delivery-flow finishes implementing and verifying a task, before merging to main. This is the internal code-review stage of the delivery-flow workflow. It is not a standalone entry point, so do not activate it directly for a one-off "review this PR" or "review my code" request; use delivery-flow for those instead.

Quality

92%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Quality

Content

92%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

The body is a lean, actionable orchestration guide: executable git commands, a clearly signaled one-level-deep template reference, a numbered workflow with explicit feedback triage, and well-organized sections. Its only real slack is mild verbosity in the example dialogue and rationalizations table.

Suggestions

Tighten the Example section: replace the dialogue transcript with just the filled-in dispatch fields (DESCRIPTION, PLAN_OR_REQUIREMENTS, BASE_SHA, HEAD_SHA) and the returned findings, dropping the "You: ..." narration.

Compress the Common Rationalizations table's Reality column to one short clause each (e.g. "Inline review burns coordinator context; only findings should come back").

Dimension	Reasoning	Score
Conciseness	The body is efficient with no explanations of concepts Claude already knows; every section drives action. Not a 5: the dialogue-style Example walkthrough and the long "Reality" cells in the Common Rationalizations table (e.g. "You're the coordinator — reviewing the diff inline burns the context window...") carry padding that could be tightened without losing guidance.	4 / 5
Actionability	Copy-paste ready commands ("BASE_SHA=$(git rev-parse HEAD~1)", "HEAD_SHA=$(git rev-parse HEAD)"), a concrete dispatch instruction pointing to the real template at references/code-reviewer.md with all four placeholders defined, and a worked example with actual SHA values. Not a 4: no gaps remain — the common case is fully executable end to end.	5 / 5
Workflow Clarity	A clear three-step sequence (get SHAs → dispatch reviewer → act on feedback) with an explicit severity-triage checkpoint ("Fix Critical issues immediately", "Fix Important issues before proceeding") and an error-recovery loop ("Push back if reviewer is wrong (with reasoning)", "Show code/tests that prove it works"). Not a 4: validation checkpoints and feedback loops are explicit, and this review skill is not a destructive/batch operation so no cap applies.	5 / 5
Progressive Disclosure	The body is a well-sectioned ~90-line overview that keeps the 181-line bulk prompt template in references/code-reviewer.md, a real file referenced one level deep and clearly signaled both in the dispatch step and at the end. Not a 4: content is appropriately split and navigation is easy; the only nit is the duplicate link to the same reference, which does not impair navigation.	5 / 5
	Total	19 / 20 Passed

Description

92%Weight 40%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

The description is specific, complete, and highly distinctive: it names concrete actions, an explicit use-timing clause, an output taxonomy, and explicit boundary guidance against standalone-review conflicts. Its only weakness is that the most natural user phrases are named as exclusions rather than triggers, slightly weakening raw trigger-term alignment.

Dimension	Reasoning	Score
Specificity	"Dispatch a code-reviewer subagent with precisely scoped context (git SHAs, task description, requirements) to review a diff and return Critical, Important, and Minor findings" lists multiple concrete actions with a complete output taxonomy. Not a 4: coverage is comprehensive for this workflow's scope with no minor gaps in what the skill does.	5 / 5
Completeness	Explicitly answers both: what ("Dispatch a code-reviewer subagent... to review a diff and return Critical, Important, and Minor findings") and when ("Use after delivery-flow finishes implementing and verifying a task, before merging to main") with concrete timing. Not a 4: the when-clause is fully explicit, not vague or merely implied.	5 / 5
Trigger Term Quality	Good natural keyword coverage — "code review", "review a diff", "merging to main", "delivery-flow" — including synonyms. Not a 5: the most natural user-entry phrases ("review this PR", "review my code") appear only as explicit exclusions, so a couple of natural trigger terms are effectively routed away from this skill.	4 / 5
Distinctiveness Conflict Risk	Occupies a clear niche ("internal code-review stage of the delivery-flow workflow") and actively steers conflicting triggers away ("do not activate it directly for a one-off 'review this PR'... use delivery-flow instead"). Not a 4: it does more than avoid overlap — it explicitly resolves the conflict with standalone review skills.	5 / 5
	Total	19 / 20 Passed

Validation

100%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 16 / 16 Passed

Validation for skill structure

No warnings or errors.

Repository: tesslio/tessl-eval-demo
Path: plugins/sdlc-assurance/skills/requesting-code-review/SKILL.md
Commit: 6e100ef

Reviewed: 1 day ago

Table of Contents

Discovery Implementation Validation

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.