no-workarounds

Enforce root-cause fixes over workarounds in software engineering tasks.

Updated May 15, 2026
One-click install
npx skills add https://github.com/JBonfim/skill-developer --skill no-workarounds-jbonfim
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: no-workarounds
Source: https://github.com/JBonfim/skill-developer/tree/main/.agents/skills/no-workarounds
Command: npx skills add https://github.com/JBonfim/skill-developer --skill no-workarounds-jbonfim

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill prevents engineering teams from papering over bugs with hacks that silence signals, hide failures, and compound technical debt over time.

Core Features & Use Cases

  • Workaround detection gate: Forces you to state the problem, trace it to the root cause, and verify the proposed change actually addresses the underlying issue.
  • Anti-pattern coverage: Rejects common workaround categories including type system evasion, lint/warning suppression, error swallowing, timing hacks, monkey patching, defensive scatter, and copy-paste adaptation.
  • Escape valve process: Allows narrowly scoped workarounds only when the true root cause is external, upstream is uncertain, business impact justifies shipping, and the workaround is isolated with tracking and tests.

Quick Start

When you hit a bug, test failure, or questionable design change, ask the AI to apply the no-workarounds gate and propose a root-cause fix instead of a workaround.

Frequently Asked Questions about no-workarounds

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

FAQPage Schema
How do I stop developers from using workarounds to patch code instead of fixing bugs?

To stop developers from using workarounds, enforce a root-cause fixing process that requires tracing failures to their underlying issue before applying changes. This prevents symptom-patching and compounding technical debt across your codebase.

What is a root-cause fix compared to a defensive code scatter workaround?

A root-cause fix addresses the underlying failure directly, while defensive code scatter is an anti-pattern workaround that suppresses errors across multiple locations. True root-cause resolution isolates the issue instead of hiding the failure signals.

When is it acceptable to use a workaround during debugging?

A workaround during debugging is acceptable only when the root cause is external and upstream is uncertain, provided the business impact justifies shipping. The workaround must be isolated with tracking documentation and test canaries.

How do I detect anti-patterns like error swallowing and timing hacks during code review?

Detect anti-patterns like error swallowing and timing hacks during code review by applying a structured workaround-detection gate. This process verifies that proposed changes resolve the actual problem rather than silencing signals or evading type systems.

Does this root-cause fixing approach work across different languages and frameworks?

Yes, this root-cause fixing approach works across different languages and frameworks. It applies broadly to debugging, architectural decisions, and code review by enforcing patterns that reject monkey patching and lint suppression universally.