Results for “complexity”

Measures cyclomatic complexity, cognitive complexity, and function length across codebases to identify maintenance hotspots. Use when someone asks about code complexity, function length analysis, maintainability metrics, or needs to find the most complex parts of their codebase. Trigger words: complexity, cyclomatic, cognitive complexity, long functions, hotspots, maintainability index, code metrics.

The English summary is being prepared. Showing the original description.

Analyze a software codebase for algorithmic complexity and performance hotspots, then propose or implement safe optimizations without breaking behavior. Use when Codex is asked to scan many files, find inefficient loops, nested iteration, repeated scans, costly rendering/recomputation, N+1 queries, avoidable O(n^2) or O(n) operations, or reduce complexity such as O(n^2) to O(n log n) / O(n), while preserving tests, APIs, outputs, and maintainability.

The English summary is being prepared. Showing the original description.

Makes working code easier to read and change without altering what it does, and proves the behaviour stayed the same. Use when someone says "simplify this", "clean up this function", "this file is a mess", "reduce the complexity", "refactor for readability", "tidy my diff before the PR", or when a linter reports high cyclomatic complexity or deep nesting. Covers pinning current behaviour with characterization tests, measuring complexity, choosing a named refactoring, applying it in small verified steps, and reporting suspected bugs found on the way instead of fixing them silently.

The English summary is being prepared. Showing the original description.

Domain-aware complexity routing. Scans task description for domain keywords, matches against domain-complexity.csv, returns complexity level, workflow intensity, and execution tier. Extends Phase 0 orchestration.

The English summary is being prepared. Showing the original description.

Refactor given method `${input:methodName}` to reduce its cognitive complexity to `${input:complexityThreshold}` or below, by extracting helper methods. Use when a method exceeds a cognitive-complexity threshold flagged by a linter or review.

The English summary is being prepared. Showing the original description.

Measure and audit C/C++ code size, namespace distribution, function complexity, nesting, recurrence, and namespace coupling in the EMULATORS framework. Use when Codex needs codebase statistics, complexity baselines, namespace comparisons, duplication indicators, hotspots, architectural growth analysis, or before/after complexity reports while excluding third-party code.

The English summary is being prepared. Showing the original description.

Use when the operator says "preview complexity advisor", "complexity diagnosis" or "intrinsic complexity attestation".

The English summary is being prepared. Showing the original description.

Assess code change risk, locate complex areas, and inspect file statistics with ruflo analysis commands. The skill also guides running and extending ruflo’s regression guards, automated checks that help catch previously fixed problems.

• Assessing risk before reviewing a code change
• Finding complex code that needs attention
• Running ruflo regression guards locally

Screen compound libraries for drug discovery using drug-likeness guidelines, structural alerts that flag patterns for review, and molecular complexity measures. Combine criteria to shortlist candidates and retain filtering results with reasons for further assessment.

• Screen compound libraries with drug-likeness rules
• Flag PAINS and other structures for review
• Combine property, structure, and complexity filters

Review code for security, performance, quality, and maintainability. Get findings organized by severity, with file locations, explanations of impact, and example fixes, plus code metrics and complexity comparisons for refactoring reviews.

• Reviewing a pull request before merging
• Checking code for security risks
• Finding performance improvement opportunities

Simplify code once its behavior is understood. Confirm the existing behavior through tests or reproduction, reduce unnecessary complexity in small, reviewable steps, and keep verification passing while preserving behavior and necessary safety checks.

• Making code easier to read without changing behavior
• Reducing complexity after confirming existing behavior
• Reviewing cleanup changes in small steps

Choose a web application stack, generate a starter project, and assess existing code quality. Uses team size, release frequency, audience, and budget to guide recommendations, with reports covering security, complexity, dependencies, and prioritized improvements.

• Generating a starter project for a web application
• Choosing a technology stack within team and budget constraints
• Reviewing code security and complexity

Create Mermaid diagrams from code relationships parsed by Trailmark. Visualize function calls, class inheritance, module dependencies, class members, complexity hotspots, and paths from inputs to sensitive functions, with adjustable focus, depth, and layout.

