fix-properly

Diagnose upstream root causes and apply source-level fixes with ripple-effect validation.

1|1|Updated May 13, 2026
One-click install
npx skills add https://github.com/bibektimilsina00/fuse_monorepo --skill fix-properly
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: fix-properly
Source: https://github.com/bibektimilsina00/fuse_monorepo/tree/main/.agents/skills/fix-properly
Command: npx skills add https://github.com/bibektimilsina00/fuse_monorepo --skill fix-properly

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill prevents teams from applying risky patches that hide the real cause of bugs, ensuring fixes are made at the source and validated end-to-end.

Core Features & Use Cases

  • Root-cause first: Forces diagnosis of symptom, location, upstream cause, and the correct upstream fix before any code changes.
  • Source-of-truth fixing: Rejects consumer-side workarounds (casts, special cases, fallbacks, silenced exceptions) and requires upstream contract corrections.
  • Data-flow tracing & ripple checks: Requires tracing value flow from creation to symptom and checking downstream consumers for ripple effects.

Quick Start

Invoke fix-properly when something is broken and you need the correct root-cause fix rather than a fast workaround.

Frequently Asked Questions about fix-properly

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

FAQPage Schema
How do I find the root cause of a bug instead of patching the symptom?

Root cause analysis requires tracing data flow from creation to symptom to identify the upstream origin. This Skill enforces diagnosing the true upstream cause and applying a source-level correction, rejecting consumer-side patches like casts or silenced exceptions.

What is the best way to fix type safety errors across multiple callers?

Fixing type safety errors requires source-of-truth corrections rather than consumer patches. This Skill rejects workarounds like casts and fallbacks, enforcing upstream contract corrections and checking downstream consumers for ripple effects to ensure consistent resolution.

Why does my code refactoring break downstream consumers?

Code refactoring breaks downstream consumers when upstream contracts change without ripple-effect validation. This Skill mandates tracing value flow from creation to symptom and verifying that the source-level fix resolves the symptom consistently for all callers.

How do I stop developers from using workarounds during debugging?

Stopping workarounds during debugging requires enforcing traceability and prohibiting silenced exceptions. This Skill rejects consumer-side patches, requiring engineers to diagnose the location, upstream cause, and correct upstream fix before making any code changes.

Can I use this approach for production maintenance on large codebases?

This approach applies to production maintenance across codebases where errors or wrong behaviors must be fixed consistently. It enforces end-to-end validation and ripple-effect checks to ensure the upstream correction fully resolves the symptom for all callers.

When should I avoid quick patches and apply source-level corrections?

You should avoid quick patches and apply source-level corrections whenever a bug risks hiding the real cause. This Skill mandates root-cause diagnosis first, prohibiting casts and special cases to ensure the fix fully resolves the symptom end-to-end.