Results for “complexity”

Use when the operator says "run distillation" or "refresh complexity corpus", or a distillation pass is due.

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

Add or define specific fields in a collection's readSchema. Use when fields are missing from materialization field selection, pruned by complexity limit, need type refinement, need to be protected from future inference changes, or need to be required for downstream consumers. Use when user says "missing fields", "pruned fields", "field not showing up", "complexity limit", "define field in read schema", "restrict field type", or "protect field from inference".

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

Review code for readability, then simplify it to be easy to follow and understand. Use this skill when the user wants to simplify code, improve readability, clean up for handoff, make code skimmable, reduce complexity, refactor for clarity, strip boilerplate, prepare code for future maintainers, or make a codebase easier to pick up. Trigger liberally — any request touching readability, simplification, cleanup, or "make this easier to understand" should use this skill. Also trigger when the user says things like "review this", "clean this up", "tidy this", "make this simpler", "reduce complexity", "flatten this", "strip the noise", or "I want to understand this code quickly next time I open it".

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

Assesses ChIP-seq quality across antibody specificity, fragmentation, enrichment, replicate concordance, and library complexity. Computes FRiP, NSC/RSC (phantompeakqualtools), library complexity (NRF/PBC1/PBC2), deepTools plotFingerprint (JS distance, AUC, synthetic JS), ChIPQC, IDR with ENCODE Nself/Nt rules, and detects hyper-ChIPable artifacts. Use when validating an antibody, diagnosing failed peak calls, deciding whether to proceed with downstream analysis, grading against ENCODE thresholds, or auditing replicate concordance.

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

Decompose tasks into structured, outcome-defined process entries with complexity triage. Load when user says "decompose this", "break this down", "what steps do I need", "plan this out", "what's the process for", "how do I approach this", or when any complex task needs structured execution planning. Includes a problem-understanding pass before complexity triage. Routes to `problem-to-plan` when the user needs planning deliverables (spec + plan + TODO). Does NOT replace brainstorming — brainstorming is design approval (upstream), this is execution planning (downstream).

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

Simplify application code for clarity without changing behavior — refactor after tests pass, reduce nesting and duplication, match project conventions. Load when refactoring for readability, cleaning up after a feature ships, or when code review flags complexity. Also triggers on "simplify this code", "code simplification", "make this easier to read", "reduce complexity", "refactor for clarity". Not for compress/split/prune-skill (skill-library files). Pairs with technical-debt-audit.

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

Assesses ChIP-seq quality across antibody specificity, fragmentation, enrichment, replicate concordance, and library complexity. Computes FRiP, NSC/RSC (phantompeakqualtools), library complexity (NRF/PBC1/PBC2), deepTools plotFingerprint (JS distance, AUC, synthetic JS), ChIPQC, IDR with ENCODE Nself/Nt rules, and detects hyper-ChIPable artifacts. Use when validating an antibody, diagnosing failed peak calls, deciding whether to proceed with downstream analysis, grading against ENCODE thresholds, or auditing replicate concordance.

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

Complete guide for code coverage analysis. Use when you need to analyze code coverage, generate coverage reports, or configure CI/CD coverage checks. Covers Coverlet configuration, report generation, metric interpretation, and cyclomatic complexity integration. Includes Fine Code Coverage, VS Code built-in tools, and best practices. Keywords: code coverage, coverage analysis, coverage report, Coverlet, Fine Code Coverage, dotnet-coverage, ReportGenerator, line coverage, branch coverage, cyclomatic complexity, runsettings, cobertura

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

Reduce changes on your own branch before opening or updating a pull request. Review added architecture and tests, remove unnecessary complexity, and verify that the smaller change still fixes the original problem and preserves supported behavior.

• Trim changes before opening a pull request
• Remove duplicate architecture after a large repair
• Keep tests that catch distinct failures

Organize engineering work carried out by AI agents with clear completion criteria, small verifiable tasks, and evaluations before and after implementation. Match model choice to task complexity and track tokens, retries, time, and outcomes to manage cost.

• Planning development work for AI agents
• Splitting a large change into independently verifiable tasks
• Comparing evaluations before and after implementation

