platform-implementation-principles

Enforce Fail Fast, Single Source of Truth, and Ports & Adapters boundaries in code.

Updated Mar 4, 2026
One-click install
npx skills add https://github.com/sncollective/snc-platform --skill platform-implementation-principles
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: platform-implementation-principles
Source: https://github.com/sncollective/snc-platform/tree/main/.claude/skills/platform-implementation-principles
Command: npx skills add https://github.com/sncollective/snc-platform --skill platform-implementation-principles

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Code-level principles (Fail Fast, Single Source of Truth, Ports & Adapters enforcement) govern how software is written and reviewed, auto-loading when adding new functions or modules, and ensuring input validation and minimal defensive boilerplate.

Core Features & Use Cases

  • Fail Fast: validate inputs at boundaries and fail early to prevent cascading errors.
  • Single Source of Truth: enforce a single registry for variant/configuration driving all behavior.
  • Ports & Adapters enforcement: domain logic depends on abstracted ports, adapters wired at the edge to keep boundaries clean.
  • Generated Contracts & Design Token Compliance: rely on generated types and shared design tokens to avoid hand-written schemas.
  • Use Case: teams refactor modules and add new features with strong guardrails and testable boundaries.

Quick Start

Start by applying input validation at the HTTP boundary and wire domain logic through ports with typed interfaces.

Frequently Asked Questions about platform-implementation-principles

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

FAQPage Schema
What is the best way to enforce clean architecture boundaries across service layers?

Enforcing clean architecture boundaries is best achieved using Ports & Adapters, where domain logic depends on abstracted ports and adapters wire infrastructure at the edge to keep interfaces testable and clean.

How do I implement fail fast input validation without defensive boilerplate?

To implement fail fast input validation, apply guard clauses at function and HTTP boundaries to validate inputs early, preventing cascading errors while minimizing defensive boilerplate across modules.

How does a single source of truth registry drive extensible behavior?

A single source of truth registry drives extensible behavior by acting as a single const registry for variants and configurations, ensuring all modules reference one centralized, consistent data source.

Do I need generated contracts and schemas for ports and adapters enforcement?

Yes, ports and adapters enforcement relies on generated contracts and shared design tokens from schemas, avoiding hand-written schemas to maintain strict dependency boundaries and clean interfaces.

Can these architectural principles work for both small and large codebases?

Yes, these architectural principles apply across function boundaries, modules, and service layers, guiding input validation and error handling in both small and large codebases with strong guardrails.

Why should domain logic avoid direct infrastructure dependencies?

Domain logic should avoid direct infrastructure dependencies to maintain testable boundaries; infrastructure must be abstracted via ports, ensuring clean separation and preventing tight coupling in service layers.