Essential patterns, idioms, and gotchas for writing Nushell code. Use when writing Nushell scripts, functions, or working with Nushell's type system, pipelines, and data structures. Complements plugin development knowledge with practical usage patterns.
83
79%
Does it follow best practices?
Impact
85%
1.02xAverage score across 3 eval scenarios
Advisory
Suggest reviewing before use
Optimize this skill with Tessl
npx tessl skill review --optimize ./nushell-usage/SKILL.mdQuality
Discovery
82%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 effectively identifies its domain (Nushell) and provides explicit trigger guidance with a 'Use when...' clause covering relevant scenarios. Its main weakness is the lack of concrete, specific actions—terms like 'patterns, idioms, and gotchas' are abstract rather than describing what the skill actually helps accomplish. The relationship to a companion plugin development skill is noted but could be clearer in terms of boundary delineation.
Suggestions
Replace abstract terms like 'patterns, idioms, and gotchas' with concrete actions, e.g., 'Define custom commands, handle closures, work with tables, manage errors, and convert data types in Nushell.'
Clarify the boundary with the plugin development skill more explicitly, e.g., 'Use this for general Nushell scripting; use [other skill] for building Nushell plugins.'
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description names the domain (Nushell code) and mentions some areas like 'type system, pipelines, and data structures,' but uses abstract terms like 'patterns, idioms, and gotchas' rather than listing concrete actions (e.g., 'parse tables, define custom commands, handle errors'). | 2 / 3 |
Completeness | Clearly answers both 'what' (patterns, idioms, and gotchas for writing Nushell code) and 'when' (explicit 'Use when writing Nushell scripts, functions, or working with Nushell's type system, pipelines, and data structures'). The 'Use when...' clause is present and specific. | 3 / 3 |
Trigger Term Quality | Includes strong natural trigger terms users would say: 'Nushell scripts', 'Nushell functions', 'type system', 'pipelines', 'data structures', and 'Nushell code'. These cover the main ways a user would phrase requests about Nushell programming. | 3 / 3 |
Distinctiveness Conflict Risk | The mention of complementing 'plugin development knowledge' helps distinguish it from a related plugin skill, but the broad scope of 'patterns, idioms, and gotchas' could overlap with general Nushell documentation or scripting skills. The niche is somewhat specific (Nushell) but the capabilities described are broad within that niche. | 2 / 3 |
Total | 10 / 12 Passed |
Implementation
77%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a strong Nushell patterns reference with excellent actionability — nearly every concept is backed by executable code with clear correct/incorrect annotations. The critical distinction between pipeline input and parameters is well-highlighted. The main weaknesses are moderate verbosity (some sections cover patterns Claude likely knows, and the best practices list is partially generic) and the length could benefit from more aggressive splitting into reference files.
Suggestions
Move generic best practices (e.g., 'test incrementally', 'use modules', 'document with comments') that Claude already knows, and trim the list to Nushell-specific advice like the caret prefix and external command recommendations.
Consider moving sections like 'Debugging Techniques', 'Module System', and 'Glob Patterns' into reference files to keep the main SKILL.md focused on the most critical and non-obvious patterns.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is generally efficient and avoids explaining basic concepts Claude would know, but it's quite long (~300+ lines) with some sections that could be tightened. The best practices list at the end contains generic advice (e.g., 'test incrementally', 'use modules') that Claude already knows. Some patterns like basic string interpolation and conditional execution are also likely unnecessary. | 2 / 3 |
Actionability | Nearly every pattern includes executable, copy-paste-ready Nushell code with clear ✅/❌ annotations showing correct vs incorrect usage. The examples are concrete, specific, and demonstrate real usage patterns including edge cases like closures capturing mutable variables and the `each` on single records pitfall. | 3 / 3 |
Workflow Clarity | For a patterns/idioms reference skill (not a multi-step process skill), the content is exceptionally well-sequenced. It progresses logically from critical distinctions through common patterns to pitfalls and advanced topics. The ✅/❌ pattern provides implicit validation checkpoints. Since this is a reference skill rather than a destructive/batch operation workflow, explicit validation loops are not required. | 3 / 3 |
Progressive Disclosure | The skill references two bundle files (references/advanced-patterns.md and references/type-system.md) which is good progressive disclosure structure, but no bundle files were provided, so we can't verify they exist. The main file itself is quite long and some sections (like the full module system example, glob patterns, or debugging techniques) could potentially be split into reference files to keep the main skill leaner. | 2 / 3 |
Total | 10 / 12 Passed |
Validation
90%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 10 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 10 / 11 Passed | |
84b1da5
Table of Contents
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.