effect-best-practices

Enforce consistent Effect-TS service and error patterns in TypeScript codebases.

15|2|Updated Dec 16, 2025
One-click install
npx skills add https://github.com/enitrat/skill-issue --skill effect-best-practices-enitrat
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: effect-best-practices
Source: https://github.com/enitrat/skill-issue/tree/main/plugins/personal-skills/skills/effect-best-practices
Command: npx skills add https://github.com/enitrat/skill-issue --skill effect-best-practices-enitrat

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Enforces consistent, safe, and maintainable usage of Effect-TS across services, layers, atoms, and observability, reducing boilerplate and enabling scalable patterns.

Core Features & Use Cases

  • Standardizes service definitions using Effect.Service, Effect.fn, and automatic accessors.
  • Enforces explicit error types with Schema.TaggedError and tag-based handling via catchTag/catchTags.
  • Promotes clear layer composition, dependency declaration, and observable-friendly patterns for logging, tracing, and metrics.
  • Real-world use: teams align service definitions and error handling across large TypeScript codebases to improve maintainability.

Quick Start

Create a new skill folder, add a SKILL.md with frontmatter and instructions, then test locally with the marketplace commands.

Frequently Asked Questions about effect-best-practices

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

FAQPage Schema
How do I enforce consistent Effect-TS service patterns across a large TypeScript codebase?

To enforce consistent Effect-TS service patterns, standardize definitions using Effect.Service and Effect.fn with automatic accessors. This ensures explicit dependency declaration and uniform service composition across projects, reducing boilerplate and improving maintainability.

What is the best way to define explicit error types in Effect-TS?

The best way to define explicit error types in Effect-TS is using Schema.TaggedError. This approach enables structured, tag-based error handling, allowing you to use catchTag and catchTags for precise error recovery and clear observability.

How does layer composition work when managing dependencies in Effect-TS?

Layer composition in Effect-TS works by explicitly declaring dependencies through structured service definitions. Promoting clear layer composition ensures observable-friendly patterns for logging and tracing while maintaining explicit dependency declaration across services.

Can I use tagged errors with catchTag for structured error handling in TypeScript?

Yes, you can use tagged errors with catchTag for structured error handling in TypeScript. By defining errors with Schema.TaggedError, you enforce explicit error types and enable precise tag-based recovery using catchTag and catchTags.

When should I add observability hooks to Effect-TS layers and atoms?

You should add observability hooks to Effect-TS layers and atoms when scaling TypeScript codebases to improve maintainability. Promoting clear layer composition with observable-friendly patterns enables consistent logging, tracing, and metrics across all services.