← all publishers

mpsuesser

@mpsuesser source repo

Report this profile Claim this profile

• 53 skills
• 0 followers
• 17 hours ago last updated

1. ▌
   Effect CLI · mpsuesser

   Build type-safe CLI applications using Effect CLI module for argument parsing, options, commands, and dependency injection.
   0
   installs
2. ▌
   Effect SQL · mpsuesser

   Type-safe SQL with Effect — SqlClient tagged-template queries, SqlSchema, SqlModel CRUD repositories, SqlResolver batching, and Migrator. Use when working with databases, writing queries, defining models, or setting up migrations.
   0
   installs
3. ▌
   Effect Path · mpsuesser

   Use effect Path for platform-abstract file path operations including joining, resolving, and URL conversion.
   0
   installs
4. ▌
   Effect Cache · mpsuesser

   Cache effectful lookups in memory with Cache and ScopedCache — capacity/LRU eviction, fixed or exit-aware TTL, deduplicated concurrent lookups, refresh/invalidation, and resource-owning entries with per-entry scopes. Use when memoizing effectful lookups by key, adding TTL caching to API or DB reads, deduplicating concurrent fetches of the same key, or caching values that own resources such as connections.
   0
   installs
5. ▌
   Effect Fiber · mpsuesser

   Fork, supervise, and interrupt Effect fibers with Effect.forkChild/forkScoped/forkIn/forkDetach, Fiber join/await/interrupt, uninterruptible regions, and the FiberHandle/FiberMap/FiberSet supervision collections. Use when running background work, cancelling or restarting tasks, implementing latest-wins or keyed workers, bridging Effect into callback APIs, or debugging interruption and fiber lifetime issues.
   0
   installs
6. ▌
   Effect Graph · mpsuesser

   Build and analyze immutable graphs with Effect's Graph module — directed/undirected construction, scoped mutation (mutate/addNode/addEdge), node/edge queries, lazy DFS/BFS/topo walkers, algorithms (isAcyclic, stronglyConnectedComponents, dijkstra/astar/bellmanFord/floydWarshall), and GraphViz/Mermaid export. Use when modeling dependency graphs, ordering tasks topologically, detecting cycles, computing reachability or shortest paths, or rendering relationship diagrams.
   0
   installs
7. ▌
   Effect Scope · mpsuesser

   Manage resource lifecycles with Effect Scope — Effect.acquireRelease/addFinalizer/scoped/scopedWith, onExit/ensuring finalizers, manual Scope.make/close/fork, ScopedRef, and scope ownership in Layers and fibers. Use when acquiring anything that needs guaranteed cleanup (file handles, connections, event listeners, temp files), when Scope appears in an effect's R, or when resources leak or are released too early.
   0
   installs
8. ▌
   Effect Config · mpsuesser

   Load and validate typed configuration with Config and ConfigProvider. Use this skill when reading environment variables, building structured config, providing test config, or working with .env files, JSON config, and custom config sources.
   0
   installs
9. ▌
   Effect Optics · mpsuesser

   Use Effect Optic for composable, type-safe access and immutable updates to nested data structures. Covers Iso, Lens, Prism, Optional, and Traversal — when to use each, how to compose them, and practical patterns for deep updates, tagged unions, and filtered collections.
   0
   installs
10. ▌
    Effect Socket · mpsuesser

    Build bidirectional socket transports with effect/unstable/socket — the Socket run/writer surface, WebSocket-backed sockets, TCP/Unix-domain clients via NodeSocket, SocketServer accept loops, channel adapters, the SocketError taxonomy, and reconnect patterns. Use when connecting to or serving raw TCP, Unix-domain, or WebSocket endpoints, framing socket bytes with Stream/Channel (NDJSON), building reconnecting socket clients, or providing socket transports to RPC/devtools layers.
    0
    installs
11. ▌
    Effect Stream · mpsuesser

    Build effectful pull-based streaming pipelines with Effect Stream — creation, transformation, consumption, NDJSON/Msgpack encoding, concurrency, resource safety. Use when working with values produced over time, paginated APIs, event listeners, or streaming I/O.
    0
    installs
