philosophy

Guide architectural and collaboration decisions with engineering philosophy principles.

4|2|Updated Jan 30, 2026
One-click install
npx skills add https://github.com/alexanderguy/skills --skill philosophy-alexanderguy
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: philosophy
Source: https://github.com/alexanderguy/skills/tree/main/skills/philosophy
Command: npx skills add https://github.com/alexanderguy/skills --skill philosophy-alexanderguy

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Philosophy and work-culture guidelines reduce confusion and inconsistency when making architectural decisions, collaborating with teammates, and choosing what to build versus what to defer.

Core Features & Use Cases

  • Guiding principles for decision-making: Encourages pragmatic tradeoffs, customer/data safety, and welcoming ideas without forcing consensus.
  • Collaboration and communication norms: Promotes asking questions, keeping discussions broadly visible, and respecting how others think.
  • Code, Git, and constraint ownership guidance: Establishes expectations for commit storytelling, separating refactors from features, and fixing invariants in the layer that owns them.
  • Backwards compatibility and testing mindset: Clarifies when compatibility matters, discourages unnecessary shims, and frames tests as behavior verification.
  • Automation and business-context framing: Supports building tools when appropriate and aligning engineering priority with business realities.

Quick Start

Load the philosophy skill when you need to make an architecture decision or align a proposed change with team work principles.

Frequently Asked Questions about philosophy

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

FAQPage Schema
What engineering principles help guide architectural decisions and team communication?

Engineering philosophy principles guide architectural decisions by promoting pragmatic tradeoffs, customer safety, and open communication norms. They establish clear expectations for resolving design questions and aligning team collaboration.

How do I handle backwards compatibility and avoid unnecessary shims during code changes?

Handle backwards compatibility by fixing invariants in the layer that owns them and avoiding unnecessary shims. Clarify when compatibility matters most, separating refactors from feature work to maintain stability.

When should I write tests as behavior verification instead of implementation checks?

Adopt a testing mindset that frames tests as behavior verification when validating code changes. This approach focuses on expected outcomes rather than internal implementation details, ensuring robust validation.

What is the best way to structure commits and separate refactors from new features?

The best way to structure commits is through clear storytelling, separating refactors from new features. This guideline ensures changes remain reviewable, logical, and aligned with team communication norms.

Does this engineering philosophy framework apply to automation and business context alignment?

Yes, the framework supports building automation tools when appropriate and aligning engineering priority with business realities. It ensures technical decisions respect operational constraints and broader goals.

Why does constraint ownership matter when making architectural decisions?

Constraint ownership matters because it requires fixing invariants in the layer that owns them, preventing scattered logic. This principle maintains system integrity and reduces confusion during collaboration.