streamline

Decompose source files over 300 lines into modules of 200 lines or fewer.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/Mharbulous/SyncoPaid --skill streamline
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: streamline
Source: https://github.com/Mharbulous/SyncoPaid/tree/main/.claude/skills/streamline
Command: npx skills add https://github.com/Mharbulous/SyncoPaid --skill streamline

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill automatically identifies oversized source files (>300 lines) and decomposes them into smaller, more maintainable modules while preserving all functionality exactly, saving you from tedious manual refactoring.

Core Features & Use Cases

  • File Inventory Management: Maintains a single source of truth for file sizes and decomposition history.
  • Smart Candidate Selection: Identifies the largest files that need decomposition based on configurable thresholds.
  • Safe Refactoring: Creates backups before decomposing and preserves all original functionality.
  • Autonomous Mode: Can run in YOLO mode to automatically commit and push changes.
  • Use Case: When your codebase becomes hard to navigate due to large files, use this Skill to automatically break them down into logical, smaller modules without changing any behavior.

Quick Start

Use the streamline skill to find and decompose the largest file in my project that's over 300 lines.

Frequently Asked Questions about streamline

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

FAQPage Schema
How do I refactor large source files into smaller modules?

Refactoring large files breaks oversized source code (>300 lines) into smaller, maintainable modules while preserving all original functionality. This Skill automatically identifies and decomposes files in Python, JavaScript, TypeScript, and Vue projects, targeting files over 300 lines and producing modules of 200 lines or less without changing behavior.

What's the best way to improve code maintainability by decomposing large files?

File decomposition improves maintainability by breaking monolithic source files into logical, smaller modules. This Skill auto-detects your project structure (e.g., src/), analyzes file sizes across supported languages, and safely refactors oversized files while creating backups and preserving imports and behavior.

Can I automatically refactor my codebase without manual changes?

Automatic refactoring decomposes large files autonomously while guaranteeing no functional or design changes. This Skill supports interactive approval mode for review-before-commit workflows and YOLO mode for fully autonomous decomposition, with dated backups created before any changes.

Does this work with Python, JavaScript, TypeScript, and Vue projects?

Yes, file decomposition supports Python, JavaScript, TypeScript, and Vue codebases. The Skill auto-detects projects from a root directory, identifies oversized source files across all supported languages, and applies decomposition thresholds consistently.

What happens to imports and dependencies when files are decomposed?

File decomposition preserves all imports, dependencies, and behavior exactly during refactoring. The Skill maintains an inventory of file states and decomposition history, ensuring no functional or design changes occur while breaking large files into smaller, modular components.

Can I track which files have been decomposed and their history?

File inventory management maintains a single source of truth for file sizes and decomposition history. The Skill tracks all refactoring changes with dated backups, allowing you to review and understand the decomposition timeline across your codebase.