component-flattening-analysis

Detects misplaced classes and fixes component hierarchy problems — finds code that should belong inside a component but sits at the root level. Use when asking "clean up component structure", "find orphaned classes", "fix module hierarchy", "flatten nested components", or analyzing why namespaces have misplaced code. Do NOT use for dependency analysis (use coupling-analysis) or domain grouping (use domain-identification-grouping).

Quality

69%

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

Fix and improve this skill with Tessl

tessl review fix ./packages/skills-catalog/skills/(architecture)/component-flattening-analysis/SKILL.md

Quality

Content

46%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 comprehensive and provides executable detection code, but it is heavily overlong, repeats the same examples across many sections, inlines content that belongs in reference files, and lacks explicit validation feedback loops for its destructive refactoring steps. The main drags on the score are conciseness and progressive disclosure.

Suggestions

Cut the body substantially: state each definition and the ss.survey tree example once, and remove the duplicated trees across Core Concepts, Analysis Process, Implementation Notes, and Common Patterns — Claude already understands directory/namespace hierarchies.

Extract the large reference-style blocks (language-specific Implementation Notes, the JavaScript fitness functions, the full Output Format templates) into reference files and link to them one level deep, turning SKILL.md into a concise overview.

Add an explicit validation feedback loop to the refactor workflow: after Phase 5 verify, re-run the fitness functions / tests, and only mark complete when zero violations are returned — fix-and-revalidate before proceeding.

Dimension	Reasoning	Score
Conciseness	The ~690-line body is noticeably verbose: it restates the same definitions, examples, and tree diagrams multiple times (e.g., the ss.survey tree appears repeatedly across Core Concepts, Analysis Process, Implementation Notes, and Common Patterns), and explains component/leaf-node concepts at length that Claude already knows.	2 / 5
Actionability	Provides mostly executable guidance including concrete detection and fitness-function code (findRootNamespacesWithCode, findOrphanedClasses, validateComponentStructure) and specific flattening steps, with only minor gaps around how the namespace/file maps are actually built from a real codebase.	4 / 5
Workflow Clarity	The five phases give a clear sequence, but the destructive/batch refactoring (moving files, updating imports) lacks explicit validate-then-fix feedback loops — Phase 5 'Verify Changes' is a light checklist rather than a re-run-validation-and-stop-if-failing gate, which caps clarity at 3.	3 / 5
Progressive Disclosure	This is a monolithic single-file skill with no bundle files or references; large blocks that clearly belong in separate references (the repeated tree-diagram examples, fitness-function implementations, language-specific Implementation Notes) are inlined rather than split out, making navigation heavy.	2 / 5
	Total	11 / 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.

A high-quality description: third-person voice, concrete actions, explicit Use-when triggers, and explicit boundary guidance against sibling skills. It is somewhat verbose and the trigger phrases are quoted as literals rather than natural synonyms, which keeps trigger_term_quality just off the top anchor.

Dimension	Reasoning	Score
Specificity	Lists multiple concrete actions ('Detects misplaced classes', 'fixes component hierarchy problems', 'finds code that should belong inside a component but sits at the root level') with comprehensive coverage of what the skill does.	5 / 5
Completeness	Explicitly answers both what ('Detects misplaced classes and fixes component hierarchy problems') and when (a dedicated 'Use when asking...' clause with concrete triggers), satisfying both halves clearly.	5 / 5
Trigger Term Quality	Strong natural trigger phrases ('clean up component structure', 'find orphaned classes', 'fix module hierarchy', 'flatten nested components') a user would plausibly say, but they are quoted as literal phrases rather than woven as natural synonyms, leaving a few variations missing.	4 / 5
Distinctiveness Conflict Risk	A clear niche reinforced by explicit 'Do NOT use for dependency analysis (use coupling-analysis) or domain grouping' boundary guidance, minimizing conflict risk with adjacent skills.	5 / 5
	Total	19 / 20 Passed

Validation

93%

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 — 15 / 16 Passed

Validation for skill structure

Criteria	Description	Result
skill_md_line_count	SKILL.md is long (694 lines); consider splitting into references/ and linking	Warning

	Total	15 / 16 Passed

Repository: tech-leads-club/agent-skills
Path: packages/skills-catalog/skills/(architecture)/component-flattening-analysis/SKILL.md
Commit: fc886b7

Reviewed: 4 days 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.