letta-ai/skills

118 skills2.3K total installs Github

Skill

Installs

extracting-pdf-text

Extract text from PDFs for LLM consumption. Use when processing PDFs for RAG, document analysis, or text extraction. Supports API services (Mistral OCR) and local tools (PyMuPDF, pdfplumber). Handles text-based PDFs, tables, and scanned documents with OCR.

portfolio-optimization

Guidance for implementing high-performance portfolio optimization using Python C extensions. This skill applies when tasks require optimizing financial computations (matrix operations, covariance calculations, portfolio risk metrics) by implementing C extensions for Python. Use when performance speedup requirements exist (e.g., 1.2x or greater) and the task involves numerical computations on large datasets (thousands of assets).

video-processing

Guide for video analysis and frame-level event detection tasks using OpenCV and similar libraries. This skill should be used when detecting events in videos (jumps, movements, gestures), extracting frames, analyzing motion patterns, or implementing computer vision algorithms on video data. It provides verification strategies and helps avoid common pitfalls in video processing workflows.

google-workspace

Connect to Gmail and Google Calendar via OAuth 2.0. Use when users want to search/read emails, create drafts, search calendar events, check availability, or schedule meetings. Triggers on queries about email, inbox, calendar, schedule, or meetings.

gmail-integration

Connect Letta Code to Gmail via OAuth 2.0 and perform email operations. Use when a user wants to set up Gmail access, search their inbox, read emails, create draft messages, or manage their inbox. Triggers on queries about email, Gmail, inbox, drafting messages, or searching mail.

imessage

Send and read iMessages/SMS from macOS. Use for texting contacts, scheduling services, or automating message-based workflows. Triggers on queries about texting, messaging, SMS, iMessage, or contacting someone via text.

code-from-image

Guide for extracting code or pseudocode from images using OCR and implementing it correctly. This skill should be used when tasks involve reading code, pseudocode, or algorithms from images (PNG, JPG, screenshots) and executing or implementing the extracted logic.

headless-terminal

This skill provides guidance for implementing headless terminal interfaces that programmatically control shell sessions. Use this skill when implementing terminal emulation, pseudo-terminal wrappers, or interfaces like BaseTerminal that require sending keystrokes and reading output from shell processes.

financial-document-processor

Guidance for processing financial documents (invoices, receipts, statements) with OCR and text extraction. This skill should be used when tasks involve extracting data from financial PDFs or images, generating summaries (CSV/JSON), or moving/organizing processed documents. Emphasizes data safety practices to prevent catastrophic data loss.

cobol-modernization

Guidance for converting COBOL programs to modern languages (Python, Java, etc.) while preserving exact behavior and data format compatibility. This skill should be used when modernizing legacy COBOL applications, converting COBOL business logic to modern languages, or ensuring byte-for-byte output compatibility between COBOL and its replacement.

large-scale-text-editing

Provides strategies for efficiently transforming large text files (thousands to millions of lines) using text editors like Vim, sed, or awk. This skill should be used when tasks involve bulk text transformations, CSV manipulation at scale, pattern-based edits across massive files, or when keystroke/operation efficiency is constrained. Applicable to tasks requiring macros, regex substitutions, or batch processing of structured text data.

letta-development-guide

Comprehensive guide for developing Letta agents, including architecture selection, memory design, model selection, and tool configuration. Use when building or troubleshooting Letta agents.

constraints-scheduling

Provides systematic approaches for solving constraint-based scheduling problems, such as finding meeting times that satisfy multiple participant availability windows, preferences, and existing calendar conflicts. This skill should be used when tasks involve scheduling with constraints, calendar conflict resolution, time slot optimization, or finding valid time windows across multiple inputs with hard and soft constraints.

learning-sdk-integration

Integration patterns and best practices for adding persistent memory to LLM agents using the Letta Learning SDK

fix-code-vulnerability

Guidance for identifying and fixing security vulnerabilities in code. This skill should be used when asked to fix security issues, address CVEs or CWEs, remediate vulnerabilities like injection attacks (SQL, command, CRLF, XSS), or when working with failing security-related tests.

yelp-search

