component-identification-sizing

Map architectural components and measure size using executable statements and file counts.

Updated Mar 11, 2026
One-click install
npx skills add https://github.com/rafael-hc/AoPonto-FoodService --skill component-identification-sizing-rafael-hc
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: component-identification-sizing
Source: https://github.com/rafael-hc/AoPonto-FoodService/tree/main/.agents/skills/component-identification-sizing
Command: npx skills add https://github.com/rafael-hc/AoPonto-FoodService --skill component-identification-sizing-rafael-hc

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) and scripts (resource) components.

What problem does it solve?

This Skill helps developers understand the structure and size of their codebase by identifying logical components and measuring their complexity, enabling better planning for decomposition and refactoring.

Core Features & Use Cases

  • Component Identification: Automatically detects architectural components based on directory and namespace structures.
  • Size Metrics: Calculates component size using executable statements, files, and percentage of the codebase.
  • Oversized/Undersized Detection: Flags components that are too large or too small based on defined thresholds and standard deviation.
  • Use Case: When planning to break down a monolith, this skill can identify the largest, most complex components that are prime candidates for extraction into microservices.

Quick Start

Use the component identification and sizing skill to analyze all components in the current codebase.

Frequently Asked Questions about component-identification-sizing

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

FAQPage Schema
How do I identify oversized components in a monolith for microservices extraction?

To identify oversized components for microservices extraction, this Skill maps architectural components based on directory structures and measures their size using executable statements and file counts. It flags components that exceed defined thresholds and standard deviation as prime decomposition candidates.

What is the best way to measure codebase component size for refactoring planning?

Measuring codebase component size for refactoring is done by calculating executable statements, file counts, and the percentage of the overall codebase each component occupies. This approach detects oversized and undersized components to guide decomposition efforts accurately.

Does component identification and sizing work with Python and Java project structures?

Yes, component identification and sizing supports Node.js, Java, and Python project structures. It automatically detects architectural components within these environments by analyzing directory and namespace structures to evaluate their complexity.

How do I detect undersized components during codebase analysis?

Detecting undersized components during codebase analysis involves measuring component sizes against defined thresholds and standard deviation. The Skill automatically flags components that are too small, alongside oversized ones, to help balance your software architecture.

When should I use automated component identification for monolith decomposition?

Automated component identification should be used when planning to break down a monolith and needing to understand your codebase structure. It detects logical components and measures their complexity to pinpoint the largest, most complex areas suitable for extraction.