12. ▌
    Effect AI Chat · mpsuesser

    Build stateful AI chat sessions with the Effect Chat module. Use this skill when implementing multi-turn conversations, agentic tool-calling loops, chat persistence, streaming chat responses, or structured object generation within a conversation context.
    0
    installs
13. ▌
    Effect AI Tool · mpsuesser

    Define and implement AI tools using Effect AI's Tool and Toolkit APIs. Use when building LLM integrations with type-safe tool definitions, parameter validation, and handler implementations. Covers user-defined tools, provider-defined tools, and toolkit composition.
    0
    installs
14. ▌
    Effect Rpc API · mpsuesser

    Define type-safe RPC contracts with effect/unstable/rpc — Rpc.make payload/success/error/defect schemas, RpcSchema.Stream streaming responses, RpcGroup composition (add/merge/omit/prefix/annotate), and RpcMiddleware.Service definitions shared by client and server. Use when declaring or evolving RPC procedures, building a shared contract package, adding streaming endpoints, or defining auth/observability middleware types.
    0
    installs
15. ▌
    Effect Testing · mpsuesser

    Write comprehensive tests using @effect/vitest for Effect code and vitest for pure functions. Use this skill when implementing tests for Effect-based applications, including services, layers, time-dependent effects, error handling, and property-based testing.
    0
    installs
16. ▌
    Effect Atom Rpc · mpsuesser

    Build reactive Atom-aware RPC clients for React/Atom UIs using AtomRpc. Provides cached query atoms, invalidating mutation atoms, SSR hydration, and reactivity-key invalidation on top of an RpcGroup.
    0
    installs
17. ▌
    Effect Batching · mpsuesser

    Implement automatic request batching and deduplication using Effect's Request, RequestResolver, and SqlResolver APIs. Use this skill when solving N+1 query problems, building batched data-fetching layers, or integrating request caching with resolvers.
    0
    installs
18. ▌
    Effect HTTP API · mpsuesser

    Build typed HTTP APIs with Effect's HttpApi — endpoints with schemas, handlers, security middleware, OpenAPI docs, derived clients, and handler unit tests. Use when building HTTP servers, REST APIs, or typed HTTP clients with Effect v4.
    0
    installs
19. ▌
    Effect Workflow · mpsuesser

    Build durable workflows with Effect using Workflow, Activity, DurableClock, DurableDeferred, and DurableQueue for execution that survives restarts, supports compensation (saga pattern), and integrates with Effect Cluster for distribution.
    0
    installs
20. ▌
    Effect AI Prompt · mpsuesser

    Build prompts for Effect AI using messages, parts, and composition operators. Covers the complete Prompt API for constructing, merging, and manipulating conversations with language models.
    0
    installs
21. ▌
    Effect Schema V4 · mpsuesser

    Authoritative reference for Effect Schema v4 API changes and migration patterns from v3. Use this skill when writing Schema code to avoid v3 patterns, when migrating existing v3 Schema code, or when unsure about current Schema API names.
    0
    installs
22. ▌
    Effect Atom State · mpsuesser

    Implement reactive state management with Effect Atom for React applications
    0
    installs
23. ▌
    Effect Filesystem · mpsuesser

    Use Effect FileSystem for platform-abstract file I/O with Node.js/Bun layers or custom implementations.
    0
    installs
24. ▌
    Effect MCP Server · mpsuesser

    Build MCP (Model Context Protocol) servers with Effect using McpServer, McpSchema, Tool, and Toolkit. Use this skill when implementing MCP servers that expose tools, resources, and prompts to LLM clients via stdio or HTTP transports.
    0
    installs
25. ▌
    Effect Rpc Client · mpsuesser

    Consume typed RPC services with Effect's RpcClient — protocol layers (HTTP, WebSocket, TCP, worker, in-memory), RpcSerialization codecs, per-call and ambient headers, streaming calls, interruption, reconnection, and RpcClientError handling. Use when calling an RpcGroup from a client, wiring a client transport + serialization stack, debugging RPC transport failures or reconnects, or testing RPC consumers with RpcTest.
    0
    installs
