skills.rest
fsolla
fsollaCOMMUNITY
Explore all skills by this author →
Website𝕏@franciscosollaGitHub

pragmatic-programmer

Evaluate codebases against seven meta-principles to identify technical debt.

Updated Jul 31, 2026
Search Tags:#architecture#best practices#refactoring#technical debt#dry#orthogonality#software craftsmanship
One-click install
npx skills add https://github.com/fsolla/teqo --skill pragmatic-programmer-fsolla
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: pragmatic-programmer
Source: https://github.com/fsolla/teqo/tree/main/.agents/skills/pragmatic-programmer
Command: npx skills add https://github.com/fsolla/teqo --skill pragmatic-programmer-fsolla

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses software entropy and technical debt by providing a structured framework for applying meta-principles like DRY, orthogonality, and design by contract to improve code quality and maintainability.

Core Features & Use Cases

  • Diagnostic Scoring: Evaluate your codebase against seven meta-principles to identify specific areas of technical debt.
  • Architectural Guidance: Apply patterns like tracer bullets, repository interfaces, and assertive programming to decouple systems and ensure reversibility.
  • Use Case: When starting a new project or refactoring a legacy module, use this Skill to determine whether to build a prototype or a tracer bullet, and how to structure your boundaries to avoid vendor lock-in.

Quick Start

Apply the pragmatic programmer framework to evaluate the current architecture of the user authentication module and suggest refactoring steps.

Frequently Asked Questions about pragmatic-programmer

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

FAQPage Schema
How do I identify and mitigate technical debt in a legacy codebase?▼

Mitigate technical debt by applying a diagnostic scoring framework that evaluates your codebase against seven meta-principles like DRY and orthogonality. This structured assessment identifies specific entropy areas, guiding targeted refactoring steps to improve overall maintainability.

What is the difference between building a prototype and using tracer bullets for new software architecture?▼

Tracer bullets build a thin end-to-end functional slice of the final architecture to validate boundaries and gather feedback, whereas prototypes explore disposable concepts. Use tracer bullets when starting new projects to ensure architectural reversibility and avoid vendor lock-in.

How do I apply orthogonality and design by contract to decouple complex software systems?▼

Apply orthogonality and design by contract by structuring architectural boundaries with repository interfaces and assertive programming. This pattern decouples complex systems, ensuring components operate independently to reduce software entropy and mitigate technical debt.

When should I make a build-vs-buy decision for architectural components to avoid vendor lock-in?▼

Make a build-vs-buy decision when evaluating architectural reversibility for new modules. Apply meta-principles to structure boundaries carefully, ensuring that adopting external dependencies maintains system independence and prevents vendor lock-in within complex software projects.

Does applying DRY principles help with refactoring a user authentication module?▼

Applying DRY principles helps refactor a user authentication module by eliminating duplicated logic and reducing software entropy. The framework evaluates current architecture against meta-principles to suggest targeted refactoring steps for improving overall code quality and maintainability.

Related Skills

Explore More Software Engineering Skills→
alirezarezvanialirezarezvani
24.2k

ceo-advisor

Analyze strategic positions and model financial scenarios for CEO decisions.

Community
Intermediate
wesleyegbertowesleyegberto
3

pragmatic-programmer

Apply pragmatic programming principles to improve maintainability and adaptability.

Community
Advanced
knopkiknopki
1

orthogonality-principle

Explains the orthogonality principle for designing independent, non-overlapping software components.

Community
Intermediate
CarGDevCarGDev

Code Auditor

Audit code quality by detecting dead code, complexity, duplication, and architectural smells.

Community
Intermediate