Search Yelp for local businesses, get contact info, ratings, and hours. Use when finding services (cleaners, groomers, restaurants, etc.), looking up business phone numbers to text, or checking ratings before booking. Triggers on queries about finding businesses, restaurants, services, or "look up on Yelp".

llm-inference-batching-scheduler

Guidance for optimizing LLM inference request batching and scheduling problems. This skill applies when designing batch schedulers that minimize cost while meeting latency and padding constraints, involving trade-offs between batch count, shape selection, and padding ratios. Use when the task involves grouping requests by sequence lengths, managing shape compilation costs, or optimizing multi-objective scheduling with hard constraints.

modernize-scientific-stack

Guide for modernizing legacy Python 2 scientific computing code to Python 3 with modern libraries. This skill should be used when migrating scientific scripts involving data processing, numerical computation, or analysis from Python 2 to Python 3, or when updating deprecated scientific computing patterns to modern equivalents (pandas, numpy, pathlib).

chess-best-move

Guide for analyzing chess board images to find the best move(s). This skill should be used when tasks involve analyzing chess positions from images, detecting piece positions, identifying winning moves, or solving chess puzzles. Applies to tasks requiring image-based chess board analysis and move calculation.

git-multibranch

Guidance for setting up Git-based multi-branch deployment systems with SSH access, web servers, and automated deployment hooks. This skill should be used when configuring Git repositories that deploy to multiple environments (e.g., main/dev branches), setting up SSH authentication for Git, configuring web servers to serve content from different branches, or creating post-receive hooks for automated deployments.

letta-fleet-management

Manage Letta AI agent fleets declaratively with kubectl-style CLI. Use when creating, updating, or managing multiple Letta agents with shared configurations, memory blocks, tools, and folders.

fix-git

Guide for recovering lost Git commits, resolving detached HEAD states, and fixing common Git repository issues. This skill should be used when users need help recovering from Git mistakes such as lost commits, detached HEAD situations, accidental resets, or when commits appear to be missing from branches.

git-leak-recovery

This skill provides guidance for recovering secrets or sensitive data that have been removed from Git history through operations like reset or rebase, and then properly cleaning up the repository to ensure the data is completely removed. Use this skill when tasks involve finding lost commits, recovering data from Git reflog, or securely removing sensitive information from Git repositories.

nginx-request-logging

Guide for configuring Nginx web server with custom request logging, rate limiting, and error pages. This skill should be used when tasks involve Nginx installation, configuration, custom log formats, rate limiting setup, or custom error page creation.

hf-model-inference

Guidance for setting up HuggingFace model inference services with Flask APIs. This skill applies when downloading HuggingFace models, creating inference endpoints, or building ML model serving APIs. Use for tasks involving transformers library, model caching, and REST API creation for ML models.

gcode-to-text

Extracts hidden or encoded text from GCODE files by analyzing toolpath geometry and coordinate data. This skill should be used when tasks involve decoding text from 3D printing files, recovering embossed or engraved text from GCODE, or CTF-style challenges involving GCODE analysis. Applies to any task requiring geometric reconstruction of text from CNC or 3D printer movement commands.

query-optimize

Guidance for SQL query optimization tasks. This skill should be used when optimizing slow SQL queries, improving database performance, or rewriting queries to be more efficient. Covers query plan analysis, benchmarking strategies, and database-specific optimization techniques.

mcp-builder

Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).

extract-moves-from-video

This skill provides guidance for extracting text commands, moves, or typed input from video recordings using OCR. It applies when extracting gameplay commands (e.g., Zork), terminal sessions, or any text-based interactions captured in video format. Use this skill when processing videos of text-based games, terminal recordings, or any scenario requiring OCR-based command extraction from screen recordings.

cancel-async-tasks

Guidance for implementing proper asyncio task cancellation with signal handling in Python. This skill applies when implementing concurrent task runners that need graceful shutdown, handling KeyboardInterrupt/SIGINT in asyncio contexts, or managing task cleanup when using semaphores for concurrency limiting. Use when tasks involve asyncio.gather, CancelledError handling, or cleanup of tasks that haven't started execution.

path-tracing

