fp-async

Practical async patterns using TaskEither - clean pipelines instead of try/catch hell, with real API examples

Quality

52%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./skills/fp-async/SKILL.md

Quality

Content

60%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

The skill excels at actionability with comprehensive, executable TypeScript examples covering real-world fp-ts TaskEither patterns. However, it is severely over-long for a skill file - the extensive before/after comparisons, explanations of concepts Claude already knows (try/catch problems, what map vs chain means), and inlined reference material that should be in separate files make it a poor use of context window. The content would be significantly more effective at ~150 lines with detailed examples moved to bundle files.

Suggestions

Cut all 'BEFORE' (problem) code blocks - Claude already knows what nested try/catch and callback hell look like. Replace with a one-line description like '// Instead of nested try/catch:'

Move the complete API wrapper, Prisma database operations, file operations, and Express handler examples into separate bundle files (e.g., examples/api-client.ts, examples/prisma.ts) and reference them from SKILL.md

Remove explanatory text like 'TaskEither is simply an async operation that tracks success or failure' and 'Use map when your transformation is synchronous and can't fail' - Claude knows fp-ts semantics

Keep the Quick Reference Card table and core pattern demonstrations (tryCatch, chain, Do notation, orElse, parallel) as the main SKILL.md content, targeting ~100-150 lines

Dimension	Reasoning	Score
Conciseness	The skill is extremely long (~500+ lines) with extensive before/after comparisons that repeat similar patterns, multiple sections explaining concepts Claude already understands (what try/catch hell is, what chain vs map means), and verbose code examples. The 'problem' sections showing bad code are particularly wasteful - Claude knows what nested try/catch looks like. The content could be cut by 50%+ while preserving all actionable information.	2 / 5
Actionability	Every pattern includes complete, executable TypeScript code with proper imports, type annotations, and realistic use cases. The examples cover fetch wrappers, Prisma database operations, file operations, Express handlers, retry logic, and batch processing - all copy-paste ready with concrete types and real library APIs.	5 / 5
Workflow Clarity	The skill progresses logically from wrapping promises → chaining → parallel execution → error recovery → real examples → handling results, with a clear quick reference card. However, there are no explicit validation checkpoints or verification steps. Since this is a patterns/reference skill rather than a destructive/batch operation workflow, the missing validation is less critical, but the sequential flow could benefit from clearer guidance on when to choose which pattern.	4 / 5
Progressive Disclosure	This is a monolithic ~500+ line file with no references to supporting files. The complete API wrapper, database operations, file operations, and Express handler examples could each be separate reference files. The quick reference card and core patterns could form a concise SKILL.md with links to detailed examples. No bundle files exist to offload this content to.	2 / 5
	Total	13 / 20 Passed

Description

45%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

The description reads like a blog post title or tutorial heading rather than a skill description for Claude's skill selection. It identifies a specific niche (TaskEither async patterns) which helps with distinctiveness, but lacks explicit trigger guidance ('Use when...'), concrete capability listing, and sufficient natural keywords that users would employ when needing this skill.

Suggestions

Add an explicit 'Use when...' clause with trigger terms like 'fp-ts', 'TaskEither', 'functional error handling', 'pipe async operations', 'monadic async'.

Replace the informal tone ('try/catch hell') with concrete capability descriptions like 'Composes async operations using TaskEither, chains API calls with pipe/flow, handles errors functionally without try/catch blocks'.

Include related technology keywords and synonyms such as 'fp-ts', 'Effect', 'functional programming', 'Either', 'monadic error handling' to improve trigger term coverage.

Dimension	Reasoning	Score
Specificity	Names the domain (async patterns with TaskEither) and hints at concrete actions (clean pipelines, API examples), but doesn't list specific capabilities like 'compose async operations', 'handle errors functionally', or 'chain API calls'.	3 / 5
Completeness	Provides a partial 'what' (async patterns using TaskEither with pipelines and API examples) but has no explicit 'when' clause. The description reads more like a tutorial title than a skill description, and the missing 'Use when...' clause caps this at 3 per guidelines, but the 'what' itself is also vague, bringing it to 2.	2 / 5
Trigger Term Quality	Includes some relevant terms like 'TaskEither', 'async patterns', 'try/catch', and 'API examples', but misses natural user phrases like 'fp-ts', 'functional programming', 'error handling', 'monadic composition', or 'Effect' that users might search for.	3 / 5
Distinctiveness Conflict Risk	TaskEither is a fairly specific concept from fp-ts/Effect ecosystem, which makes it reasonably distinct. However, it could overlap with general async/Promise handling skills or broader functional programming skills.	4 / 5
	Total	12 / 20 Passed

Validation

81%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 9 / 11 Passed

Validation for skill structure

Criteria	Description	Result
skill_md_line_count	SKILL.md is long (967 lines); consider splitting into references/ and linking	Warning
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	9 / 11 Passed

Repository: administrakt0r/AI-Agents-Safe-Coding-Skills
Path: skills/fp-async/SKILL.md
Commit: 57c135b

Reviewed: 3 days ago

Table of Contents

Discovery Implementation Validation

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.