robust-engineering

Identify brittle code patterns and enforce root-cause fixes across codebases.

10|Updated Dec 13, 2016

Search Tags:#refactoring #maintainability #engineering #code-quality #root-cause #robust

Ready to run

npx skills add https://github.com/vitallium/dotfiles --skill robust-engineering

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: robust-engineering
Source: https://github.com/vitallium/dotfiles/tree/main/dot_agents/skills/robust-engineering
Command: npx skills add https://github.com/vitallium/dotfiles --skill robust-engineering

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Enforces robust engineering standards to avoid hacks, promote root-cause fixes, and ensure clear honesty about limitations or fragility across codebases.

Core Features & Use Cases

Enforce non-hacky solutions and rigorous design reviews.
Promote root-cause analysis, maintainable code, and explicit risk reporting.
Use case: during refactoring or API redesign, apply the skill to surface weaknesses and devise robust alternatives.

Quick Start

Identify a brittle area in the codebase and outline a robust fix with a clear rationale.

Frequently Asked Questions about robust-engineering

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

FAQPage Schema

How do I identify and eliminate brittle code patterns during refactoring?▼

To identify brittle code patterns during refactoring, apply rigorous design reviews that surface weaknesses and require root-cause analysis to devise robust, maintainable alternatives with clear rationale.

What's the best way to enforce non-hacky solutions and rigorous engineering standards?▼

The best way to enforce non-hacky solutions is to impose explicit standards requiring root-cause analysis, clear documentation of limitations, and guarded changes across codebases and engineering tasks.

Can I use this approach for API design reviews and test fixes?▼

Yes, you can apply this approach to API design reviews and test fixes by imposing explicit standards that require root-cause analysis and clear honesty about fragility or limitations across the codebase.

Why does root-cause analysis matter for maintainable code?▼

Root-cause analysis matters for maintainable code because it enforces robust engineering standards that avoid hacks, promote honest risk reporting, and ensure clear documentation of limitations or fragility.

What are the limitations of applying explicit engineering standards to a codebase?▼

The limitation of applying explicit engineering standards is that it requires rigorous design reviews and guarded changes, demanding clear documentation of any limitations or fragility rather than allowing quick hacks.

How do I start building robust engineering with zero hacks?▼

To start building robust engineering with zero hacks, identify a brittle area in your codebase and outline a robust fix with a clear rationale, ensuring explicit risk reporting and root-cause fixes.