Guidance for implementing path tracers and ray tracers to reconstruct or generate images. This skill applies when tasks involve writing C/C++ ray tracing code, reconstructing images from reference images, or building rendering systems with spheres, shadows, and procedural textures. Use for image reconstruction tasks requiring similarity matching.

torch-tensor-parallelism

Guidance for implementing tensor parallelism in PyTorch, including ColumnParallelLinear and RowParallelLinear layers. This skill should be used when implementing distributed tensor parallel operations, sharding linear layers across multiple GPUs, or simulating collective operations like all-gather and all-reduce for parallel computation.

configure-git-webserver

Guidance for setting up Git repositories with automatic web deployment via post-receive hooks. This skill applies when configuring bare Git repositories, setting up web servers to serve pushed content, creating Git hooks for deployment automation, or implementing push-to-deploy workflows.

filter-js-from-html

Guidance for filtering JavaScript and XSS attack vectors from HTML while preserving original formatting. This skill should be used when tasks involve removing script content, sanitizing HTML, filtering XSS payloads, or creating security filters that must preserve the original document structure unchanged.

feal-differential-cryptanalysis

Guidance for implementing differential cryptanalysis attacks on FEAL (Fast Data Encipherment Algorithm) and similar block ciphers. This skill should be used when tasks involve recovering round keys, implementing differential attacks, exploiting cipher weaknesses, or performing cryptanalysis on Feistel network ciphers. Applicable to CTF challenges and educational cryptanalysis exercises.

sqlite-db-truncate

Guidance for recovering data from corrupted or truncated SQLite database files through binary analysis and manual parsing. This skill applies when working with damaged SQLite databases that cannot be opened with standard tools, particularly when corruption is due to binary truncation, incomplete writes, or filesystem errors.

letta conversations api

Guide for using the Letta Conversations API to manage isolated message threads on agents. Use when building multi-user chat applications, session management, or any scenario requiring separate conversation contexts on a single agent.

mailman

Guidance for setting up and configuring mailing list servers with Postfix and Mailman3. This skill should be used when tasks involve configuring email servers, mailing list management, LMTP integration, or mail delivery pipelines. Applies to tasks requiring Postfix-Mailman integration, subscription workflows, or email broadcast functionality.

sparql-university

Guidance for writing SPARQL queries against RDF/Turtle datasets, particularly for university or academic data. This skill should be used when tasks involve querying RDF data with SPARQL, filtering entities based on multiple criteria, aggregating results, or working with Turtle (.ttl) files.

webapp-testing

Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.

polyglot-rust-c

Guidance for creating polyglot source files that compile and run correctly as both Rust and C or C++. This skill applies when tasks require writing code that is valid in multiple languages simultaneously, exploiting comment syntax differences or preprocessor directives to create dual-language source files. Use this skill for polyglot programming challenges, CTF tasks, or educational exercises involving multi-language source compatibility.

train-fasttext

Guidance for training FastText text classification models with constraints on model size and accuracy. This skill should be used when training FastText models, optimizing hyperparameters, or balancing trade-offs between model size and classification accuracy.

count-dataset-tokens

Guidance for counting tokens in datasets, particularly from HuggingFace or similar sources. This skill should be used when tasks involve counting tokens in datasets, understanding dataset schemas, filtering by categories/domains, or working with tokenizers. It helps avoid common pitfalls like incomplete field identification and ambiguous terminology interpretation.

torch-pipeline-parallelism

Guidance for implementing PyTorch pipeline parallelism for distributed model training. This skill should be used when tasks involve implementing pipeline parallelism, distributed training with model partitioning across GPUs/ranks, AFAB (All-Forward-All-Backward) scheduling, or inter-rank tensor communication using torch.distributed.

pytorch-model-cli

Guidance for creating standalone CLI tools that perform neural network inference by extracting PyTorch model weights and reimplementing inference in C/C++. This skill applies when tasks involve converting PyTorch models to standalone executables, extracting model weights to portable formats (JSON), implementing neural network forward passes in C/C++, or creating CLI tools that load images and run inference without Python dependencies.

crack-7z-hash

This skill provides guidance for cracking 7z archive password hashes. It should be used when tasked with recovering passwords from 7z encrypted archives, extracting and cracking 7z hashes, or working with password-protected 7z files in CTF challenges, security testing, or authorized recovery scenarios.