26. ▌
    Effect Rpc Server · mpsuesser

    Serve RpcGroup contracts with Effect's RpcServer — handler layers (RpcGroup.toLayer/toLayerHandler), protocol layers (HTTP, WebSocket, TCP, stdio, worker), RpcSerialization, server middleware, streaming results, interruption and shutdown semantics, RpcTest. Use when implementing the server side of an Effect RPC API, mounting RPC on an HttpRouter or existing HTTP app, choosing a wire format, implementing RpcMiddleware, handling client aborts, or testing RPC handlers.
    0
    installs
27. ▌
    Effect Scheduling · mpsuesser

    Design Effect v4 retries, repeats, polling, pacing, backoff, jitter, rate-limit-aware delays, and timeouts with Schedule. Use when replacing manual sleep loops or defining recurrence and failure policy.
    0
    installs
28. ▌
    Effect AI Provider · mpsuesser

    Configure and compose AI provider layers using @effect/ai packages. Covers Anthropic, OpenAI, OpenAI-Compat, and OpenRouter providers with config management, model abstraction, ExecutionPlan fallback, and runtime overrides for language model integration.
    0
    installs
29. ▌
    Effect HTTP Client · mpsuesser

    Make outgoing HTTP requests with Effect's HttpClient — HttpClientRequest builders, schema-decoded HttpClientResponse bodies, the HttpClientError taxonomy, retryTransient/rate limiting/cookies/redirects, streaming uploads and downloads, and FetchHttpClient/NodeHttpClient transport layers. Use when calling external REST/JSON APIs, uploading or downloading files and streams, adding retries/auth/tracing to outbound HTTP, or mocking HTTP responses in tests.
    0
    installs
30. ▌
    Effect HTTP Server · mpsuesser

    Build HTTP servers with effect/unstable/http — HttpRouter routes and middleware, HttpServerRequest schema decoding, HttpServerResponse constructors, multipart uploads, websocket upgrades, static files, NodeHttpServer/BunHttpServer layers, and in-memory web handlers. Use when serving raw HTTP routes, reading request bodies/cookies/uploads, writing server middleware, streaming responses, or testing handlers without a real port.
    0
    installs
31. ▌
    Effect Rpc Cluster · mpsuesser

    Build typed RPC endpoints and cluster-distributed entities, singletons, cron jobs, and durable workflows with Effect's RPC and Cluster modules (Rpc/RpcGroup/RpcServer/RpcClient, Entity/Sharding/Singleton, Node/Bun bundles). Use when building RPC services or distributed/clustered Effect systems.
    0
    installs
32. ▌
    Effect Wide Events · mpsuesser bundle

    Conceptual guide to wide events (canonical log lines) for observability. Use when thinking about instrumentation strategy, span annotations, or designing what context to capture.
    0
    installs
33. ▌
    Effect AI Streaming · mpsuesser

    Master Effect AI streaming response patterns including start/delta/end protocol, accumulation strategies, resource-safe consumption, and history management with SubscriptionRef.
    0
    installs
34. ▌
    Effect Layer Design · mpsuesser

    Design and compose Effect layers for clean dependency management
    0
    installs
35. ▌
    Effect Observability · mpsuesser

    Implement structured logging, distributed tracing, and metrics in Effect applications. Use this skill when configuring loggers, adding spans/tracing, collecting metrics, or setting up OTLP/Prometheus export.
    0
    installs
36. ▌
    Effect Error Handling · mpsuesser

    Implement typed error handling in Effect v4 using Schema.TaggedError, catchTag/catchTags, catchReason/catchReasons, Cause, ErrorReporter, and recovery patterns. Use this skill when working with Effect error channels, handling expected failures, or designing error recovery strategies.
    0
    installs
37. ▌
    Effect Context Witness · mpsuesser

    Decide between Context.Service witness and capability patterns for dependency injection, understanding coupling trade-offs
    0
    installs
