golang-samber-lo
Functional programming helpers for Golang using samber/lo — 500+ type-safe generic functions for slices, maps, channels, strings, math, tuples, and concurrency (Map, Filter, Reduce, GroupBy, Chunk, Flatten, Find, Uniq, etc.). Core immutable package (lo), concurrent variants (lo/parallel aka lop), in-place mutations (lo/mutable aka lom), lazy iterators (lo/it aka loi for Go 1.23+), and experimental SIMD (lo/exp/simd). Apply when using or adopting samber/lo, when the codebase imports github.com/samber/lo, or when implementing functional-style data transformations in Go. Not for streaming pipelines (→ See golang-samber-ro skill).
92
92%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Quality
Discovery
100%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This is an excellent skill description that hits all the marks. It provides rich specificity with concrete function names and sub-packages, includes abundant natural trigger terms a Go developer would use, explicitly states both what the skill does and when to apply it, and even draws a clear boundary against a related skill to prevent conflicts.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions and capabilities: 500+ type-safe generic functions, specific function names (Map, Filter, Reduce, GroupBy, Chunk, Flatten, Find, Uniq), specific sub-packages (lo, lo/parallel, lo/mutable, lo/it, lo/exp/simd), and their purposes (immutable, concurrent, in-place mutations, lazy iterators, SIMD). | 3 / 3 |
Completeness | Clearly answers both 'what' (functional programming helpers with 500+ generic functions across multiple sub-packages) and 'when' with explicit triggers ('Apply when using or adopting samber/lo, when the codebase imports github.com/samber/lo, or when implementing functional-style data transformations in Go'). Also includes a negative boundary ('Not for streaming pipelines'). | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural terms: 'samber/lo', 'functional programming', 'Golang', 'Go', 'generic functions', 'slices', 'maps', 'channels', specific function names like 'Map, Filter, Reduce', the import path 'github.com/samber/lo', and 'functional-style data transformations'. These are terms a developer would naturally use. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive — targets a specific library (samber/lo) with a specific import path, and explicitly differentiates from a related skill (golang-samber-ro) for streaming pipelines. This clear boundary and niche focus make conflicts very unlikely. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
85%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
A well-structured library skill with strong actionability and excellent progressive disclosure. The code examples are executable and the decision tables for package selection are genuinely useful. The main weakness is some verbosity in explaining concepts Claude already understands (generics benefits, immutability advantages, what manual for-loops look like), which could be trimmed to improve token efficiency.
Suggestions
Remove or significantly trim the 'Why samber/lo' bullet explanations — Claude understands generics, immutability, and zero-dependency benefits. A single sentence like 'Type-safe generic helpers that fill gaps beyond stdlib slices/maps packages' suffices.
Drop the manual for-loop comparison in 'Transform a slice' — Claude knows what boilerplate lo replaces; the lo example alone is sufficient.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The 'Why samber/lo' section explains things Claude already knows (what generics are, what immutability means, what zero dependencies implies). The comparison with manual for-loops in 'Core Patterns' is somewhat redundant. However, the tables and quick reference are efficient. Overall mostly efficient but with some unnecessary explanation. | 2 / 3 |
Actionability | Provides fully executable Go code examples for Map, Filter, Reduce, GroupBy, and error variants. Installation command is copy-paste ready. The package import table with aliases is immediately usable. Common mistakes table gives specific, actionable fixes. | 3 / 3 |
Workflow Clarity | For a library skill (not a multi-step destructive process), the workflow is clear: start with lo, profile, then upgrade to lop/lom/loi. The 'Choose the Right Package' table with decision criteria and the 'Key rules' provide an unambiguous decision sequence. The 'Best Practices' section reinforces the profile-before-optimizing workflow. | 3 / 3 |
Progressive Disclosure | Excellent structure: concise overview in SKILL.md with clear one-level-deep references to Package Guide, API Reference, and Advanced Patterns. Cross-references to related skills are well-signaled. The quick reference table provides discoverability without bloating the main file. | 3 / 3 |
Total | 11 / 12 Passed |
Validation
81%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 |
|---|---|---|
metadata_field | 'metadata' should map string keys to string values | Warning |
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 9 / 11 Passed | |
- Repository
- samber/cc-skills-golang
- Commit
b88f91d
- Reviewed
Table of Contents
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.