• Mapping function calls around a selected function
• Visualizing class inheritance and members
• Drawing module dependency maps

Manage software complexity through deep modules, information hiding, and strategic programming. Use when the user mentions "module design", "API too complex", "shallow class", "complexity budget", "strategic vs tactical", "deep module", "information leakage", "pass-through method", "this code is over-engineered", or "simplify this design". Also trigger when reviewing an interface for simplicity, evaluating whether an abstraction is pulling its weight, deciding whether a comment is worth writing, or choosing between general-purpose and special-purpose approaches. Covers deep vs shallow modules, red flags for complexity, and comments as design documentation. For code quality, see clean-code. For architecture boundaries, see clean-architecture.

The English summary is being prepared. Showing the original description.

Classify XQUIC GitHub issues with an evidence-backed L1-L4 resolution-complexity label while keeping validity, priority, severity, and disposition separate and skipping uniquely labeled issues unless the user explicitly forces a recheck. Use when triaging one issue or a batch of issues, creating an issue-complexity backlog, or applying or correcting L1-L4 GitHub labels.

The English summary is being prepared. Showing the original description.

Automated Big-O complexity analysis of code and algorithms. Performs static analysis of loop structures, recursive call trees, space complexity estimation, and amortized analysis with detailed derivation documents.

The English summary is being prepared. Showing the original description.

Analyse text complexity across quantitative, qualitative, and reader-task dimensions with scaffolding recommendations. Use when selecting texts, assessing readability, or planning reading support.

The English summary is being prepared. Showing the original description.

Use SonarJS-derived rules in .NET repositories that ship JavaScript or TypeScript frontends and need deeper bug-risk, code-smell, or cognitive-complexity checks than a minimal ESLint baseline. USE FOR: SonarQube, SonarCloud, or eslint-plugin-sonarjs setups; frontend code smells; cognitive complexity and deeper bug-risk rules. DO NOT USE FOR: lightweight base lint setups with no extra smell or complexity rules; teams that reject Sonar tooling. INVOKES: inspect the repository context, edit targeted files, and run relevant build, test, lint, or validation commands when changes are made.

The English summary is being prepared. Showing the original description.

Use free built-in .NET maintainability analyzers and code metrics configuration to find overly complex methods and coupled code. USE FOR: the team wants to find overly complex methods; cyclomatic complexity thresholds are needed in CI; maintainability metrics or coupling thresholds need to be configured. DO NOT USE FOR: formatting-only work; generic analyzer setup with no complexity policy change. INVOKES: inspect the repository context, edit targeted files, and run relevant build, test, lint, or validation commands when changes are made.

The English summary is being prepared. Showing the original description.

This skill should be used when the user asks about "code complexity", "cyclomatic complexity", "cognitive complexity", "code metrics", "maintainability index", "code coverage", or when measuring code quality quantitatively. Provides metrics thresholds and measurement techniques.

The English summary is being prepared. Showing the original description.

Analyse text complexity across quantitative, qualitative, and reader-task dimensions with scaffolding recommendations. Use when selecting texts, assessing readability, or planning reading support.

The English summary is being prepared. Showing the original description.

Use free built-in .NET maintainability analyzers and code metrics configuration to find overly complex methods and coupled code. Use when a repo needs cyclomatic complexity checks, maintainability thresholds, or complexity-driven refactoring gates.

The English summary is being prepared. Showing the original description.

Domain-aware complexity routing: scans the task for domain keywords, matches domain-complexity.csv, and returns complexity level, workflow intensity, and execution tier. Extends Phase 0 orchestration.

The English summary is being prepared. Showing the original description.

Post-implementation simplification pass. Reduces complexity without changing behavior. Use after Phase 3 (Build GREEN) and before Phase 4 (Review). Catches dead code, unnecessary abstractions, over-engineering, and redundant patterns. Triggers on "simplify", "clean up", "reduce complexity", "too complex". NOT for style/convention enforcement (see mk:clean-code); NOT for reviewing diffs or PRs (see mk:review).

The English summary is being prepared. Showing the original description.