enforcing-principles

Enforce fail-fast, unified data access, and Zod-driven API boundary validation.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/krwhynot/crispy-crm --skill enforcing-principles
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: enforcing-principles
Source: https://github.com/krwhynot/crispy-crm/tree/main/.claude/skills/enforcing-principles
Command: npx skills add https://github.com/krwhynot/crispy-crm --skill enforcing-principles

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill codifies Atomic CRM's Engineering Constitution to prevent over-engineering during pre-launch. It enforces fail-fast, a single composable entry point, and schema-driven form defaults. It guides developers to use Zod at the API boundary, maintain clear validation, and minimize complexity until user feedback justifies resilience patterns.

Core Features & Use Cases

  • Fail-fast discipline: avoid retries, circuit breakers, and graceful fallbacks during pre-launch; loud failures for rapid iteration.
  • Single composable entry point: consolidate data access behind a unified provider that delegates to resource modules with Zod-based API validation.
  • Form defaults from schema: derive default form values from Zod schemas (e.g., zodSchema.partial().parse({})) to keep defaults in a single source of truth.
  • Guidance on patterns: TypeScript types vs interfaces, React Admin patterns, and security/testing anti-patterns.
  • Real-world use: apply these principles when implementing features, handling errors, adding validation, creating forms, and writing migrations.

Quick Start

  • Start by auditing current code paths for retry logic and circuit breakers; remove resilience wrappers so failures throw to the operator.
  • Ensure a unified data provider is in place and that validation happens at the API boundary using Zod schemas.
  • Replace hardcoded form defaults with zodSchema.partial().parse({}) and merge in runtime values.
  • Avoid over-engineering until user feedback justifies more resilient patterns.

Frequently Asked Questions about enforcing-principles

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

FAQPage Schema
How do I prevent validation drift and enforce consistent data access patterns in my application?

Enforce fail-fast validation at the API boundary using Zod schemas with a unified data provider as your single composable entry point. This prevents retry logic, circuit breakers, and graceful fallbacks during development, making failures loud and actionable for rapid iteration.

How can I derive form defaults directly from Zod schemas instead of hardcoding them?

Use `zodSchema.partial().parse({})` to generate form defaults from your schema, then merge in runtime values. This keeps defaults in a single source of truth and eliminates duplication between validation and UI initialization.

What's the best way to structure data access to avoid over-engineering before launch?

Consolidate data access behind a unified provider that delegates to resource modules with Zod-based validation. This approach enforces a single entry point, centralizes validation at the API boundary, and prevents complexity until user feedback justifies resilience patterns.

When should I apply fail-fast discipline versus adding resilience patterns like retries?

During pre-launch, enforce fail-fast by removing retries and circuit breakers so failures throw immediately to operators. Add resilience patterns only after you have user feedback justifying the added complexity and deployment risk.

How do I implement security patterns like GRANT and RLS validation alongside form handling and migrations?

Apply two-layer GRANT+RLS security patterns consistently at the API boundary alongside Zod validation. This unifies access control with schema-driven form defaults and migration validation across your application.

Can I use this approach with React Admin and TypeScript interfaces?

Yes. This Skill provides concrete guidance on React Admin patterns, TypeScript types versus interfaces, and how to integrate schema-driven form defaults and validation across your stack while maintaining the fail-fast discipline.