regex-chess

Guidance for generating legal chess moves using only regex pattern matching and substitution. This skill applies when implementing chess move generators constrained to regex-only solutions, FEN notation parsing/manipulation, or similar pattern-matching-based board game logic. Use this skill for tasks requiring regex-based state transformations on structured string representations.

log-summary-date-ranges

Guidance for analyzing log files and generating summary reports with counts aggregated across multiple date ranges and severity levels. This skill applies when tasks involve parsing log files by date, counting occurrences by severity (ERROR, WARNING, INFO), and outputting structured CSV summaries across time periods like "today", "last 7 days", or "last 30 days".

password-recovery

Digital forensic skill for recovering passwords and sensitive data from disk images, deleted files, and binary data. This skill should be used when tasks involve extracting passwords from disk images, recovering deleted file contents, analyzing binary files for fragments, or forensic data recovery scenarios. Applies to tasks mentioning disk images, deleted files, password fragments, or data recovery.

write-compressor

Guidance for implementing encoders/compressors that must produce output compatible with an existing decoder/decompressor. This skill applies when tasked with writing compression algorithms, arithmetic coders, entropy encoders, or any encoder that must be the inverse of a given decoder implementation.

mteb-retrieve

Guidance for text embedding retrieval tasks using sentence transformers or similar embedding models. This skill should be used when the task involves loading documents, encoding text with embedding models, computing similarity scores (cosine similarity), and retrieving/ranking documents based on semantic similarity to a query. Applies to MTEB benchmark tasks, document retrieval, semantic search, and text similarity ranking.

extract-elf

Guidance for extracting and processing data from ELF (Executable and Linkable Format) binary files. This skill should be used when tasks involve parsing ELF headers, reading program segments, extracting memory contents, or converting binary data to structured formats like JSON. Applicable to reverse engineering, binary analysis, and memory dump extraction tasks.

feal-linear-cryptanalysis

Guide for performing linear cryptanalysis attacks on FEAL and similar Feistel ciphers. This skill should be used when tasks involve breaking FEAL encryption, recovering cipher keys using known plaintext-ciphertext pairs, or implementing linear cryptanalysis techniques. Applies to cryptographic challenges mentioning "linear attack," "FEAL," "Feistel cipher analysis," or key recovery from plaintext-ciphertext pairs.

fix-ocaml-gc

Guide for debugging and fixing bugs in the OCaml garbage collector, particularly memory management issues in the runtime's sweeping and allocation code. This skill applies when working on OCaml runtime C code, investigating segfaults in GC operations, or fixing pointer arithmetic bugs in memory managers with size-classed pools and run-length encoding.

path-tracing-reverse

Guidance for reverse engineering graphics rendering programs (ray tracers, path tracers) from binary executables. This skill should be used when tasked with recreating a program that generates images through ray/path tracing, particularly when the goal is to achieve pixel-perfect or near-pixel-perfect output matching. Applies to tasks requiring binary analysis, floating-point constant extraction, and systematic algorithm reconstruction.

install-windows-3.11

Guidance for installing and running Windows 3.11 in QEMU with VNC access and web-based noVNC interface. This skill should be used when tasks involve setting up legacy Windows 3.11 environments, configuring QEMU for DOS/Windows 3.x, or creating virtualized retro computing setups with remote access capabilities.

sanitize-git-repo

Guide for sanitizing git repositories by identifying and replacing sensitive information such as API keys, tokens, and credentials. This skill should be used when tasks involve removing secrets from codebases, sanitizing repositories before sharing, or replacing sensitive values with placeholders. Applies to tasks involving secret detection, credential removal, or repository cleanup for security purposes.

mcmc-sampling-stan

Guidance for Bayesian MCMC sampling tasks using RStan. This skill applies when implementing hierarchical Bayesian models, configuring Stan/RStan for MCMC inference, or working with posterior distributions. Use for tasks involving Stan model specification, RStan installation, MCMC diagnostics, and Bayesian hierarchical modeling.

largest-eigenval

Guidance for optimizing numerical linear algebra computations, particularly finding eigenvalues of small dense matrices faster than standard library implementations. This skill applies when the task involves performance optimization of matrix operations, beating numpy/scipy performance baselines, or writing high-performance numerical code with Cython/LAPACK.

