skills.rest
marcusta
marcustaCOMMUNITY
Explore all skills by this author →
GitHub

complexity-check

Enforce method size, nesting depth, naming conventions, and domain constants in TapScore backend code.

Updated May 25, 2025
Search Tags:#refactoring#backend#complexity#code-quality#naming-conventions#lint
One-click install
npx skills add https://github.com/marcusta/golf-serie --skill complexity-check-marcusta
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: complexity-check
Source: https://github.com/marcusta/golf-serie/tree/main/.claude/skills/complexity-check
Command: npx skills add https://github.com/marcusta/golf-serie --skill complexity-check-marcusta

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Enforce code complexity limits and quality standards in TapScore backend to keep code readable, maintainable, and less prone to bugs as projects scale.

Core Features & Use Cases

  • Enforce method size limits, nesting depth, and naming conventions to prevent complexity creep.
  • Encourage replacing magic numbers with domain constants and improving type safety during development and reviews.
  • Use during code reviews and pair programming to raise code quality and consistency across modules.

Quick Start

Run the complexity-check during code reviews to enforce method size, nesting depth, naming conventions, and constant usage.

Frequently Asked Questions about complexity-check

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

FAQPage Schema
How do I enforce code complexity limits and naming conventions in backend services?▼

Code quality checks enforce method size limits, nesting depth, and naming conventions by flagging violations in service methods and controllers, then providing actionable remediation guidance to keep backend code robust.

What is the best way to check method size and nesting depth during code reviews?▼

Checking method size and nesting depth during code reviews involves running complexity rules against backend tasks to flag violations and encourage replacing magic numbers with domain constants for better type safety.

Can I use complexity checks for refactoring controllers and data access code?▼

Yes, complexity checks apply established quality rules to typical backend tasks like controllers, data access, and refactors across common scenarios, preventing complexity creep and maintaining readable code.

Why does backend code complexity increase as projects scale and how to prevent it?▼

Backend code complexity increases as projects scale due to unchecked method size and deep nesting; you prevent complexity creep by enforcing quality standards and proper domain constant usage during development and pair programming.

Does code linting cover replacing magic numbers with domain constants?▼

Code linting covers replacing magic numbers with domain constants by flagging patterns that violate established complexity rules, encouraging improved type safety and consistency across backend modules during refactoring.

Related Skills

Explore More Software Engineering Skills→
uukuguyuukuguy
1

code-metrics

Calculate complexity, size, coupling, and duplication metrics from source code.

Community
Intermediate
ntaksh42ntaksh42
1

code-smell-detector

Detect code smells and provide refactoring recommendations for software projects.

Community
Intermediate
zapabobzapabob
2

ts-reviewer

Review TypeScript and JavaScript code for type safety and best practices.

Community
Advanced
ysyecustysyecust
40

java-coding-standards

Enforce Java 17+ Spring Boot coding standards for naming, immutability, Optional usage, exceptions, generics, and layouts.

Community
Basic