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).
89
88%
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 thoroughly covers specific capabilities, includes rich natural trigger terms, explicitly states both what the skill does and when to use it, and clearly distinguishes itself from related skills. The negative boundary referencing the golang-samber-ro skill is a particularly strong touch for disambiguation. Uses proper third-person voice throughout.
| 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', 'slices', 'maps', 'channels', 'Map', 'Filter', 'Reduce', 'GroupBy', 'github.com/samber/lo', 'functional-style data transformations', 'generic functions'. These are terms a developer would naturally use when working with this library. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive — targets a specific Go library (samber/lo) with explicit import path, and even draws a clear boundary against a related skill (golang-samber-ro for streaming pipelines). Very unlikely to conflict with other skills. | 3 / 3 |
Total | 12 / 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 well-structured skill with strong actionability — executable code examples, clear decision tables, and practical common-mistakes guidance. The progressive disclosure design is sound but undermined by missing bundle files for the referenced paths. Conciseness could be improved by trimming the motivational 'Why samber/lo' section and the manual-loop comparison, which explain concepts Claude already understands.
Suggestions
Provide the referenced bundle files (references/package-guide.md, references/api-reference.md, references/advanced-patterns.md) to fulfill the progressive disclosure promises made in the skill body.
Trim or remove the 'Why samber/lo' section — Claude doesn't need to be sold on the library's value proposition; focus on when and how to use it.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is generally well-organized but includes some unnecessary explanation Claude would already know (e.g., the 'Why samber/lo' section explaining what generics and immutability are, the comparison with manual for-loops). The persona line and some motivational framing could be trimmed. However, the tables and quick reference are efficient information delivery. | 2 / 3 |
Actionability | Provides fully executable Go code examples for core patterns (Map, Filter+Reduce, GroupBy, MapErr), concrete installation commands, and a clear quick reference table. The code is copy-paste ready with realistic types and patterns. | 3 / 3 |
Workflow Clarity | For a library skill (not a multi-step destructive operation), the workflow is clear: install → choose the right package → use core patterns → avoid common mistakes → optimize only after profiling. The decision table for package selection and the common mistakes table serve as effective validation checkpoints for choosing the right approach. | 3 / 3 |
Progressive Disclosure | References to ./references/package-guide.md, ./references/api-reference.md, and ./references/advanced-patterns.md are well-signaled and one level deep, which is good structure. However, no bundle files were provided, so these references point to non-existent files, undermining the actual progressive disclosure. The cross-references to other skills are helpful but the missing bundle files are a significant gap. | 2 / 3 |
Total | 10 / 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
e9761db
- 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.