benchflow-ai/skillsbench/erlang-otp-behaviors

Name: erlang-otp-behaviors
Author: benchflow-ai

Claude Code and agent skill by benchflow-ai/skillsbench

Trust tier 2

community

LLM review pending

By benchflow-ai
AI/ML
benchflow-ai/skillsbench
tasks/fix-erlang-ssh-cve/environment/skills/erlang-otp-behaviors/SKILL.md
Updated 25 Sep 2026
Version 1.0.01 version recorded

Source check pending

Checking that the SKILL.md file is still in the repository.

Use when oTP behaviors including gen_server for stateful processes, gen_statem for state machines, supervisors for fault tolerance, gen_event for event handling, and building robust, production-ready Erlang applications with proven patterns.

Install

npx vskill@latest install benchflow-ai/skillsbench/erlang-otp-behaviors

SKILL.md

Erlang OTP Behaviors

Introduction

OTP (Open Telecom Platform) behaviors provide reusable patterns for common process types in Erlang systems. These abstractions handle complex details like message passing, error handling, and state management, allowing developers to focus on business logic while maintaining system reliability.

Behaviors define interfaces that processes must implement, with OTP handling the infrastructure. Gen_server provides client-server processes, gen_statem implements state machines, supervisors manage process lifecycles, and gen_event coordinates event distribution. Understanding these patterns is essential for production Erlang.

This skill covers gen_server for stateful processes, gen_statem for complex state machines, supervisor trees for fault tolerance, gen_event for event handling, application behavior for packaging, and patterns for building robust OTP systems.

Gen_Server Basics

Gen_server implements client-server processes with synchronous and asynchronous communication.

erlang

-module(counter_server).
-behaviour(gen_server).
 
%% API
-export([start_link/0, increment/0, decrement/0, get_value/0, reset/0]).
 
%% gen_server callbacks
-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).
 
-define(SERVER, ?MODULE).
 
%% State record
-record(state, {count = 0}).
 
%%%===================================================================
%%% API
%%%===================================================================
 
start_link() ->
    gen_server:start_link({local, ?SERVER}, ?MODULE, [], []).
 
increment() ->
    gen_server:cast(?SERVER, increment).
 
decrement() ->
    gen_server:cast(?SERVER, decrement).
 
get_value() ->
    gen_server:call(?SERVER, get_value).
 
reset() ->
    gen_server:call(?SERVER, reset).
 
%%%===================================================================
%%% gen_server callbacks
%%%===================================================================
 