vulnerable-secret

Guidance for extracting secrets from protected or obfuscated binaries through systematic static and dynamic analysis. This skill should be used when tasks involve reverse engineering executables, extracting hidden flags or keys, analyzing binary protections, or decoding obfuscated data within compiled programs.

custom-memory-heap-crash

Guide for debugging crashes related to custom memory heaps, particularly use-after-free issues caused by static destruction ordering, DEBUG vs RELEASE discrepancies, and custom allocator lifecycle problems. This skill should be used when investigating crashes that occur only in RELEASE builds, memory-related crashes involving custom allocators, static initialization/destruction order issues, or use-after-free bugs in C++ applications.

winning-avg-corewars

Guidance for developing CoreWars warriors that achieve target win rates against specific opponents. This skill should be used when tasks involve writing, optimizing, or debugging Redcode assembly warriors for the CoreWars programming game, particularly when win rate thresholds must be met against multiple opponents.

distribution-search

Guidance for finding probability distributions that satisfy specific statistical constraints such as KL divergence targets. This skill should be used when tasks involve constructing probability distributions with exact numerical properties, optimization over high-dimensional probability spaces, or satisfying multiple simultaneous statistical constraints within tight tolerances.

qemu-startup

Guidance for starting and configuring QEMU virtual machines with proper serial console access. This skill should be used when tasks involve starting QEMU VMs, configuring serial console or telnet access, booting ISO images, or troubleshooting VM startup issues. Covers pre-flight checks, idempotent startup procedures, and intelligent readiness verification.

tune-mjcf

Guidance for optimizing MuJoCo MJCF model files for simulation performance while maintaining numerical accuracy. This skill should be used when tuning physics simulation parameters, optimizing MuJoCo XML configurations, or balancing speed vs accuracy tradeoffs in robotics simulations.

compile-compcert

Guide for building CompCert, the formally verified C compiler, from source. This skill should be used when compiling, building, or installing CompCert, or when working with Coq-based software that has strict dependency version requirements. Covers OCaml/opam setup, Coq version compatibility, memory management, and common build pitfalls.

sqlite-with-gcov

Guidance for compiling SQLite (or similar C projects) with gcov code coverage instrumentation. This skill should be used when tasks involve building software with gcov flags, setting up code coverage instrumentation, or troubleshooting coverage data file generation. Covers gcov path mechanics, build directory considerations, and runtime verification strategies.

reshard-c4-data

Guidance for data resharding tasks that involve reorganizing files across directory structures with constraints on file sizes and directory contents. This skill applies when redistributing datasets, splitting large files, or reorganizing data into shards while maintaining constraints like maximum files per directory or maximum file sizes. Use when tasks involve resharding, data partitioning, or directory-constrained file reorganization.

openssl-selfsigned-cert

Guides the creation of self-signed SSL/TLS certificates using OpenSSL, including key generation, certificate creation, combined PEM files, and verification scripts. This skill should be used when tasks involve generating self-signed certificates, creating SSL certificate infrastructure, or writing certificate verification scripts.

regex-log

Guidance for constructing complex regular expressions that extract and validate data from log files. This skill applies when building regex patterns to parse log entries with requirements like IP address validation, date extraction, boundary conditions, and selecting specific occurrences (first/last). Use this skill when the task involves creating regex for log parsing with multiple validation constraints.

rstan-to-pystan

Guidance for converting R-Stan (RStan) code to Python-Stan (PyStan). This skill applies when translating Stan models and inference code from R to Python, including API mapping between RStan and PyStan 3.x, hyperparameter translation, and handling differences in output formats. Use this skill for statistical model migration, Bayesian inference code conversion, or when working with Stan models across R and Python ecosystems.

make-mips-interpreter

Guidance for building MIPS interpreters or emulators that execute MIPS binaries. This skill applies when implementing CPU emulation, ELF loaders, instruction decoders, or syscall handlers for MIPS architecture. Use when tasks involve creating virtual machines for MIPS executables, interpreting MIPS assembly instructions, or emulating MIPS system calls.

dna-assembly

