post-implementation-review

Reviews completed implementation work for dead paths, stale imports, invariant ownership, and API shape.

4.8k|376|Updated Mar 16, 2023
One-click install
npx skills add https://github.com/EpicenterHQ/epicenter --skill post-implementation-review
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: post-implementation-review
Source: https://github.com/EpicenterHQ/epicenter/tree/main/.agents/skills/post-implementation-review
Command: npx skills add https://github.com/EpicenterHQ/epicenter --skill post-implementation-review

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

After finishing an implementation, code often contains stale abstractions, dead exports, misleading names, and misplaced invariants that slip through the initial pass. This Skill performs a disciplined second read of all touched files to catch these issues while the edit context is still fresh.

Core Features & Use Cases

  • Structured Review Passes: Runs first-read, mental inlining, ownership-and-collapse, smell, and invariant audits over every touched file, with an ASCII tree of files read as evidence.
  • Scoped Lane Discipline: Separates findings into fix-now, report-only, and pause categories so speculative or cosmetic cleanup never gets silently mixed into grounded fixes.
  • Focused Skill Delegation: Escalates to focused skills (refactoring, code-audit, typescript, svelte, yjs, testing) only when the touched surface matches.
  • Use Case: After implementing a new feature across several TypeScript modules, run this Skill to re-read each file, flag a one-caller wrapper that should be inlined, delete stale imports, and verify diagnostics before committing.

Quick Start

Review the implementation I just completed for dead paths, stale imports, ownership issues, and API shape, then report findings before making any cleanup edits.

Frequently Asked Questions about post-implementation-review

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

FAQPage Schema
How do I review code after implementing a feature?

Re-read every touched file top to bottom, list them as an ASCII tree, then run structured passes: first-read, mental inlining, ownership checks, smell detection, and invariant audit. Report findings before making cleanup edits unless the issue is a direct compile or test failure.

What should a post-implementation code review check for?

Check for dead exports and methods, stale imports and JSDoc, identity wrappers, one-caller abstractions, redundant safety checks, misleading names, and old API shapes left alive alongside new ones. Each abstraction should be marked as earning its keep, inlineable, wrongly owned, or misnamed.

When should cleanup edits be made during a code review?

Fix immediately only grounded correctness, invariant, public API, verification, and serious clarity issues on the touched path. Report speculative or cosmetic cleanup separately, and pause on explicit user limits, product direction, destructive actions, or unclear ownership.

How do I decide whether to inline a helper or wrapper function?

Count its callers and mentally inline it into call sites. Keep the layer only if it owns a lifecycle, an unsafe parse or network boundary, a repeated domain operation, a public contract, or a long imperative block whose name explains the phase.

Does this review approach work with TypeScript and Svelte projects?

Yes, it includes checks specific to TypeScript type organization, Go-to-Definition hop counts, Svelte components and runes, and Yjs CRDT documents. It delegates to focused skills for those surfaces when the touched files match.