evaluate

Summarize code changes and quiz developers on design decisions.

1|Updated Jan 6, 2026
One-click install
npx skills add https://github.com/Levezze/devkit --skill evaluate-levezze
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: evaluate
Source: https://github.com/Levezze/devkit/tree/main/skills/evaluate
Command: npx skills add https://github.com/Levezze/devkit --skill evaluate-levezze

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It helps you reliably understand and validate an implementation after you finish work, by turning “what changed” into a clear summary and then testing your grasp of the key design decisions and tradeoffs.

Core Features & Use Cases

  • Post-implementation summary: Produces a structured recap covering what was built, how the pieces connect, which files changed, and the key non-obvious decisions.
  • Implementation quiz: Asks 5–7 focused, one-at-a-time questions grounded in the relevant code snippets to surface risks, gaps, and coupling or error-path concerns.
  • Workflow-aware scoping: Determines the scope using git diffs/logs relative to a base branch, or prompts for the base branch / file pointers when git context is missing.

Quick Start

Use the evaluate skill after finishing a feature so it can summarize your changes and quiz you on the design decisions and tradeoffs.

Frequently Asked Questions about evaluate

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

FAQPage Schema
How do I review my git diff to understand design tradeoffs after finishing a feature?

A post-implementation review validates your understanding of completed code changes by summarizing the architecture and testing your grasp of key decisions. It reads modified files from your git diff, presents a file-tree context summary, and sequentially asks focused questions to surface risks, gaps, and coupling concerns.

Can I do a post-implementation review on standalone files without a git repository?

A post-implementation review works by determining scope from git diffs or user-provided file pointers, reading the modified files, and presenting a structured summary. It then sequentially asks 5-7 quiz questions grounded in code snippets to probe your understanding of error paths and design tradeoffs without producing a written artifact.

What is the best way to test my knowledge of architecture decisions after a TDD cycle?

Running a post-implementation review requires no dependencies, but needs completed code changes and either a git-backed branch or standalone file pointers. The evaluate skill uses this input to determine the scope, read modified files, and generate the structured summary and sequential quiz questions.

Does a post-implementation review generate a written report of the code review?

No, a post-implementation review does not generate a written report or artifact. The evaluate skill focuses on interactive validation by presenting a structured architecture summary and asking 5-7 sequential quiz questions to probe your understanding, concluding with a final wrap-up instead of outputting a file.