ivelten
UserOpinionated Claude Code skills for Haskell development
Categories
Indexed Skills (15)
haskell-benchmarking
Write and run Haskell performance benchmarks. Covers the `benchmark` cabal stanza, `tasty-bench` for timing (the default), `weigh` for memory-allocation measurement, baseline comparison to catch regressions, the laziness traps (`nf` vs `whnf`), and how to integrate with GHC profiling/flame graphs for deeper investigation. Also explains when to switch to `criterion` for HTML reports. Use when adding benchmarks, debugging a "this got slower" regression, comparing two implementations of the same function, hunting space leaks, or wiring benchmarks into CI.
haskell-database
Model PostgreSQL databases from Haskell types using Rel8. Covers the type-mapping decision tree (composite types vs jsonb vs enums vs primitives), indexed JSONB queries, composite-type indexing caveats, Rel8 table definitions with HKD, and pure-SQL migrations via hasql-migrations. Use when designing the database layer, choosing PostgreSQL column types for Haskell ADTs, writing Rel8 queries, or setting up migrations.
haskell-debugging
Debug Haskell programs interactively using the GHCi debugger and DAP (Debug Adapter Protocol) adapters. Covers the three DAP packages (haskell-dap, ghci-dap, haskell-debug-adapter), VS Code/editor launch.json configuration, GHCi breakpoints and stepping, and when to reach for each tool. Use when setting up debugger integration, stepping through runtime behavior, or diagnosing issues that tracing alone can't reveal.
haskell-devcontainer
Set up or detect a Haskell Dev Container using the pre-built ivelten/haskell-devcontainer Docker image. Covers detection of an existing devcontainer setup, creating .devcontainer/ files from scratch, VS Code extension list, direnv integration, and what the image does and does not ship. Use when bootstrapping a Haskell project in a container, checking whether a devcontainer is already configured, or setting up VS Code Dev Containers for Haskell.
haskell-documentation
Write and enforce Haskell documentation with Haddock + Doctest. Covers the syntax cheat sheet (before/after declarations, records, sum types, module headers), the Haddock coverage gate (`-Wmissing-docs` and `haddock -Werror` do not exist on GHC 9.10.3 — use `scripts/check-haddock.sh`), executable examples via doctest, and how to keep docs from drifting from code. Use when adding documentation, configuring the doctest test-suite, deciding what to put in Haddock vs hspec, or debugging Haddock warnings.
haskell-domain-errors
Model errors as Haskell domain types with structured context, hand-written Show for humans, explicit-tag ToJSON for logs, and conscious choices about Exception/FromJSON. Use when designing error ADTs, deciding between Either/Error effect/throwIO, writing instances for errors, or reviewing error-handling code.
haskell-effectful
Design and use Haskell effect stacks with the `effectful` library. Covers defining effects (`Effect` GADTs, `DispatchOf`), writing interpreters (production + in-memory for tests), polymorphic business logic over an effect set, static vs dynamic dispatch, and composition in `main`. Use whenever the user is wiring up application architecture, deciding where IO lives, or modeling a capability as an effect.
haskell-json
Serialize and deserialize Haskell types to JSON with Aeson. Covers the TaggedObject discriminator pattern for sum types, fieldLabelModifier to strip record prefixes, manual ToJSON/FromJSON for constructors without record syntax, omitNothingFields, and the generic vs manual decision. Use when writing Aeson instances, customizing JSON shape for sum types, or making serialization consistent across a codebase.
haskell-logging
Add structured logging to a Haskell application using `log-effectful`. Covers severity levels (trace/info/attention — no logError), structured payloads, scoped context via `localData`, composition in `main`, and integration with domain errors. Use when adding logs, designing what to log, configuring log backends (stdout/JSON/ElasticSearch), or explaining why there's no `logError`.
haskell-project-setup
Set up a new Haskell project with the opinionated cabal stack, independent of how the toolchain was provisioned. Covers GHC pinning, cabal.project, .cabal templates, project layout, and language-extension policy. Use when bootstrapping a Haskell repo, configuring the build system, deciding where files go, or choosing which language extensions to enable.
haskell-quality-gates
Configure Haskell formatting, linting, performance defaults, pre-commit hooks, and CI checks. Covers ormolu, hlint, cabal-gild, the .pre-commit-config.yaml template, CI workflow steps, strict-by-default field policy, Text/ByteString/Vector/Map preferences, profiling flags, and the "before declaring work done" checklist. Use when wiring up linting/formatting automation, setting up CI for a Haskell project, debugging space leaks, or running the final pre-commit checks.
haskell-testing
Set up and write Haskell tests with `hspec`, `QuickCheck`, and `hspec-discover`. Covers the test-suite cabal stanza, auto-discovery, per-module spec layout, property tests, `Arbitrary` instance placement, in-memory effect interpreters, and colored/specdoc output (locally and in CI). Use when adding tests, configuring the test runner, deciding between unit and property tests, or making test output more readable.
haskell-toolchain-mise
Set up a native (non-container) Haskell toolchain on the host with mise + GHCup. Covers the mise.toml pin (ghcup, cabal, ormolu), GHC and HLS via GHCup, the HLS/GHC compatibility rule, cabal-installed dev tools, PATH and shim wiring for direnv and editors, macOS prerequisites, and the CI mirror of the same pins. Use when bootstrapping a Haskell project without Docker, when the devcontainer is too slow on macOS, or when asked to install or pin GHC, cabal, HLS, ormolu or hlint locally.
haskell-type-design
Design Haskell domain types and records idiomatically. Covers type-driven design (domain types first, functions second), newtypes for primitives, "parse don't validate", phantom types for state machines, and record conventions (positional vs named, field prefixes, NamedFieldPuns, when to reach for optics). Use when modeling a domain in Haskell, defining records or sum types, reviewing type design, or explaining the type-first mindset.
haskell
Entry point and roadmap for any Haskell development work. Use this skill whenever the user mentions Haskell, cabal, GHC, GHCi, HLS, GHCup, mise, Hackage, `.hs`/`.cabal`/`mise.toml`/`.tool-versions` files, or otherwise begins a Haskell-related task — even when no specific sub-topic is yet active. Loads the map of focused haskell-* sub-skills (project setup, devcontainer, native mise+GHCup toolchain, type design, domain errors, effectful, database, json, logging, testing, documentation, benchmarking, quality gates, debugging) plus the cross-cutting defaults that hold across all of them. Acts as the orientation layer so the specific sub-skills don't each need to win a trigger battle on their own.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.