verify-design-a

Evaluate code architecture to surface misdesigns, coupling, and unsuitable abstractions.

1|Updated Jan 25, 2026

Search Tags:#architecture #refactoring #abstraction #code-review #system-design #design-review #dependency-analysis

Ready to run

npx skills add https://github.com/JSai23/claude-tooling --skill verify-design-a

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: verify-design-a
Source: https://github.com/JSai23/claude-tooling/tree/main/plugins/wf/skills/verify-design-a
Command: npx skills add https://github.com/JSai23/claude-tooling --skill verify-design-a

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Evaluates code architecture in hindsight to surface misdesigns, unnecessary complexity, and weak abstractions that hinder maintainability.

Core Features & Use Cases

Architecture questions: type/design fit, module structure, dependencies, and abstractions to justify design choices.
Structured output: Observations, questions, alternatives, and impacts to guide refactors.
Refactor candidacy: Prioritized FROM/TO/TRADEOFF lists for targeted improvements.

Quick Start

Perform an architecture review of your codebase, identifying dependencies, abstractions, and potential refactor candidates.

Frequently Asked Questions about verify-design-a

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

FAQPage Schema

How do I review code architecture to identify misdesigns and weak abstractions?▼

To review code architecture, evaluate module structure, dependencies, and abstractions to surface misdesigns and unnecessary complexity. This process identifies weak design choices and unsuitable abstractions that hinder maintainability, justifying refactoring decisions.

When should I perform an architecture review for refactoring decisions?▼

Perform an architecture review when evaluating code in hindsight to find misdesigns and unnecessary complexity. It is needed when module structure, dependencies, or layer boundaries show coupling or weak abstractions that hinder maintainability and require targeted refactors.

What is the best way to document code review findings for system design?▼

The best way to document code review findings is using a structured format including observations, questions, alternatives, and impacts. This guides refactors by evaluating type and design fit, module structure, and dependencies to justify architectural choices.

How do I prioritize refactoring candidates from a dependency analysis?▼

Prioritize refactoring candidates by generating FROM/TO/TRADEOFF lists from dependency analysis. This targets improvements by evaluating module dependencies and layer boundaries, providing structured observations and impacts to guide your refactoring decisions.

Can I use this architectural review approach across module and layer boundaries?▼

Yes, architectural review applies to scenarios across modules, dependencies, and layer boundaries. It evaluates design fit and abstractions to surface coupling and unnecessary complexity, guiding refactor candidacy with structured observations, questions, alternatives, and impacts.