golang-samber-ro
Reactive streams and event-driven programming in Golang using samber/ro — ReactiveX implementation with 150+ type-safe operators, cold/hot observables, 5 subject types (Publish, Behavior, Replay, Async, Unicast), declarative pipelines via Pipe, 40+ plugins (HTTP, cron, fsnotify, JSON, logging), automatic backpressure, error propagation, and Go context integration. Apply when using or adopting samber/ro, when the codebase imports github.com/samber/ro, or when building asynchronous event-driven pipelines, real-time data processing, streams, or reactive architectures in Go. Not for finite slice transforms (-> See golang-samber-lo skill).
87
86%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Advisory
Suggest reviewing before use
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 is highly specific, comprehensive, and well-structured. It lists concrete capabilities, includes abundant natural trigger terms, provides explicit 'when to use' guidance, and even includes a negative boundary to prevent confusion with a related skill. The only minor note is that the description is quite dense, but the information density is justified and well-organized.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete capabilities: 150+ type-safe operators, cold/hot observables, 5 named subject types, declarative pipelines via Pipe, 40+ plugins with examples (HTTP, cron, fsnotify, JSON, logging), automatic backpressure, error propagation, and Go context integration. | 3 / 3 |
Completeness | Clearly answers both 'what' (reactive streams with specific operators, subjects, plugins, etc.) and 'when' with an explicit 'Apply when...' clause covering library usage, import detection, and use-case triggers. Also includes a helpful negative boundary ('Not for finite slice transforms') with a cross-reference to another skill. | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural trigger terms: 'samber/ro', 'github.com/samber/ro', 'reactive streams', 'event-driven', 'ReactiveX', 'asynchronous', 'real-time data processing', 'streams', 'reactive architectures', 'Go', 'Golang', 'observables', 'backpressure'. These are terms a developer would naturally use. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive — targets a specific Go library (samber/ro) with a clear niche (reactive/event-driven programming). The explicit negative boundary distinguishing it from the golang-samber-lo skill further reduces conflict risk. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
72%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 that excels at progressive disclosure and actionability, providing concrete code examples and clear navigation to detailed reference materials. The main weaknesses are moderate verbosity (the 'why use this' justification sections could be trimmed) and the lack of explicit step-by-step workflows with validation checkpoints for common reactive pipeline construction tasks. The content would benefit from a concrete 'build a pipeline' workflow with verification steps rather than primarily serving as a reference catalog.
Suggestions
Trim the 'Why samber/ro' section — the two comparison tables overlap significantly; consolidate into one table or remove the lo vs ro table since the scenario table already covers when to use each tool.
Add a concrete workflow section (e.g., 'Building a Reactive Pipeline') with numbered steps and validation checkpoints, such as verifying goroutine cleanup with runtime.NumGoroutine() or testing error propagation before deploying.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is generally well-structured but includes some unnecessary explanation Claude would already know (e.g., the 'Why samber/ro' section explaining why channels are hard, the lo vs ro comparison table is somewhat redundant given the scenario table above it). The content could be tightened by ~20-30% without losing actionable information. | 2 / 3 |
Actionability | Provides fully executable code examples (the core pipeline example with Subscribe and Collect), concrete constructor signatures for all 5 subject types, specific operator names, exact import paths for plugins, and copy-paste ready installation commands. The common mistakes table gives specific fixes, not vague advice. | 3 / 3 |
Workflow Clarity | The skill covers concepts and operator references well but lacks explicit step-by-step workflows for building reactive pipelines. There are no validation checkpoints (e.g., how to verify a pipeline isn't leaking goroutines, how to test backpressure behavior). The common mistakes section partially compensates but doesn't constitute a clear workflow with feedback loops. | 2 / 3 |
Progressive Disclosure | Excellent progressive disclosure: the main file provides a concise overview with operator quick reference tables, then clearly signals one-level-deep references to detailed guides (subjects-guide.md, operators-guide.md, plugin-ecosystem.md, patterns.md). Cross-references to related skills are well-organized at the end. | 3 / 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
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.