Guidance for DNA assembly tasks including Golden Gate assembly, Gibson assembly, and restriction enzyme-based cloning. This skill should be used when designing primers for Type IIS restriction enzymes (BsaI, BsmBI, etc.), creating fusion proteins, or assembling multiple DNA fragments. Covers primer structure requirements, overhang design, and verification strategies.

raman-fitting

This skill provides guidance for Raman spectrum peak fitting tasks. It should be used when analyzing spectroscopic data, fitting Lorentzian or Gaussian peaks to Raman spectra, or working with graphene/carbon material characterization. The skill emphasizes critical data parsing verification, physical constraints from domain knowledge, and systematic debugging of curve fitting problems.

kv-store-grpc

Guide for implementing gRPC-based key-value store services in Python. This skill should be used when building gRPC servers with protobuf definitions, implementing KV store operations (Get, Set, Delete), or troubleshooting gRPC service connectivity. Applicable to tasks involving grpcio, protobuf code generation, and background server processes.

schemelike-metacircular-eval

Guide for building metacircular evaluators in Scheme-like languages. This skill applies when implementing interpreters that can interpret themselves, handling tasks involving eval/apply loops, environment management, closure implementation, and multi-level interpretation. Use for any metacircular evaluator, Scheme interpreter, or self-interpreting language implementation task.

build-pmars

Guidance for building pMARS (portable Memory Array Redcode Simulator) from source. This skill should be used when tasked with compiling pMARS, building Core War simulators from source packages, or creating headless/non-X11 builds of legacy C software from Debian source packages.

merge-diff-arc-agi-task

Guidance for solving ARC-AGI style pattern recognition tasks that involve git operations (fetching bundles, merging branches) and implementing algorithmic transformations. This skill applies when tasks require merging git branches containing different implementations of pattern-based algorithms, analyzing input-output examples to discover transformation rules, and implementing correct solutions. (project)

overfull-hbox

Guidance for fixing LaTeX overfull hbox warnings by replacing words with shorter synonyms from an allowed list. This skill applies when tasks involve modifying LaTeX documents to eliminate typographic warnings while adhering to strict word replacement constraints. Use when dealing with synonym-constrained text editing in LaTeX or similar markup languages.

pypi-server

Guide for setting up local PyPI servers to host and serve Python packages. This skill should be used when tasks involve creating a local PyPI repository, serving Python packages over HTTP, building distributable Python packages, or testing pip installations from a custom index URL.

install-windows-3-11

Guidance for setting up legacy Windows VMs (like Windows 3.11) in QEMU with web-based remote access via noVNC. This skill should be used when tasks involve running legacy operating systems in virtual machines, configuring QEMU for older OS images, setting up VNC/noVNC web interfaces, or establishing programmatic keyboard control via QMP. Covers VM boot verification strategies, nginx reverse proxy configuration, and websockify setup.

make-doom-for-mips

Guide for cross-compiling complex C programs (like DOOM) for embedded MIPS environments with custom VM runtimes. This skill applies when building software that targets MIPS architecture with limited stdlib support, custom syscall interfaces, or JavaScript-based VM execution environments. Use when cross-compiling games, applications, or any C code for constrained MIPS targets.

protein-assembly

Guidance for designing fusion protein gBlock sequences from multiple protein sources. This skill applies when tasks involve combining proteins from PDB databases, plasmid files, and fluorescent protein databases into a single optimized DNA sequence with specific linkers and codon optimization requirements.

multi-source-data-merger

This skill provides guidance for merging data from multiple heterogeneous sources (JSON, CSV, Parquet, XML, etc.) into a unified dataset. Use this skill when tasks involve combining records from different file formats, applying field mappings, resolving conflicts based on priority rules, or generating merged outputs with conflict reports. Applicable to ETL pipelines, data consolidation, and record deduplication scenarios.

prove-plus-comm

Guidance for proving mathematical properties in Coq using induction, specifically addition commutativity and similar arithmetic lemmas. This skill should be used when working with Coq proof assistants to complete induction proofs, fill in proof cases, or apply standard library lemmas like plus_n_O and plus_n_Sm.

letta-api-client