Review and refine code using shared conventions for clear names, readability, error handling, and updates that preserve original data. Identify duplication, oversized functions, and unnecessary complexity to make code easier to understand and maintain.

• Reviewing names and readability in existing code
• Refactoring long functions and deeply nested logic
• Standardizing coding conventions for a new module

Migrate code and API calls from Claude Sonnet 4.0, Sonnet 4.5, or Opus 4.1 to Opus 4.5. Update platform-specific model identifiers and address reported prompt behavior issues, such as excessive tool use or unnecessary code complexity.

• Updating model identifiers in existing code
• Migrating API settings for a specific platform
• Adjusting prompts that trigger excessive tool use

Review code changes before merging across correctness, readability, architecture, security, and performance. Get findings that distinguish required fixes from optional suggestions, with concrete ways to simplify code and checks on test coverage.

• Reviewing a pull request before merging
• Checking code written by an AI agent
• Assessing whether a refactor reduces complexity

Choose Rust design patterns for RTK modules that process command output. Use concrete examples to structure configuration, prevent type mixups, manage parser states, and select abstractions suited to the task without adding unnecessary architectural complexity.

• Planning the structure of a new command output filter
• Preventing mixups between values with the same underlying type
• Organizing configuration with many optional fields

Review source code for readability, complexity, duplication, and maintainability without changing files. Receive a structured report with prioritized issues, refactoring suggestions, positive findings, and estimates of technical debt—the work needed to address accumulated code problems.

• Review the quality of an authentication module
• Find duplicate code and overly long methods
• Assess accumulated code problems and repair effort

Assembles teams of AI agents by analyzing task complexity, required skills, and resource needs. It covers selecting specialists, adjusting team size to workload, and refining coordination using patterns from past executions.

• Assemble specialists for payment system refactoring
• Scale agents to process large batches of data files
• Find networking specialists for WebSocket debugging

Analyze Git changes before submitting or merging a pull request. Assess risk and complexity, classify changes, suggest reviewer roles, and identify files needing closer inspection using diff statistics and file-level risk analysis.

• Assess change risks before submitting a pull request
• Review large changes spanning multiple modules
• Identify reviewer roles suited to the changes

Analyze the last seven days of agent and model token usage to identify unnecessary spending. Recommend changes to model selection, prompt caching, and overlapping work, with estimated dollar savings, percentage reductions, and implementation priorities.

• Investigating higher-than-expected AI costs
• Matching model choices to task complexity
• Reviewing prompt caching efficiency

Review large tables, feeds, and lists for rendering overhead. Introduce virtualization, which renders only visible items and a small buffer, while preserving keyboard access, selection, and expected scrolling behavior.

• Investigate sluggish admin tables
• Review long search result lists
• Reduce rendering overhead in feeds

Measure the size and nesting of a page's DOM, the tree of HTML elements. Identify unnecessary wrappers and oversized lists, then simplify the structure or render only visible list items to reduce confirmed rendering costs.

• Investigating pages with slow rendering or interactions
• Measuring HTML element counts and nesting depth
• Removing unnecessary wrapper elements

Document a project's structure, commands, and specific conventions in a hierarchy of AGENTS.md files. Analyze directory complexity to choose useful locations, update existing guidance, and check that child files avoid repeating their parents.

• Create project guidance for coding agents
• Refresh existing AGENTS.md documentation
• Document rules specific to complex directories

Uses multiple agents with different critical roles to challenge assumptions, complexity, risks, and alternatives. Findings that withstand review go to a dedicated planner, who turns them into sequenced tasks with explicit success criteria.

• Reviewing assumptions before implementation
• Checking integration risks and edge cases
• Comparing alternative approaches

Clarify unresolved product decisions before implementation, such as scope, supported platforms, or API agreements. Use a small set of focused questions to establish the intended outcome, while leaving routine technical choices to the agent.

• Clarify an unresolved product scope
• Confirm which platforms a product should support
• Resolve open decisions about data or API agreements

Assess REST and GraphQL API security through checks of authentication, access permissions, input validation, and request limits. The workflow guides endpoint discovery, testing, and documentation of findings and remediation within an authorized scope.

• Checking API authentication and token handling
• Testing access permissions across roles and tenants
• Reviewing request limits and input validation