haskell-engineering

Enforce type-driven development and explicit purity boundaries in Haskell software.

Updated Mar 31, 2026
One-click install
npx skills add https://github.com/uesleinasch/unac-agents --skill haskell-engineering
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: haskell-engineering
Source: https://github.com/uesleinasch/unac-agents/tree/main/skills-shared/haskell-engineering
Command: npx skills add https://github.com/uesleinasch/unac-agents --skill haskell-engineering

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

The skill provides a comprehensive framework for designing and validating robust Haskell software by enforcing type-driven development, purity boundaries, and clear architectural patterns across projects.

Core Features & Use Cases

  • Type-first thinking and totality-by-default to prevent partial patterns and runtime errors
  • Clear purity boundaries with explicit IO separation and effect management
  • Guidance for architecture (Hexagonal, Ports & Adapters), ADT design, and smart constructors
  • Operational strategies for testing, performance, and project configuration
  • Use case: guide a Haskell project from domain modeling to deployment with reliable, maintainable code

Quick Start

Follow the guidelines to structure a pure, maintainable Haskell project using type-driven design and hexagonal architecture.

Frequently Asked Questions about haskell-engineering

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I enforce purity boundaries and separate IO in Haskell?

To enforce purity boundaries in Haskell, you explicitly separate IO operations from pure logic, managing effects through clear module structures. This prevents side effects from leaking into domain models and core libraries.

What is type-driven development in Haskell and how does it prevent runtime errors?

Type-driven development in Haskell uses type-first thinking and totality-by-default to prevent partial patterns and runtime errors. By designing algebraic data types and smart constructors, you ensure exhaustive pattern matching and explicit error handling.

How to structure a Haskell project using hexagonal architecture?

Structuring a Haskell project with hexagonal architecture involves isolating domain logic using Ports and Adapters patterns. This design guides ADT creation and pure module separation, ensuring maintainable and robust infrastructure services.

Does type-driven Haskell development require specific testing strategies?

Type-driven Haskell development requires operational strategies for testing that validate purity boundaries and explicit error handling. These strategies ensure robust domain models and reliable performance across core libraries and services.

When should I use smart constructors in Haskell domain modeling?

Use smart constructors in Haskell domain modeling when you need to enforce invariants and guarantee valid state creation. They support type-driven development by preventing invalid data from entering pure domain logic.