pull-complexity-down

Review module interfaces and recommend reductions to caller-managed complexity.

11|Updated Feb 25, 2026
One-click install
npx skills add https://github.com/codybrom/clairvoyance --skill pull-complexity-down
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: pull-complexity-down
Source: https://github.com/codybrom/clairvoyance/tree/main/skills/pull-complexity-down
Command: npx skills add https://github.com/codybrom/clairvoyance --skill pull-complexity-down

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill identifies when software modules push unnecessary setup, configuration, error handling, or edge-case decisions onto callers instead of absorbing that complexity where it can be handled once.

Core Features & Use Cases

  • Interface Complexity Audits: Inventory parameters, exceptions, constraints, decorators, and pass-through variables that increase caller burden.
  • Configuration Analysis: Test whether configuration values should be constants, sensible defaults, dynamic computations, presets, or policy objects.
  • Module Boundary Review: Distinguish complexity that belongs inside an implementation from complexity that would introduce unrelated knowledge or leak UI concerns.
  • Use Case: Review a service API whose callers must configure retries, prepare inputs, and handle recoverable failures, then recommend a simpler interface that centralizes those decisions.

Quick Start

Ask the pull-complexity-down skill to review the specified module and recommend concrete ways to reduce the complexity exposed to its callers.

Frequently Asked Questions about pull-complexity-down

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

FAQPage Schema
How do I reduce configuration parameters pushing complexity onto API callers?

Reduce API configuration complexity by evaluating parameters against asymmetry, dynamic computation, and module-boundary criteria. Convert unnecessary configurations into constants, sensible defaults, or policy objects, absorbing setup decisions centrally so callers avoid managing excessive pass-through variables.

What is module boundary complexity in interface design?

Module boundary complexity in interface design occurs when implementations push setup, error handling, or edge-case decisions onto callers. Reviewing module interfaces distinguishes complexity that belongs inside an implementation from complexity that leaks unrelated knowledge or UI concerns across boundaries.

How do I review an API that requires caller-managed error handling?

Review an API requiring caller-managed error handling by inventorying exceptions, constraints, and recoverable failures. Evaluate whether the implementation can absorb these decisions centrally, recommending interface reductions that pull complexity away from callers instead of forcing them to handle recoverable failures.

When should pass-through parameters be removed during a code review?

Remove pass-through parameters during a code review when they increase caller burden without adding value to the module boundary. Evaluate pass-through variables against asymmetry and dynamic computation criteria to determine if centralizing them inside the implementation reduces unnecessary interface complexity.

What is the best way to audit interface complexity for service APIs?

The best way to audit interface complexity for service APIs is to inventory parameters, exceptions, decorators, and pass-through variables. Evaluate these interface elements against asymmetry, dynamic computation, and module-boundary criteria to recommend specific reductions that centralize decisions.

How do I know if configuration values should be defaults or dynamic computations?

Determine if configuration values should be defaults or dynamic computations by testing whether values require runtime inputs or can be centralized. Replace caller-managed configurations with constants, sensible defaults, dynamic computations, presets, or policy objects based on module-boundary criteria.