Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+22 more

    clean direct fix

    1

    Eliminate technical debt and redundant logic by enforcing single canonical paths in code, config, and prompts.

    $5

    Secure checkout via Stripe

    30-day refund guarantee

    Converts to your local currency at checkout

    Security scanned
    clean direct fix

    clean direct fix

    Example session with this skill installed

    Fix the duplicate timeout logic in the request handler and the retry middleware. It is currently hardcoded in both places.

    • Read your context and instructions
    • Compiled the clean direct fix

    I have consolidated the request timeout logic into a single canonical owner.

    Repair Implementation

    MetricDetail
    Main Pathconfig/constants.ts (Timeout registry)
    Removed PathHardcoded values in services/api-client.ts and middleware/retry-handler.ts
    VerificationGrep check for TIMEOUT = returned 1 result; Unit tests for retry-handler passed.
    Remaining RiskNone known.
    // config/constants.ts - The new Canonical Owner
export const NETWORK_CONFIG = {
  REQUEST_TIMEOUT_MS: 5000,
  MAX_RETRIES: 3
};

// middleware/retry-handler.ts - Updated to use canonical source
import { NETWORK_CONFIG } from '../config/constants';

export const retryMiddleware = async (req, next) => {
  let attempts = 0;
  while (attempts < NETWORK_CONFIG.MAX_RETRIES) {
    try {
      return await withTimeout(next(req), NETWORK_CONFIG.REQUEST_TIMEOUT_MS);
    } catch (err) {
      attempts++;
      if (attempts >= NETWORK_CONFIG.MAX_RETRIES) throw err;
    }
  }
};

    Next steps

    1. Review the centralized NETWORK_CONFIG values to ensure they meet production requirements.
    2. Run the integration test suite to verify the withTimeout wrapper handles the new constant correctly across all services.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Stop bloating your codebase with "just add a line" fixes. This skill forces a strict architectural discipline on code repairs, configuration updates, and prompt engineering. It eliminates technical debt at the source by identifying canonical owners and removing stale or redundant logic paths. Instead of stacking patches, you merge new requirements into existing truth sources.

    What it does

    • Architectural Auditing identifies redundant logic, duplicate prompt instructions, and conflicting config keys.
    • Source of Truth Consolidation merges new requirements into a single canonical owner rather than creating sibling functions or parallel logic.
    • Duplicate-Semantic Gating searches for repeated labels or responsibilities across code and prompts to prevent logic drift.
    • Safe Path Migration manages the transition from deprecated paths to new implementations with explicit removal conditions.
    • Multi-Layer Verification runs positive and negative checks to prove the old path is dead and the new path is the sole entry point.

    How it works

    1. Contract Definition starts every repair by naming the canonical owner, the bad path being replaced, and the unaffected scope.
    2. Logic Consolidation rewrites the primary source of truth to handle the new requirement, avoiding new branches or explanatory text.
    3. Redundancy Cleanup identifies and archives stale siblings, constants, or hard-coded variants.
    4. Strict Verification uses diff analysis and count checks to ensure no duplicate semantics remain in the runtime environment.

    Frameworks & tools

    This skill is language-agnostic and works with any source code, configuration schema (YAML, JSON), prompt engineering surface, or cloud infrastructure definition.

    Why this beats prompting it yourself

    Generic prompts often lead to "patch-on-patch" solutions that solve the immediate symptom while increasing complexity. This skill enforces a "one trustworthy path" constraint that prevents LLMs from hallucinating new logic layers and keeps your codebase clean.

    Use cases

    • Refactoring overlapping React components or service logic into a single shared utility.
    • Consolidating conflicting instructions in complex agentic system prompts.
    • Migrating legacy API endpoints to new versions while ensuring the old path is fully decommissioned.
    • Cleaning up scattered environment variables and hard-coded constants into a centralized config.

    Known limitations

    Does not perform large-scale worktree strategy or project-wide goal setting. Requires an existing codebase or configuration to analyze.

    How to use

    Skills on Agensi run inside your AI agent. Copy the prompt, paste it into your agent, and it connects to Agensi and installs this skill for you. If a payment is needed, your agent shows it to you first.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill passes our trust checks below.

    Security scanned

    Passed our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    30-day refund

    Not a fit? Get your money back

    Trust & safety

    Security scanned

    Verified clean today

    • Passed all security checks, Safe to install

    Listedtoday

    What's inside

    Frequently Asked Questions