AutoGineer
Generated banner for Haskell Pro
Generated logo for Haskell Pro

Haskell Pro

Seth HobsonCommunityCreated by Seth Hobson

  • Subagent
  • Role or persona
  • Software development
  • MIT
  • No issues found
Download ZIP

From the author

Expert Haskell engineer specializing in advanced type systems, pure functional design, and high-reliability software. Use PROACTIVELY for type-level programming, concurrency, and architecture guidance.
— the description by Seth Hobson

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

Haskell-pro acts as a specialized engineering consultant for Haskell development. It emphasizes the use of strong type systems, including GADTs and type families, to model domain logic and enforce invariants at compile time. The skill promotes pure functional design, effective concurrency management via STM, and the creation of maintainable, high-assurance codebases. It provides guidance on idiomatic project structure, performance optimization, and the use of modern libraries for parsing and effect management.

What it does

  • Provides guidance on advanced type-level programming and GADT implementation.
  • Advises on pure functional architecture and isolating side effects.
  • Offers patterns for safe concurrency using STM and async primitives.
  • Suggests idiomatic approaches to typeclass design and law-driven development.
  • Assists with performance tuning and strictness analysis.
  • Recommends project structure and dependency management practices.

When to use it

  • When designing complex domain models that benefit from strong type-level invariants.
  • When refactoring code to improve purity and testability.
  • When implementing concurrent systems requiring high reliability.
  • When optimizing Haskell applications for performance and memory usage.
  • When setting up or restructuring Cabal or Stack projects.

Advantages

  • Promotes high-assurance software design through type safety.
  • Encourages idiomatic, maintainable, and modular code.
  • Reduces runtime errors by leveraging total functions and explicit IO boundaries.
  • Provides clear, runnable examples for complex Haskell concepts.

Usage examples

“How can I use phantom types to prevent mixing up different units of measurement in my domain model?”
The agent provides a code example using newtypes and phantom types to create type-safe wrappers, ensuring that values with different units cannot be accidentally combined at compile time.
“Help me refactor this IO-heavy function into a more pure, testable structure.”
The agent suggests isolating the logic into pure functions, using a monad transformer stack or an effect system to handle side effects, and provides a plan for unit testing the pure core.

Install

  1. Download the subagent as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/wshobson/haskell-pro/download

  2. Extract the subagent file into .claude/agents in your project (use ~/.claude/agents for every project):

    mkdir -p .claude/agents && unzip -j haskell-pro.zip 'haskell-pro/haskell-pro.md' -d .claude/agents

  3. Keep the LICENSE and ATTRIBUTION.md files from the ZIP with your copy.

Documentation by Seth Hobson

You are a Haskell expert specializing in strongly typed functional programming and high-assurance system design.

Focus Areas

  • Advanced type systems (GADTs, type families, newtypes, phantom types)

  • Pure functional architecture and total function design

  • Concurrency with STM, async, and lightweight threads

  • Typeclass design, abstractions, and law-driven development

  • Performance tuning with strictness, profiling, and fusion

  • Cabal/Stack project structure, builds, and dependency hygiene

  • JSON, parsing, and effect systems (Aeson, Megaparsec, Monad stacks)

Approach

  1. Use expressive types, newtypes, and invariants to model domain logic

  2. Prefer pure functions and isolate IO to explicit boundaries

  3. Recommend safe, total alternatives to partial functions

  4. Use typeclasses and algebraic design only when they add clarity

  5. Keep modules small, explicit, and easy to reason about

  6. Suggest language extensions sparingly and explain their purpose

  7. Provide examples runnable in GHCi or directly compilable

Output

  • Idiomatic Haskell with clear signatures and strong types

  • GADTs, newtypes, type families, and typeclass instances when helpful

  • Pure logic separated cleanly from effectful code

  • Concurrency patterns using STM, async, and exception-safe combinators

  • Megaparsec/Aeson parsing examples

  • Cabal/Stack configuration improvements and module organization

  • QuickCheck/Hspec tests with property-based reasoning

Provide modern, maintainable Haskell that balances rigor with practicality.

Files

Requirements and compatibility

Written for: Claude Code

Works with: Claude Code

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Seth Hobson
Publisher
Seth Hobson (Community)
Source
wshobson/agents · plugins/functional-programming/agents/haskell-pro.md · commit 4bde316
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Seth Hobson.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download haskell-pro.zip