code-checker_skill

Overview

This skill scans C and C++ codebases to find maintainability problems like oversized files and functions and circular dependencies between modules. It supports scanning single files or entire directories with configurable thresholds and can output a concise report. Use it to prioritize refactors and quickly spot code smells that increase technical debt.

How this skill works

The scanner counts effective lines (excluding blanks, comments, and preprocessor lines) to flag files and functions that exceed configurable thresholds. It also parses include relationships and GN build files to group code into directory modules and detect circular include chains. Results are presented as a report with prioritized findings and optional output file support.

When to use it

• You want to find files or functions that are too large to maintain or test easily.
• You suspect or want to prevent circular dependencies between directory-level modules.
• Before a major refactor to identify high-impact targets.
• During code health reviews or CI checks to enforce maintainability thresholds.
• When onboarding to understand hotspots in a legacy C/C++ codebase.

Best practices

• Start with default thresholds (files: 2000 effective lines, functions: 50 effective lines) and tune for your codebase.
• Scan whole directories for module-level dependency analysis; scan single files for quick size checks.
• Prioritize fixes by impact: largest files/functions and cycles that block modularization.
• Use verbose or output-file options to generate artifacts for code-review and tracking.
• Combine results with manual code reading before applying refactors; automated rules guide but don’t replace context.

Example use cases

• Run a full project scan to produce a size_report.md and circular_report.md before a release.
• Check a suspicious file to see if any functions exceed the configured function threshold.
• Detect and visualize circular header dependencies that prevent safe modularization.
• Integrate size checks into CI to fail builds when new code introduces oversized functions.
• Triage a legacy module by listing largest files and functions to create a phased refactor plan.