Apply modularity patterns to software architecture design challenges.
npx skills add https://github.com/jdubray/puffin --skill modularity-patterns
Please help me install this Agent Skill. Skill: modularity-patterns Source: https://github.com/jdubray/puffin/tree/main/.claude/skills/modularity-patterns Command: npx skills add https://github.com/jdubray/puffin --skill modularity-patterns
Modern software systems often suffer from tight coupling and brittle architectures as complexity grows. This Skill provides a curated set of modularity, composition, and decoupling patterns to improve maintainability, testability, and adaptability across codebases.
Describe your target architecture and I will propose a modularity pattern strategy with concrete trade-offs.
High-intent search queries and answers about installing and using this skill.
Improving testability in existing codebases requires reducing tight coupling and isolating components. This Skill provides decoupling guidelines and composition patterns that support substitution, allowing you to refactor brittle architectures for better testability.
Decoupling a monolith involves applying separation of concerns and interface-first design to enable component substitution. This Skill proposes modularity patterns like Dependency Injection and Plugin to isolate modules and enable parallel evolution across your codebase.
Architecting a plugin system requires defining clear interfaces and lifecycle management rules to isolate extensions. This Skill recommends patterns like Microkernel, Plugin, and Observer to establish flexible extension points with minimal ripple effects.
Introducing cross-cutting concerns safely requires patterns that minimize dependency chains and isolate side effects. This Skill applies the Decorator and Observer patterns to manage cross-cutting logic while maintaining testability and architectural adaptability.
Use Strategy to encapsulate interchangeable algorithms within a class, while Dependency Injection manages external dependencies to isolate modules. This Skill compares modularity patterns and their concrete trade-offs to help you select the right approach for your target architecture.
Improving testability in existing codebases requires reducing tight coupling and isolating components. This Skill provides decoupling guidelines and composition patterns that support substitution, allowing you to refactor brittle architectures for better testability.
camilooscargbaptistaRecommend design patterns and SOLID refactors to reduce coupling and improve modularity.
superdejoooRefactor Laravel/Livewire codebases by extracting controllers and migrating validation to Form Requests.
hatlesswizardEnforce clean system architecture patterns in Java code development.
EthansuttorDecompose a monolithic orchestrator into modular bounded contexts using DDD and a microkernel pattern.
