Gleam OTP Development Skill

This skill guides Claude Code through building concurrent, fault-tolerant applications with Gleam OTP.

Primary Sources

1. •Gleam OTP Documentation - Complete OTP reference
2. •Gleam OTP GitHub Examples - Official examples
3. •Gleam OTP: Using Supervisors - Supervisor tutorial
4. •Gleam OTP Design Principals - Design patterns
5. •Actor Documentation - Actor API reference
6. •Supervisor Documentation - Supervisor API reference

Quick Reference

Core Modules

• •gleam/otp/actor - Actor processes with type-safe messaging
• •gleam/otp/supervisor - Supervision trees
• •gleam/otp/static_supervisor - Static supervision configuration
• •gleam/otp/task - One-off concurrent tasks
• •gleam/erlang/process - Low-level process operations

See: Gleam OTP Modules

Common Workflows

Creating a New OTP Application

gleam new my_otp_app
cd my_otp_app
gleam add gleam_otp gleam_erlang

Basic Actor Pattern

Consult the actor documentation for:

• •Creating actors: Actor - start
• •Message handling: Actor - Next
• •Calling actors: Actor - call

Supervision Tree Setup

For supervision patterns, see:

• •Supervisor - start
• •Supervisor - add
• •Supervisor - worker

Example structure:

Application Supervisor
├── Database Pool Supervisor
│   ├── Connection 1
│   ├── Connection 2
│   └── Connection N
├── Web Server Supervisor
│   ├── HTTP Listener
│   └── Request Handlers
└── Background Job Supervisor
    └── Worker Pool

See: Gleam OTP: Using Supervisors

One-Off Tasks

For concurrent one-off operations: Task Module

Alternative with more features: Taskle Library

Design Patterns

GenServer-Style Actor

// State, Message types, start function, handle function

See complete examples: Actor Examples

Worker Pool

For worker pool implementation patterns: Gleam OTP Design Principals

Event Manager

For pub/sub patterns, consult:

• •Process - send
• •Custom event manager implementations

Registry Pattern

For process registration and discovery: Process - register

Supervision Strategies

Choose the right restart strategy:

OneForOne

Restart only the failed child. Use for: Independent workers

OneForAll

Restart all children if one fails. Use for: Tightly coupled processes

RestForOne

Restart failed child and all started after it. Use for: Dependent process chains

See: Supervisor Strategies

Testing OTP Applications

Testing Actors

import gleam/otp/actor

pub fn actor_test() {
  let assert Ok(actor.Started(subject, _)) = start_my_actor()
  let result = actor.call(subject, waiting: 100, sending: fn(s) { MyMessage(s) })
  let assert expected = result
}

Testing Supervisors

Test supervision behavior:

• •Child starts correctly
• •Child restarts on crash
• •Supervisor respects max restart limits

See: Testing Guide

Monitoring and Debugging

Erlang Observer

Monitor your OTP application:

iex -S mix  # For Elixir projects
erl  # For Erlang projects

Then: :observer.start()

Process Monitoring

Use process monitoring functions: Process - monitor

Logging

Integrate logging: Palabres - OTP Logging

Common Anti-Patterns

Refer to: OTP Anti-Patterns

Key anti-patterns to avoid:

• •Processes as state (use variables instead)
• •Unsupervised processes
• •Large messages between processes
• •Using processes for code organization

Libraries for OTP Development

Core

• •gleam_otp - OTP framework
• •gleam_erlang - Erlang runtime

Extended

• •taskle - Elixir-like Task functionality
• •glixir - Safe Gleam-Elixir OTP interop

Utilities

• •palabres - Logging for OTP apps

Hot Code Reloading

Gleam supports Erlang's hot code reloading, but type safety isn't guaranteed during upgrades.

See: Gleam FAQ - Hot Code Reloading

Deployment Considerations

Release Building

Use Gleam's Erlang release functionality:

gleam export erlang-shipment

See: Deploying to Fly.io

Configuration

Use environment variables: Envoy Library

Clustering

For distributed Erlang clusters, consult:

• •Gleam Erlang - Node
• •Erlang distribution documentation

Example Applications

Find complete OTP application examples:

• •Gleam OTP Examples
• •Community projects using OTP

When to Use OTP

✅ Use OTP when you need:

• •Long-running stateful services
• •Fault tolerance and automatic restarts
• •Concurrent independent operations
• •Process isolation

❌ Don't use OTP for:

• •Simple pure computations
• •Organizing code (use modules)
• •Holding simple state (use variables)

See: OTP Patterns

Remember: OTP is powerful but has specific use cases. Consult official documentation for current patterns and best practices.