effect-patterns-tooling-and-debugging

name	effect-patterns-tooling-and-debugging
description	Effect-TS patterns for Tooling And Debugging. Use when working with tooling and debugging in Effect-TS applications.

Effect-TS Patterns: Tooling And Debugging

This skill provides 8 curated Effect-TS patterns for tooling and debugging. Use this skill when working on tasks related to:

• tooling and debugging
• Best practices in Effect-TS applications
• Real-world patterns and solutions

---

🟢 Beginner Patterns

Read Effect Type Errors

Rule: Effect errors are verbose but structured - learn to extract the key information.

Rationale:

Effect type errors can be long, but they follow a pattern. Learn to scan for the key parts.

---

Effect's type system catches many bugs at compile time, but:

1. Effect types are complex - Three type parameters
2. Errors are nested - Multiple layers of generics
3. Messages are verbose - TypeScript shows everything

Understanding the pattern makes errors manageable.

---

---

Set Up Your Effect Development Environment

Rule: Install the Effect extension and configure TypeScript for optimal Effect development.

Rationale:

Set up your development environment with the Effect extension and proper TypeScript configuration for the best experience.

---

A well-configured environment helps you:

1. See types clearly - Effect types can be complex
2. Get better autocomplete - Know what methods are available
3. Catch errors early - TypeScript finds problems
4. Navigate easily - Go to definitions, find references

---

---

🟡 Intermediate Patterns

Supercharge Your Editor with the Effect LSP

Rule: Install and use the Effect LSP extension for enhanced type information and error checking in your editor.

Good Example:

Imagine you have the following code. Without the LSP, hovering over program might show a complex, hard-to-read inferred type.

import { Effect } from "effect";

// Define Logger service using Effect.Service pattern
class Logger extends Effect.Service<Logger>()("Logger", {
  sync: () => ({
    log: (msg: string) => Effect.log(`LOG: ${msg}`),
  }),
}) {}

const program = Effect.succeed(42).pipe(
  Effect.map((n) => n.toString()),
  Effect.flatMap((s) => Effect.log(s)),
  Effect.provide(Logger.Default)
);

// Run the program
Effect.runPromise(program);

With the Effect LSP installed, your editor would display a clear, readable overlay right above the program variable, looking something like this:

// (LSP Inlay Hint)
// program: Effect<void, never, never>

This immediately tells you that the final program returns nothing (void), has no expected failures (never), and has no remaining requirements (never), so it's ready to be run.

---

Anti-Pattern:

Going without the LSP. While your code will still compile and work perfectly fine, you are essentially "flying blind." You miss out on the rich, real-time feedback that the LSP provides, forcing you to rely more heavily on manual type checking, tsc runs, and deciphering complex inferred types from your editor's default tooltips. This leads to a slower, less efficient development cycle.

Rationale:

To significantly improve your development experience with Effect, install the official Effect Language Server (LSP) extension for your code editor (e.g., the "Effect" extension in VS Code).

---

Effect's type system is incredibly powerful, but TypeScript's default language server doesn't always display the rich information contained within the A, E, and R channels in the most intuitive way.

The Effect LSP is a specialized tool that understands the semantics of Effect. It hooks into your editor to provide a superior experience:

• Rich Inline Types: It displays the full Effect<A, E, R> signature directly in your code as you work, so you always know exactly what an effect produces, how it can fail, and what it requires.
• Clear Error Messages: It provides more specific and helpful error messages tailored to Effect's APIs.
• Enhanced Autocompletion: It can offer more context-aware suggestions.

This tool essentially makes the compiler's knowledge visible at a glance, reducing the mental overhead of tracking complex types and allowing you to catch errors before you even save the file.

---

---

Use Effect DevTools

Rule: Use Effect's built-in debugging features and logging for development.

Good Example:

1. Enable Debug Mode

import { Effect, Logger, LogLevel, FiberRef, Cause } from "effect"

