integra-code-organization

Identify coupling patterns and co-locate related code to minimize blast radius.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/Integra-Beauty/integra-conventions --skill integra-code-organization
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: integra-code-organization
Source: https://github.com/Integra-Beauty/integra-conventions/tree/main/skills/integra-code-organization
Command: npx skills add https://github.com/Integra-Beauty/integra-conventions --skill integra-code-organization

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Helps teams reason about where to place code, how to group functions, and how to minimize coupling while maximizing clarity and reuse.

Core Features & Use Cases

  • Co-locate by coupling, not similarity to keep related changes together.
  • Keep single-use helpers with their caller to avoid needless extraction.
  • Organize by what changes, not by what it is, to reflect real fault lines.
  • Avoid premature decomposition and maintain cohesive modules as they evolve.
  • Use boundaries that preserve critical relationships, enabling safer refactors.

Quick Start

Identify a real coupling pattern in your module and place related helpers with the caller to keep changes minimal.

Frequently Asked Questions about integra-code-organization

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

FAQPage Schema
How do I organize code modules to reduce coupling and blast radius?

Code organization based on coupling minimizes blast radius by identifying real change patterns and placing related functionality together. Co-locate coupled code rather than grouping by similarity to ensure safer refactors.

When should I keep single-use helpers with the caller instead of extracting them?

Keep single-use helpers with the caller to avoid premature decomposition and needless extraction. Extracting helpers too early breaks cohesion and increases coupling across modules, making future changes harder to track and maintain.

What is the best way to refactor code layout for better module cohesion?

The best way to refactor for cohesion is to organize by what changes together, not by what it is. Apply co-location by coupling to preserve critical relationships and establish boundaries that enable safer, more maintainable refactors.

Why does grouping similar functions together cause maintainability issues?

Grouping similar functions causes maintainability issues because it ignores real coupling patterns. Organizing by what changes, not by similarity, keeps related changes together and prevents blast radius from spreading across unrelated modules.

Does premature decomposition harm codebase maintainability during refactoring?

Premature decomposition harms maintainability by breaking up cohesive modules before real fault lines emerge. Avoid needless extraction and maintain cohesive modules as they evolve to preserve critical relationships and enable safer refactors.

How do I decide whether to co-locate helpers with their callers?

Decide whether to co-locate helpers by analyzing real coupling patterns between the helper and its caller. Keep single-use helpers with the caller to minimize blast radius and avoid introducing unnecessary module boundaries.