taste-reviewer

Identify code shape issues and pair findings with costed recommendations.

11|1|Updated Mar 3, 2026
One-click install
npx skills add https://github.com/ylxmf2005/AgentCorp --skill taste-reviewer-ylxmf2005
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: taste-reviewer
Source: https://github.com/ylxmf2005/AgentCorp/tree/main/agentcorp/taste-reviewer
Command: npx skills add https://github.com/ylxmf2005/AgentCorp --skill taste-reviewer-ylxmf2005

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Taste Reviewer provides structured, costed feedback on whether code changes are shaped correctly, not just functional.

Core Features & Use Cases

  • Honest shape judgments: identify where a change is hacky, misaligned with the model, or misnamed, and propose the right abstraction.
  • Costed findings: pair each finding with the honest shape and the price in effort or risk implications.
  • Traceable review flow: connects findings to evidence and downstream implications across API surfaces, tests, and design.

Quick Start

Run Taste Reviewer on the proposed change to generate a set of findings with recommended shape improvements and costs.

Frequently Asked Questions about taste-reviewer

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

FAQPage Schema
How can I check if my code changes have the right design shape and abstraction boundaries during a code review?

To check code changes for proper design shape and abstraction boundaries, you can use a taste review process that judges whether the code is merely functional or correctly shaped. It surfaces findings with concrete recommendations on naming, API surfaces, and model alignment.

What is a costed finding in software engineering code review and why does it matter?

A costed finding in code review pairs a design issue with its honest shape and the concrete price in effort or risk. It matters because it enforces traceable evidence linking API surfaces and abstraction boundaries to downstream implications.

How do I review API surfaces and naming conventions to ensure they are not hacky or misaligned?

Reviewing API surfaces and naming conventions involves identifying where a change is hacky or misnamed and proposing the right abstraction. A structured taste review connects these findings to evidence and downstream design implications during review lanes.

Can I get automated recommendations for improving misaligned abstractions and design boundaries in my code?

You can get recommendations for improving misaligned abstractions by running a taste review on proposed changes. It generates findings that include the honest shape, proposed abstraction improvements, and the cost implications of the effort or risk involved.

When should I use a taste review instead of a standard functional code review?

You should use a taste review instead of a standard functional review when you need to judge if changes are properly shaped rather than merely working. It enforces that findings include the honest shape, a concrete price, and evidence linking to code changes.

Does taste review work with existing software engineering review lanes to trace design implications?

Taste review works across code review workflows to judge design, naming, abstraction boundaries, and API surfaces during review lanes. It enforces a traceable flow by connecting findings to evidence and downstream implications across tests and design.