Build applications with the Letta API — a model-agnostic, stateful API for building persistent agents with memory and long-term learning. Covers SDK patterns for Python and TypeScript. Includes 24 working code examples.

qemu-alpine-ssh

Guidance for setting up QEMU virtual machines with Alpine Linux and SSH access. This skill should be used when tasks involve starting QEMU with Alpine Linux ISO, configuring port forwarding for SSH, setting up OpenSSH server in Alpine, or troubleshooting QEMU networking issues.

break-filter-js-from-html

Guidance for bypassing HTML/JavaScript sanitization filters in security testing contexts. This skill should be used when tasked with finding XSS filter bypasses, testing HTML sanitizers, or exploiting parser differentials between server-side filters and browsers. Applies to CTF challenges, authorized penetration testing, and security research involving HTML injection and JavaScript execution through sanitization bypasses.

adaptive-rejection-sampler

Guidance for implementing Adaptive Rejection Sampling (ARS) algorithms. This skill should be used when implementing rejection sampling methods, log-concave distribution samplers, or statistical sampling algorithms that require envelope construction and adaptive updates. It provides procedural approaches, performance considerations, and verification strategies specific to ARS implementations.

gpt2-codegolf

Guidance for implementing minimal GPT-2 inference in constrained environments (code golf challenges). This skill should be used when implementing neural network inference from scratch, parsing binary checkpoint formats, implementing BPE tokenization, or working on code golf challenges involving ML models. Covers verification strategies and common pitfalls for checkpoint parsing and model inference.

letta-app-development

circuit-fibsqrt

Guide for implementing combinational/sequential logic circuits using gate-level descriptions in text-based simulators. This skill applies when building circuits for mathematical functions like integer square root, Fibonacci sequences, or similar computations that require both combinational logic (arithmetic operations) and sequential logic (feedback loops, state machines). Use this skill when the task involves generating gate netlists, implementing multi-bit arithmetic circuits, or debugging event-driven circuit simulators.

polyglot-c-py

Guidance for creating polyglot files that are valid in both Python and C. This skill applies when tasked with writing code that must be parseable and executable by both the Python interpreter and C compiler. Covers polyglot syntax techniques, testing strategies, and critical cleanup requirements.

sam-cell-seg

Guidance for SAM-based cell segmentation and mask conversion tasks involving MobileSAM, mask-to-polygon conversion, CSV processing, and command-line interface design. This skill applies when working with Segment Anything Model (SAM) for biological image segmentation, converting binary masks to polygon coordinates, processing microscopy data, or building CLI tools that interface with deep learning models. (project)

pytorch-model-recovery

Guidance for recovering PyTorch model architectures from state dictionaries, retraining specific layers, and saving models in TorchScript format. This skill should be used when tasks involve reconstructing model architectures from saved weights, fine-tuning specific layers while freezing others, or converting models to TorchScript format.

build-cython-ext

Guidance for building and fixing Cython extensions, particularly for numpy compatibility issues. This skill should be used when tasks involve compiling Cython code, fixing deprecated numpy type errors, or resolving compatibility issues between Cython extensions and modern numpy versions (2.0+).

model-extraction-relu-logits

Guidance for extracting weight matrices from black-box ReLU neural networks using only input-output queries. This skill applies when tasked with recovering internal parameters (weights, biases) of a neural network that can only be queried for outputs, particularly two-layer ReLU networks. Use this skill for model extraction, model stealing, or neural network reverse engineering tasks.

nextjs-saas

Use when building multi-tenant SaaS with Next.js App Router and Supabase. Covers project structure, proxy pattern for auth, component patterns, state management, and Row-Level Security.

dna-insert

Guide for designing DNA insertion primers for site-directed mutagenesis (SDM) using Q5 or similar kits. This skill should be used when tasks involve inserting DNA sequences into plasmids, designing mutagenesis primers, or working with PCR-based insertion methods. Provides verification strategies, common pitfalls, and procedural guidance for correct primer design.

mteb-leaderboard

Guidance for querying ML model leaderboards and benchmarks (MTEB, HuggingFace, embedding benchmarks). This skill applies when tasks involve finding top-performing models on specific benchmarks, comparing model performance across leaderboards, or answering questions about current benchmark standings. Covers strategies for accessing live leaderboard data, handling temporal requirements, and avoiding common pitfalls with outdated sources.