38. ▌
    Effect Domain Modeling · mpsuesser

    Build schema-first Effect domain models with Schema.Class variants, tagged unions, branded values, legal state transitions, predicates, equivalence, and orders. Use when modeling domain entities, value objects, or discriminated unions.
    0
    installs
39. ▌
    Effect Managed Runtime · mpsuesser

    Bridge Effect services into non-Effect frameworks (Hono, Express, Fastify, Lambda, Workers) using ManagedRuntime. Use this skill when you need to run Effects outside of runMain — in HTTP handlers, serverless functions, or any embedded context where Effect doesn't own the process lifecycle.
    0
    installs
40. ▌
    Effect Parallelization · mpsuesser

    Run Effect computations concurrently with Effect.all/forEach concurrency options, racing combinators (race, raceAll, raceFirst), and coordination primitives (Semaphore, PartitionedSemaphore, Latch). Use when fanning out work over a collection, limiting parallelism, racing alternatives for first-success, enforcing per-key or global rate limits, or gating fibers on a startup signal.
    0
    installs
41. ▌
    Effect Platform Layers · mpsuesser

    Structure Effect platform layer provision for cross-platform applications using Effect platform abstractions.
    0
    installs
42. ▌
    Effect Command Executor · mpsuesser

    Spawn and manage child processes using Effect's ChildProcess module. Use this skill when running shell commands, capturing process output, piping commands, streaming long-running process output, or managing process lifecycles with scoped cleanup.
    0
    installs
43. ▌
    Effect Pattern Matching · mpsuesser

    Match schema tagged unions with match/matchOrElse and guards, trusted Data.TaggedEnum values with $match/$is, and Effect outcomes with Effect.match. Use for discriminated unions, ADTs, or conditional logic based on tagged types.
    0
    installs
44. ▌
    Effect Pubsub Event Bus · mpsuesser

    Build typed event buses using Effect PubSub and Stream. Use this skill when implementing publish/subscribe communication between services, replacing callback-based event systems, or building reactive service architectures with typed event streams.
    0
    installs
45. ▌
    Effect Typeclass Design · mpsuesser

    Implement typeclasses with curried signatures and dual APIs for both data-first and data-last usage
    0
    installs
46. ▌
    Effect AI Language Model · mpsuesser

    Master the Effect AI LanguageModel service for text generation, structured output, streaming, and tool calling. Use when working with LLM interactions, schema-validated responses, or building conversational AI systems.
    0
    installs
47. ▌
    Effect Domain Predicates · mpsuesser

    Generate comprehensive predicates and orders for domain types using typeclass patterns
    0
    installs
48. ▌
    Effect React Composition · mpsuesser

    Build composable React components using Effect Atom for state management. Use this skill when implementing React UIs that avoid boolean props, embrace component composition, and integrate with Effect's reactive state system.
    0
    installs
49. ▌
    Effect Schema Composition · mpsuesser

    Master Effect Schema composition patterns including Schema.decodeTo, transformations, filters, and validation. Use this skill when working with complex schema compositions, multi-step transformations, or when you need to validate and transform data through multiple stages.
    0
    installs
50. ▌
    Effect Concurrency Testing · mpsuesser

    Test Effect concurrency primitives including PubSub, Deferred, Latch, Fiber coordination, SubscriptionRef, and Stream. Use this skill when testing concurrent effects, event-driven systems, or fiber coordination.
    0
    installs
51. ▌
    Effect Platform Abstraction · mpsuesser

    Use Effect platform abstractions for cross-platform file I/O, process spawning, HTTP clients, cryptography, and terminal I/O. Apply when writing filesystem/process/HTTP/crypto/console code that must stay portable across Node.js, Bun, and browser adapters.
    0
    installs
52. ▌
    Effect Incremental Migration · mpsuesser

    Incrementally migrate existing async/Promise-based modules to Effect services while preserving backward compatibility. Use this skill when effectifying an existing module, replacing async facades with Effect services, or maintaining dual async/Effect APIs during migration.
    0
    installs
53. ▌
    Effect Service Implementation · mpsuesser

    Implement Effect services as fine-grained capabilities avoiding monolithic designs
    0
    installs