// ============================================
// 1. Verbose logging for development
// ============================================

const debugProgram = Effect.gen(function* () {
  yield* Effect.logDebug("Starting operation")

  const result = yield* someEffect.pipe(
    Effect.tap((value) => Effect.logDebug(`Got value: ${value}`))
  )

  yield* Effect.logDebug("Operation complete")
  return result
})

// Run with debug logging enabled
const runWithDebug = debugProgram.pipe(
  Logger.withMinimumLogLevel(LogLevel.Debug),
  Effect.runPromise
)

// ============================================
// 2. Fiber supervision and introspection
// ============================================

const inspectFibers = .(* () {
  
   fiber1 = * .(.())
   fiber2 = * .(.())

  
  * .()
  * .()

  
   status1 = * fiber1.
  * .()
})





 tracedProgram = .(* () {
  * .()

  * .(* () {
    * .()
    * .()
  }).(.())

  * .(* () {
    * .()
    * .()
  }).(.())

  * .(* () {
    * .()
    * .()
  }).(.())

  * .()
})





 debugErrors = .(* () {
   failingEffect = .(* () {
    * .( ())
  }).(
    .( .( ()))
  )

  * failingEffect.(
    .(
      .(* () {
        * .()
        * .()
        * .()
        * .()

        
         failures = .(cause)
        * .()

         
      })
    )
  )
})





 {  }  

   ()<, { :  }>() {}

 inspectContext = .(* () {
   context = * .<>()

  * .()
  * .()
})





 devLogger = .( {
   timestamp = date.()
   level = logLevel..()
   spanInfo = spans. > 
    ? 
    : 
   annotationInfo = .(annotations). > 
    ? 
    : 

  .()
})

 withDevLogger = <A, E, R>
  effect.(
    .(.(., devLogger))
  )





 showRuntimeMetrics = .(* () {
   runtime = * .()

  * .()
  
   fiberRefs = runtime.

  * .()
})





 debugSession = .(* () {
  * .()

  
  * tracedProgram.(
    withDevLogger,
    .(.)
  )

  * debugErrors

  * .()
})

.(debugSession)

Debug Output Example

2024-01-15T10:30:00.000Z DEBUG   [initialization] Step 1: Initialize
2024-01-15T10:30:00.100Z DEBUG   [processing] Step 2: Process
2024-01-15T10:30:00.300Z DEBUG   [finalization] Step 3: Finalize
2024-01-15T10:30:00.350Z INFO    Program complete

Rationale:

Use Effect's built-in debugging capabilities, logging, and fiber introspection for development.

---

Effect DevTools help you:

1. See fiber state - What's running, blocked, completed
2. Trace execution - Follow the flow of effects
3. Debug errors - Understand failure chains
4. Profile performance - Find slow operations

---

---

Configure Linting for Effect

Rule: Use Biome for fast linting with Effect-friendly configuration.

Good Example:

1. Biome Configuration (Recommended)

