good-haskell-code

Identify GOOD and BAD patterns in Haskell code for correctness and maintainability.

Updated Feb 22, 2026
One-click install
npx skills add https://github.com/mewhhaha/clapse --skill good-haskell-code
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: good-haskell-code
Source: https://github.com/mewhhaha/clapse/tree/main/.agents/skills/good-haskell-code
Command: npx skills add https://github.com/mewhhaha/clapse --skill good-haskell-code

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill helps writers and reviewers produce reliable, maintainable Haskell by surfacing concise GOOD/BAD patterns and guiding invariants across architecture, effects, concurrency, FRP, parsing/versioning, and profiling.

Core Features & Use Cases

  • Provides explicit GOOD/BAD examples with one-sentence rationales to illustrate safe vs risky patterns in GHc 9.14.1 code.
  • Supports targeted reviews for readability, type-safety, API stability, and performance, enabling faster, risk-averse decision making.
  • Use case: a code-review scenario where a team evaluates a module's boundary definitions, error handling, and effect management to decide safe refactors.

Quick Start

Review a code snippet by selecting a routing category (e.g., readability, performance) and present paired GOOD/BAD examples with rationale.

Frequently Asked Questions about good-haskell-code

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

FAQPage Schema
How do I review Haskell code for common anti-patterns and type-safety issues?

Review Haskell code by evaluating explicit GOOD/BAD examples that surface anti-patterns and enforce type-safety invariants. This targets correctness and maintainability improvements across architecture, effects, and error handling.

What are the best practices for managing effects and typed errors in Haskell?

Best practices for Haskell effects involve enforcing typed errors and maintaining small effect boundaries. Explicit invariants ensure safe error handling and prevent unintended side effects during module refactoring.

How do I profile Haskell performance and identify measurable bottlenecks?

Profile Haskell performance by applying benchmarks and checks that provide measurable performance data. This process isolates bottlenecks in concurrency and FRP logic to guide targeted optimizations.

Does this Haskell pattern guidance apply to the GHC 9.14.1 ecosystem?

Yes, the pattern guidance is explicitly applied to the GHC 9.14.1 ecosystem. It focuses on architecture, effects, concurrency, FRP, parsing, versioning, and profiling within that specific environment.

When should I use explicit invariants for Haskell concurrency and FRP patterns?

Use explicit invariants for Haskell concurrency and FRP when you need to enforce type-safety and ensure measurable performance. They prevent race conditions and maintain stability during complex state transitions.