caffe-cifar-10

Guidance for building Caffe from source and training CIFAR-10 models. This skill applies when tasks involve compiling Caffe deep learning framework, configuring Makefile.config, preparing CIFAR-10 dataset, or training CNN models with Caffe solvers. Use for legacy ML framework installation, LMDB dataset preparation, and CPU-only deep learning training tasks.

bn-fit-modify

Guide for Bayesian Network tasks involving structure learning, parameter fitting, intervention, and sampling. This skill should be used when working with pgmpy or similar libraries to recover DAG structures from data, fit conditional probability distributions, perform causal interventions (do-calculus), or sample from modified networks.

build-pov-ray

Guidance for building POV-Ray (Persistence of Vision Raytracer) from source, particularly legacy versions like 2.2. This skill should be used when tasked with downloading, compiling, and installing POV-Ray from source archives. It covers handling legacy C code, compressed archive formats, build system navigation, and verification strategies for successful compilation.

db-wal-recovery

Guidance for recovering data from SQLite Write-Ahead Log (WAL) files that may be corrupted, encrypted, or inaccessible. This skill should be used when tasks involve database recovery, WAL file analysis, decrypting database files, or recovering missing/corrupted SQLite data. Helps avoid common pitfalls like fabricating data based on patterns instead of actual recovery.

model-configuration

SDK/API patterns for configuring LLM models on Letta agents. Use when setting model handles, adjusting temperature/tokens, configuring provider-specific settings (reasoning, extended thinking), or setting up custom endpoints.

skill-creator

Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.

skill-learning-patterns

Meta-skill for recognizing learnings, validating improvements, and contributing back to the collective knowledge base. Use when agents discover better patterns, find gaps in existing skills, or want to improve shared knowledge.

frontend-design

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

github-cli

GitHub CLI (gh) commands for PR workflows - checking CI status, viewing failed test logs, creating and updating pull requests. Use when working with GitHub PRs, checking why CI failed, or managing PR metadata.

google-calendar

Connect Letta Code to Google Calendar via OAuth 2.0 and perform calendar operations. Use when a user wants to search events, check availability, or create/schedule meetings. Triggers on queries about calendar, schedule, meetings, availability, or booking time.

morph-warpgrep

Integration guide for Morph's WarpGrep (fast agentic code search) and Fast Apply (10,500 tok/s code editing). Use when building coding agents that need fast, accurate code search or need to apply AI-generated edits to code efficiently. Particularly useful for large codebases, deep logic queries, bug tracing, and code path analysis.

letta-configuration

Configure LLM models and providers for Letta agents and servers. Use when setting model handles, adjusting temperature/tokens, configuring provider-specific settings, setting up BYOK providers, or configuring self-hosted deployments with environment variables.

internal-comms

A set of resources to help me write all kinds of internal communications, using the formats that my company likes to use. Claude should use this skill whenever asked to write some sort of internal communications (status reports, leadership updates, 3P updates, company newsletters, FAQs, incident reports, project updates, etc.).

skill-development

Create and contribute skills to the communal knowledge base. Use when creating new skills, updating existing skills, or contributing learnings back to the repository.

slack

Search messages, read threads, and send messages in Slack. Use when looking up discussions, finding context about a topic, or sending notifications to channels.

linear

Manage Linear issues via GraphQL API. List, filter, update, prioritize, comment, and search issues. Use when the user asks about Linear, issues, project management, or backlog.

obsidian-cli

Work with Obsidian vaults using the official Obsidian CLI. Read, create, append, search, and manage notes, daily notes, properties, tags, tasks, sync, and more from the terminal. Use when the user mentions Obsidian, notes, vault, daily notes, or when working with markdown knowledge bases. Requires Obsidian desktop app running with CLI enabled in Settings > General.

provider-configuration

Configure LLM providers for Letta servers, covering both self-hosted environment variable setup and programmatic BYOK provider management via REST API. Use when setting up new providers, validating credentials, generating Docker env files, or configuring custom endpoints for OpenAI, Anthropic, Azure, Ollama, and 20+ other providers.