Global Best Practices

Enforce SOLID, KISS, DRY, YAGNI, and security best practices for code.

51|6|Updated Mar 28, 2019
One-click install
npx skills add https://github.com/Mte90/dotfiles --skill global-best-practices-mte90
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Global Best Practices
Source: https://github.com/Mte90/dotfiles/tree/main/.config/opencode/skills/common/best-practices
Command: npx skills add https://github.com/Mte90/dotfiles --skill global-best-practices-mte90

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a comprehensive set of universal principles and actionable guidelines to improve code quality, maintainability, and robustness across all development environments.

Core Features & Use Cases

  • Architectural Principles: Enforces SOLID principles for modular and scalable design.
  • Clean Code Standards: Promotes KISS, DRY, and YAGNI for simplicity and efficiency.
  • Security & Performance: Outlines essential practices for secure and performant code.
  • Error Handling: Guides on predictable and graceful failure management.
  • Use Case: A developer is unsure about the best way to structure a new module. They consult this Skill to understand SOLID principles and apply them to create a well-designed, maintainable component.

Quick Start

Apply the best practices for writing clean and maintainable code.

Frequently Asked Questions about Global Best Practices

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

FAQPage Schema
What are SOLID principles and how do they improve software architecture?

SOLID principles are universal design guidelines for modular and scalable software architecture. Applying them ensures your codebase remains maintainable, robust, and easy to extend across all development environments.

How do I apply clean code standards like KISS, DRY, and YAGNI to my project?

To apply clean code standards, this Skill provides actionable guidelines to enforce KISS, DRY, and YAGNI. These principles promote simplicity and efficiency by eliminating duplication, reducing complexity, and avoiding unnecessary features.

What is the best way to structure a new module for maintainability?

The best way to structure a new module for maintainability is to consult architectural principles like SOLID. This Skill guides you in creating well-designed, modular components that ensure predictable behavior and graceful failure management.

How do I handle errors and manage failures when writing robust code?

To handle errors and write robust code, this Skill provides guidelines for predictable and graceful failure management. It outlines essential practices for secure, performant code that manages unexpected states without breaking the application.

When do I need to refactor code for better architecture?

You need to refactor code for better architecture when modules become difficult to maintain or scale. This Skill provides actionable guidelines and universal principles to safely restructure components while enforcing security and performance best practices.