core-development-philosophy

Guides software changes toward minimal conceptual scope and reuse of existing implementations.

1|Updated Aug 11, 2026
One-click install
npx skills add https://github.com/0xMuluh/package-development-skills --skill core-development-philosophy-0xmuluh
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: core-development-philosophy
Source: https://github.com/0xMuluh/package-development-skills/tree/main/core-development-philosophy
Command: npx skills add https://github.com/0xMuluh/package-development-skills --skill core-development-philosophy-0xmuluh

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Software packages tend to accumulate unnecessary abstractions, speculative frameworks, and sprawling pull requests that mix unrelated changes, making codebases harder to maintain. This Skill provides a default engineering philosophy that keeps software conceptually small as it grows by enforcing reuse-first development, one semantic change per PR, and preservation of unrelated behavior. ## Core Features & Use Cases - Development Invariants: Fifteen concrete rules covering reuse before implementing, preferring existing representations, depending on public contracts, and earning new classes only with demonstrated need. - Pre-Change Planning: Required questions and a PR scope template that force explicit statements of problem, intended change, non-goals, reuse opportunities, and behavioral boundaries before writing code. - Review Heuristics & Split Signals: Checklists for reviewers and concrete warning signs (e.g., "fix + rename", "move + redesign") indicating a PR should be split into separate semantic changes. - Use Case: When asked to add a feature to an established package, apply this Skill to first check whether existing containers, upstream implementations, and public APIs already solve the problem, then scope the PR to one observable change with a focused regression test. ## Quick Start Apply the core development philosophy to plan and review my next pull request for this package.

Frequently Asked Questions about core-development-philosophy

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

FAQPage Schema
How do I keep pull requests small and focused?▼

Give every pull request one semantic purpose that can be described in a single sentence. Split work when the PR combines independent verbs like fix plus rename or move plus redesign, and exclude opportunistic cleanups of unrelated code.

When should I create a new class or abstraction?▼

Create a new abstraction only when a concrete current requirement exists, existing language or ecosystem abstractions are inadequate, and at least one current caller benefits. Otherwise prefer existing representations such as data frames, lists, or upstream result classes.

Should I reuse existing libraries or write my own implementation?▼

Investigate reuse first: check the standard library, the package's public API, existing dependencies, and established domain packages before implementing. Depend on exported public contracts rather than non-exported functions or undocumented internals.

How do I safely refactor legacy code without tests?▼

Characterize the existing behavior first by adding focused tests that capture what the code currently does, then make the intended change and add tests demonstrating the new behavior. Do not redesign poorly understood code and its tests simultaneously.

What are the limits of minimal-change development?▼

Small refers to semantic scope, not line count, so large diffs are acceptable when every changed line serves one purpose. The philosophy does not prohibit new abstractions or dependencies, but each must be justified by a demonstrated concrete problem.