// biome.json
{
  "$schema": "https://biomejs.dev/schemas/1.8.0/schema.json",
  "organizeImports": {
    "enabled": true
  },
  "linter": {
    "enabled": true,
    "rules": {
      "recommended": true,
      "complexity": {
        "noExcessiveCognitiveComplexity": "warn",
        "noForEach": "off",  // Effect uses forEach patterns
        "useLiteralKeys": "off"  // Effect uses computed keys
      },
      "correctness": {
        "noUnusedVariables": "error",
         
         
      
       
         
         
         
      
       
         
           
      
       
         
           
           
             
               
               
            
          
        
      
    
  
   
     
     
     
     
  
   
     
       
       
       
    
  
   
     
      
      
      
      
    
  

2. ESLint Configuration (Alternative)

// eslint.config.js
import eslint from "@eslint/js"
import tseslint from "typescript-eslint"

export default tseslint.config(
  eslint.configs.recommended,
  ...tseslint.configs.strictTypeChecked,
  {
    languageOptions: {
      parserOptions: {
        project: true,
        tsconfigRootDir: import.meta.dirname,
      },
    },
    rules: {
      // TypeScript strict rules
      "@typescript-eslint/no-unused-vars": [
        "error",
        { argsIgnorePattern: "^_" }
      ],
      "@typescript-eslint/no-explicit-any": "warn",
      "@typescript-eslint/explicit-function-return-type": "off",
      "@typescript-eslint/no-floating-promises": "error",

      // Effect-friendly rules
      "@typescript-eslint/no-confusing-void-expression": "off",
      "@typescript-eslint/no-misused-promises": [
        "error",
        { checksVoidReturn: false }
      ],

      // Style rules
      "prefer-const": "error",
      "no-var": "error",
      "object-shorthand": ,
      : ,
    },
  },
  {
    : [],
    : {
      : ,
    },
  },
  {
    : [, , ],
  }
)

3. Package.json Scripts

{
  "scripts": {
    "lint": "biome check .",
    "lint:fix": "biome check --apply .",
    "lint:ci": "biome ci .",
    "format": "biome format --write .",
    "format:check": "biome format ."
  }
}

4. VS Code Integration

// .vscode/settings.json
{
  "editor.defaultFormatter": "biomejs.biome",
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": {
    "quickfix.biome": "explicit",
    "source.organizeImports.biome": "explicit"
  },
  "[typescript]": {
    "editor.defaultFormatter": "biomejs.biome"
  },
  "[typescriptreact]": {
    "editor.defaultFormatter": "biomejs.biome"
  }
}

5. Pre-commit Hook

// package.json
{
  "scripts": {
    "prepare": "husky"
  }
}

# .husky/pre-commit
bun run lint:ci
bun run typecheck

6. Effect-Specific Rules to Consider

// Custom rules you might want

// ❌ Bad: Using Promise where Effect should be used
const fetchData = async () => { }  // Warn in Effect codebase

// ✅ Good: Using Effect
const fetchData = Effect.gen(function* () { })

// ❌ Bad: Throwing errors
const validate = (x: unknown) => {
  if (!x) throw new Error("Invalid")  // Error
}

// ✅ Good: Returning Effect with error
const validate = (x: unknown) =>
  x ? Effect.succeed(x) : Effect.fail(new ValidationError())

// ❌ Bad: Using null/undefined directly
const maybeValue: string | null = null  // Warn

// ✅ Good: Using Option
const maybeValue: Option.Option<string> = Option.none()

Rationale:

Configure Biome (recommended) or ESLint with rules that work well with Effect's functional patterns.

---

Good linting for Effect:

1. Catches errors - Unused variables, missing awaits
2. Enforces style - Consistent code across team
3. Avoids antipatterns - No implicit any, proper typing
4. Fast feedback - Errors in editor immediately

---

---

Set Up CI/CD for Effect Projects

Rule: Use GitHub Actions with proper caching for fast Effect project CI/CD.

Good Example:

1. Basic GitHub Actions Workflow

# .github/workflows/ci.yml
name: CI

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [20.x, 22.x]

    steps:
      - uses: actions/checkout@v4

      - name: Setup Bun
        uses: oven-sh/setup-bun@v1
        with:
          bun-version: latest

      - name: Install dependencies
        run: bun install

      - name: Type check
        run: bun run typecheck

      - name: Lint
        run: bun run lint

      -  
           

        
           

2. With Caching

# .github/workflows/ci-cached.yml
name: CI (Cached)

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Setup Bun
        uses: oven-sh/setup-bun@v1
        with:
          bun-version: latest

      # Cache Bun dependencies
      - name: Cache dependencies
        uses: actions/cache@v4
        with:
          path: |
            ~/.bun/install/cache
            node_modules
          key: ${{ runner.os }}-bun-${{ hashFiles('**/bun.lockb') }}
          restore-keys: |
            ${{ runner.os }}-bun-

      - name: Install dependencies
        run: bun install

      
         
         
        
                           
           
         
           

        
           

        
            

         
         
        
           

3. Package.json Scripts

{
  "scripts": {
    "typecheck": "tsc --noEmit",
    "lint": "biome check .",
    "lint:fix": "biome check --apply .",
    "test": "vitest run",
    "test:watch": "vitest",
    "test:coverage": "vitest run --coverage",
    "build": "tsc",
    "clean": "rm -rf dist .tsbuildinfo"
  }
}

4. Multi-Stage Workflow

# .github/workflows/ci-full.yml
name: CI Full

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: oven-sh/setup-bun@v1
      - run: bun install
      - run: bun run lint

  typecheck:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: oven-sh/setup-bun@v1
      - run: bun install
      - run: bun run typecheck

  test:
    runs-on: ubuntu-latest
    needs: [lint, typecheck]
    steps:
        
        
         
          

  
     
     []
    
        
        
         
          
        
        
           
           

  
     
     []
       
    
        
        
           
      

5. Release Workflow

# .github/workflows/release.yml
name: Release

on:
  push:
    tags:
      - 'v*'

jobs:
  release:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: oven-sh/setup-bun@v1

      - run: bun install
      - run: bun run build
      - run: bun run test

      - name: Create Release
        uses: softprops/action-gh-release@v1
        with:
          files: dist/*
          generate_release_notes: true

Rationale:

Set up CI/CD with type checking, testing, and optional deployment stages optimized for Effect projects.

---

CI/CD for Effect projects ensures:

1. Type safety - Catch type errors before merge
2. Test coverage - Run tests automatically
3. Consistent builds - Same environment every time
4. Fast feedback - Know quickly if something broke

---

---

🟠 Advanced Patterns

Profile Effect Applications

Rule: Use Effect's timing features and Node.js profilers to find performance bottlenecks.

Good Example:

1. Basic Timing with Spans

import { Effect, Duration } from "effect"

// ============================================
// 1. Time individual operations
// ============================================

const timeOperation = <A, E, R>(
  name: string,
  effect: Effect.Effect<A, E, R>
) =>
  Effect.gen(function* () {
    const startTime = Date.now()

    const result = yield* effect

    const duration = Date.now() - startTime
    yield* Effect.log(`${name}: ${duration}ms`)

    return result
  })

// Usage
const program = Effect.gen(function* () {
  yield* timeOperation("database-query", queryDatabase())
  yield* timeOperation("api-call", callExternalApi())
  yield* timeOperation("processing", ())
})





 timedProgram = .(* () {
  * .()

  * ().(.())

  * ().(.())

  * ().(.())

  * .()
}).(.())





 {  }  

 operationDuration = .(, {
  : ,
  : [, , , , , , , , ],
})

 profiledEffect = <A, E, R>
  .(* () {
     startTime = .()

     result = * effect

     duration = .() - startTime
    * .(
      operationDuration.(.(, name)),
      duration
    )

     result
  })





 logMemoryUsage = .( {
   usage = process.()
   {
    : .(usage. /  / ),
    : .(usage. /  / ),
    : .(usage. /  / ),
    : .(usage. /  / ),
  }
})

 withMemoryLogging = <A, E, R>
  .(* () {
     before = * logMemoryUsage
    * .()

     result = * effect

     after = * logMemoryUsage
    * .()
    * .()

     result
  })





 withCpuProfile = <A, E, R>
  .(* () {
    
     inspector = * .( {
       {  } = ()
       session =  ()
      session.()
       session
    })

    * .( {
      inspector.()
      inspector.()
    })

     result = * effect

    
    * .<>( {
      inspector.(,  {
         (err) {
          (.(err))
        }  {
           fs = ()
          fs.(
            ,
            .(profile)
          )
          (.)
        }
      })
    })

     result
  })





 benchmark = <A, E, R>
  .(* () {
     : [] = []

     ( i = ; i < iterations; i++) {
       start = performance.()
      * effect
      times.(performance.() - start)
    }

     sorted = times.( a - b)
     stats = {
      : sorted[],
      : sorted[sorted. - ],
      : sorted[.(sorted. / )],
      : sorted[.(sorted. * )],
      : sorted[.(sorted. * )],
      : times.( a + b, ) / times.,
    }

    * .()
    * .()
    * .()
    * .()
    * .()
    * .()
    * .()

     stats
  })





 profileConcurrency = .(* () {
   items = .({ :  },  i)

  
  * (
    ,
    .(items,  .(i * ), { :  }),
    
  )

  
  * (
    ,
    .(items,  .(i * ), {
      : ,
    }),
    
  )

  
  * (
    ,
    .(items,  .(i * ), { :  }),
    
  )
})





 profilingSession = .(* () {
  * .()

  * (
    (, someEffect, )
  )

  * profileConcurrency
})

.(profilingSession)

Rationale:

Profile Effect applications using built-in timing spans, metrics, and Node.js profiling tools.

---

Profiling helps you:

1. Find bottlenecks - What's slow?
2. Optimize hot paths - Focus effort where it matters
3. Track regressions - Catch slowdowns early
4. Right-size resources - Don't over-provision

---

---

Teach your AI Agents Effect with the MCP Server

Rule: Use the MCP server to provide live application context to AI coding agents, enabling more accurate assistance.

Good Example:

The "Good Example" is the workflow this pattern enables.

1. You run the MCP server in your terminal, pointing it at your main AppLayer.

   npx @effect/mcp-server --layer src/layers.ts:AppLayer
   

2. You configure your AI agent (e.g., Cursor) to use the MCP server's endpoint (http://localhost:3333).

3. You ask the AI a question that requires deep context about your app:

   "Refactor this code to use the UserService to fetch a user by ID and log the result with the Logger."

4. The AI, in the background, queries the MCP server:

   • It discovers that UserService and Logger are available in the AppLayer.
   • It retrieves the exact method signature for UserService.getUser and Logger.log.

5. The AI generates correct, context-aware code because it's not guessing; it's using the live architectural information provided by the MCP server.

// The AI generates this correct code:
import { Effect } from "effect";
import { UserService } from "./features/User/UserService.js";
const program = Effect.gen(function* () {
  const userService = yield* UserService;

  const user = yield* userService.getUser("123");
  yield* Effect.log(`Found user: ${user.name}`);
});

---

Anti-Pattern:

Working with an AI agent without providing it with specific context. The agent will be forced to guess based on open files or generic knowledge. This often leads to it hallucinating method names, getting dependency injection wrong, or failing to handle specific error types, requiring you to manually correct its output and defeating the purpose of using an AI assistant.

Rationale:

To enable AI coding agents (like Cursor or custom bots) to provide highly accurate, context-aware assistance for your Effect application, run the Effect MCP (Meta-Circular-Protocol) server. This tool exposes your application's entire dependency graph and service structure in a machine-readable format.

---

AI coding agents are powerful, but they often lack the deep, structural understanding of a complex Effect application. They might not know which services are available in the context, what a specific Layer provides, or how your feature modules are composed.

The MCP server solves this problem. It's a specialized server that runs alongside your application during development. It inspects your AppLayer and creates a real-time, queryable model of your entire application architecture.

An AI agent can then connect to this MCP server to ask specific questions before generating code, such as:

• "What services are available in the current context?"
• "What is the full API of the UserService?"
• "What errors can UserRepository.findById fail with?"

By providing this live, ground-truth context, you transform your AI from a generic coding assistant into a specialized expert on your specific codebase, resulting in far more accurate and useful code generation and refactoring.

---

---