init([]) ->
    {ok, #state{}}.
 
%% Synchronous calls (with response)
handle_call(get_value, _From, State) ->
    {reply, State#state.count, State};
 
handle_call(reset, _From, State) ->
    {reply, ok, State#state{count = 0}};
 
handle_call(_Request, _From, State) ->
    {reply, ignored, State}.
 
%% Asynchronous casts (no response)
handle_cast(increment, State) ->
    NewCount = State#state.count + 1,
    {noreply, State#state{count = NewCount}};
 
handle_cast(decrement, State) ->
    NewCount = State#state.count - 1,
    {noreply, State#state{count = NewCount}};
 
handle_cast(_Msg, State) ->
    {noreply, State}.
 
%% Handle other messages
handle_info(_Info, State) ->
    {noreply, State}.
 
terminate(_Reason, _State) ->
    ok.
 
code_change(_OldVsn, State, _Extra) ->
    {ok, State}.
 
%%%===================================================================
%%% Complex gen_server example: Cache
%%%===================================================================
 
-module(cache_server).
-behaviour(gen_server).
 
-export([start_link/1, put/2, get/1, delete/1, clear/0, size/0]).
-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).
 
-record(state, {
    cache = #{},
    max_size = 1000,
    hits = 0,
    misses = 0
}).
 
start_link(MaxSize) ->
    gen_server:start_link({local, ?MODULE}, ?MODULE, [MaxSize], []).
 
put(Key, Value) ->
    gen_server:call(?MODULE, {put, Key, Value}).
 
get(Key) ->
    gen_server:call(?MODULE, {get, Key}).
 
delete(Key) ->
    gen_server:cast(?MODULE, {delete, Key}).
 
clear() ->
    gen_server:cast(?MODULE, clear).
 
size() ->
    gen_server:call(?MODULE, size).
 
init([MaxSize]) ->
    process_flag(trap_exit, true),
    {ok, #state{max_size = MaxSize}}.
 
handle_call({put, Key, Value}, _From, State) ->
    Cache = State#state.cache,
    case maps:size(Cache) >= State#state.max_size of
        true ->
            {reply, {error, cache_full}, State};
        false ->
            NewCache = maps:put(Key, Value, Cache),
            {reply, ok, State#state{cache = NewCache}}
    end;
 
handle_call({get, Key}, _From, State) ->
    Cache = State#state.cache,
    case maps:find(Key, Cache) of
        {ok, Value} ->
            NewState = State#state{hits = State#state.hits + 1},
            {reply, {ok, Value}, NewState};
        error ->
            NewState = State#state{misses = State#state.misses + 1},
            {reply, not_found, NewState}
    end;
 
handle_call(size, _From, State) ->
    Size = maps:size(State#state.cache),
    {reply, Size, State};
 
handle_call(_Request, _From, State) ->
    {reply, {error, unknown_request}, State}.
 
handle_cast({delete, Key}, State) ->
    NewCache = maps:remove(Key, State#state.cache),
    {noreply, State#state{cache = NewCache}};
 
handle_cast(clear, State) ->
    {noreply, State#state{cache = #{}}};
 
handle_cast(_Msg, State) ->
    {noreply, State}.
 
handle_info(_Info, State) ->
    {noreply, State}.
 
terminate(Reason, State) ->
    io:format("Cache terminating: ~p~n", [Reason]),
    io:format("Stats - Hits: ~p, Misses: ~p~n", [State#state.hits, State#state.misses]),
    ok.
 
code_change(_OldVsn, State, _Extra) ->
    {ok, State}.
 
%%%===================================================================
%%% gen_server with timeouts
%%%===================================================================
 
-module(session_server).
-behaviour(gen_server).
 
-export([start_link/0, touch/0]).
-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).
 
-define(TIMEOUT, 30000). % 30 seconds
 
-record(state, {
    last_activity,
    data = #{}
}).
 
start_link() ->
    gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).
 
touch() ->
    gen_server:cast(?MODULE, touch).
 
init([]) ->
    {ok, #state{last_activity = erlang:system_time(millisecond)}, ?TIMEOUT}.
 
handle_call(_Request, _From, State) ->
    {reply, ok, State, ?TIMEOUT}.
 
handle_cast(touch, State) ->
    NewState = State#state{last_activity = erlang:system_time(millisecond)},
    {noreply, NewState, ?TIMEOUT};
 
handle_cast(_Msg, State) ->
    {noreply, State, ?TIMEOUT}.
 
handle_info(timeout, State) ->
    io:format("Session timed out~n"),
    {stop, normal, State};
 
handle_info(_Info, State) ->
    {noreply, State, ?TIMEOUT}.
 
terminate(_Reason, _State) ->
    ok.
 
code_change(_OldVsn, State, _Extra) ->
    {ok, State}.

Gen_server provides structure for stateful processes with client-server patterns.

Gen_Statem for State Machines

Gen_statem implements finite state machines with explicit state transitions.

erlang

-module(door_fsm).
-behaviour(gen_statem).
 
-export([start_link/0, open/0, close/0, lock/0, unlock/1]).
-export([init/1, callback_mode/0, terminate/3, code_change/4]).
-export([locked/3, unlocked/3, open/3]).
 
-define(CODE, "1234").
 
start_link() ->
    gen_statem:start_link({local, ?MODULE}, ?MODULE, [], []).
 
open() ->
    gen_statem:call(?MODULE, open).
 
close() ->
    gen_statem:call(?MODULE, close).
 
lock() ->
    gen_statem:call(?MODULE, lock).
 
unlock(Code) ->
    gen_statem:call(?MODULE, {unlock, Code}).
 
init([]) ->
    {ok, locked, #{}}.
 
callback_mode() ->
    state_functions.
 
%% Locked state
locked(call, {unlock, Code}, Data) when Code =:= ?CODE ->
    {next_state, unlocked, Data, [{reply, ok}]};
 
locked(call, {unlock, _WrongCode}, Data) ->
    {keep_state, Data, [{reply, {error, wrong_code}}]};
 
locked(call, _Event, Data) ->
    {keep_state, Data, [{reply, {error, door_locked}}]}.
 
%% Unlocked state
unlocked(call, lock, Data) ->
    {next_state, locked, Data, [{reply, ok}]};
 
unlocked(call, open, Data) ->
    {next_state, open, Data, [{reply, ok}]};
 
unlocked(call, _Event, Data) ->
    {keep_state, Data, [{reply, ok}]}.
 
%% Open state
open(call, close, Data) ->
    {next_state, unlocked, Data, [{reply, ok}]};
 
open(call, _Event, Data) ->
    {keep_state, Data, [{reply, {error, door_open}}]}.
 
terminate(_Reason, _State, _Data) ->
    ok.
 
code_change(_OldVsn, State, Data, _Extra) ->
    {ok, State, Data}.
 
%%%===================================================================
%%% Connection state machine
%%%===================================================================
 
-module(connection_fsm).
-behaviour(gen_statem).
 
-export([start_link/0, connect/0, disconnect/0, send/1]).
-export([init/1, callback_mode/0, terminate/3, code_change/4]).
-export([disconnected/3, connecting/3, connected/3]).
 
-record(data, {
    socket = undefined,
    buffer = <<>>,
    retry_count = 0
}).
 
start_link() ->
    gen_statem:start_link({local, ?MODULE}, ?MODULE, [], []).
 
connect() ->
    gen_statem:call(?MODULE, connect).
 
disconnect() ->
    gen_statem:call(?MODULE, disconnect).
 
send(Data) ->
    gen_statem:call(?MODULE, {send, Data}).
 
init([]) ->
    {ok, disconnected, #data{}}.
 
callback_mode() ->
    [state_functions, state_enter].
 
%% Disconnected state
disconnected(enter, _OldState, _Data) ->
    io:format("Entered disconnected state~n"),
    keep_state_and_data;
 
disconnected(call, connect, Data) ->
    case connect_to_server() of
        {ok, Socket} ->
            {next_state, connected, Data#data{socket = Socket, retry_count = 0},
             [{reply, ok}]};
        error ->
            NewData = Data#data{retry_count = Data#data.retry_count + 1},
            case NewData#data.retry_count < 3 of
                true ->
                    {next_state, connecting, NewData, [{reply, {error, retrying}}]};
                false ->
                    {keep_state, NewData, [{reply, {error, max_retries}}]}
            end
    end.
 
%% Connecting state
connecting(enter, _OldState, _Data) ->
    erlang:send_after(1000, self(), retry_connect),
    keep_state_and_data;
 
connecting(info, retry_connect, Data) ->
    case connect_to_server() of
        {ok, Socket} ->
            {next_state, connected, Data#data{socket = Socket, retry_count = 0}};
        error ->
            NewData = Data#data{retry_count = Data#data.retry_count + 1},
            case NewData#data.retry_count < 3 of
                true ->
                    {keep_state, NewData};
                false ->
                    {next_state, disconnected, NewData}
            end
    end.
 
%% Connected state
connected(enter, _OldState, _Data) ->
    io:format("Connection established~n"),
    keep_state_and_data;
 
connected(call, {send, Data}, StateData) ->
    case send_data(StateData#data.socket, Data) of
        ok ->
            {keep_state_and_data, [{reply, ok}]};
        error ->
            {next_state, disconnected, StateData, [{reply, {error, send_failed}}]}
    end;
 
connected(call, disconnect, StateData) ->
    close_connection(StateData#data.socket),
    {next_state, disconnected, StateData#data{socket = undefined}, [{reply, ok}]}.
 
terminate(_Reason, _State, Data) ->
    case Data#data.socket of
        undefined -> ok;
        Socket -> close_connection(Socket)
    end.
 
code_change(_OldVsn, State, Data, _Extra) ->
    {ok, State, Data}.
 
%% Helper functions
connect_to_server() ->
    {ok, socket}.
 
send_data(_Socket, _Data) ->
    ok.
 
close_connection(_Socket) ->
    ok.

Gen_statem provides structured state machine implementation with explicit transitions.

Supervisor Trees

Supervisors monitor child processes and restart them on failure for fault tolerance.

erlang

-module(my_supervisor).
-behaviour(supervisor).
 
-export([start_link/0]).
-export([init/1]).
 
start_link() ->
    supervisor:start_link({local, ?MODULE}, ?MODULE, []).
 
init([]) ->
    SupFlags = #{
        strategy => one_for_one,
        intensity => 5,
        period => 60
    },

This is the start of the file. Read the full SKILL.md on GitHub.

Security

Security scanPassed, 100 of 100Pattern checks on the skill's files.
Model reviewNot runA model review is scheduled for the next rescan.

See the full security report

Quality evaluation

Task evaluationNot runNo evaluation yet. Run one in Skill Studio.

See evaluation results

Source

SKILL.md in the repositoryCheckingtasks/fix-erlang-ssh-cve/environment/skills/erlang-otp-behaviors/SKILL.md

Popularity

Repository stars: 1,474
Repository forks: 325
7-day trend score: 36

Stars and forks are for the whole GitHub repository, not this skill alone. Not refreshed yet.

Works with

Any agent vskill installs to: 56 targets in all. These 39 have a page on this site.

Claude Code
Cursor
GitHub Copilot
Windsurf
Codex
Gemini CLI
Cline
Amp
Roo Code
Goose
Continue
Kilo Code
Junie
Trae
OpenHands
Qwen Code
AI Agent
Tabnine Chat
Sourcegraph Cody
Amazon Q
Firebase Genkit
Sweep
Devin
Phind
Mentat
Claude Desktop
Aider
GPT Pilot
Plandex
bolt.new
v0
Replit Agent
Anse
TypingMind
BetterChatGPT
LibreChat
Warp AI
Pieces
Fig AI

Embed badge

[![vskill VERIFIED](https://verified-skill.com/api/v1/skills/benchflow-ai/skillsbench/erlang-otp-behaviors/badge)](https://verified-skill.com/skills/benchflow-ai/skillsbench/erlang-otp-behaviors)

Something wrong with this skill or its page? Tell us.