Modular Code

by parcadeid07ff4b06b62No license3.9K starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated 8 months ago

Modular Code Organization

Instructions onlySoftware Development
AI-generated overview

Guides splitting Python code into modular files sized for maintainability and AI-assisted editing.

What it does
Provides guidelines for organizing Python code into modules, including file size thresholds, criteria for when to split a file, and natural split points such as domain concept, abstraction layer, data type, and I/O boundary. It also suggests a package structure and lists do's and don'ts for module naming and organization. A refactoring procedure for splitting existing large files is included, along with candidate files in a codebase.
When to use it
Use when organizing or refactoring Python code into modules, deciding whether a file is too large, or planning how to split an existing large file. It is aimed at maintainability and AI-assisted development contexts.
Requirements
No tools, packages, or credentials required; it is instructions only and ships no scripts.

Modular Code Organization

Write modular Python code with files sized for maintainability and AI-assisted development.

File Size Guidelines

LinesStatusAction
150-500OptimalSweet spot for AI code editors and human comprehension
500-1000LargeLook for natural split points
1000-2000Too largeRefactor into focused modules
2000+CriticalMust split - causes tooling issues and cognitive overload

When to Split

Split when ANY of these apply:

  • File exceeds 500 lines
  • Multiple unrelated concerns in same file
  • Scroll fatigue finding functions
  • Tests for the file are hard to organize
  • AI tools truncate or miss context

How to Split

Natural Split Points

  1. By domain concept: auth.py → auth/login.py, auth/tokens.py, auth/permissions.py
  2. By abstraction layer: Separate interface from implementation
  3. By data type: Group operations on related data structures
  4. By I/O boundary: Isolate database, API, file operations

Package Structure

feature/├── __init__.py      # Keep minimal, just exports├── core.py          # Main logic (under 500 lines)├── models.py        # Data structures├── handlers.py      # I/O and side effects└── utils.py         # Pure helper functions

DO

  • Use meaningful module names (data_storage.py not utils2.py)
  • Keep __init__.py files minimal or empty
  • Group related functions together
  • Isolate pure functions from side effects
  • Use snake_case for module names

DON'T

  • Split files arbitrarily by line count alone
  • Create single-function modules
  • Over-modularize into "package hell"
  • Use dots or special characters in module names
  • Hide dependencies with "magic" imports

Refactoring Large Files

When splitting an existing large file:

  1. Identify clusters: Find groups of related functions
  2. Extract incrementally: Move one cluster at a time
  3. Update imports: Fix all import statements
  4. Run tests: Verify nothing broke after each move
  5. Document: Update any references to old locations

Current Codebase Candidates

Files over 2000 lines that need attention:

  • Math compute modules (scipy, mpmath, numpy) - domain-specific, may be acceptable
  • patterns.py - consider splitting by pattern type
  • memory_backfill.py - consider splitting by operation type

Sources

Source and attribution

Source:parcadei/continuous-claude-v3in.claude/skills/modular-codeat commitd07ff4b

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal