golang-grpc
Provides gRPC usage guidelines, protobuf organization, and production-ready patterns for Golang microservices. Use when implementing, reviewing, or debugging gRPC servers/clients, writing proto files, setting up interceptors, handling gRPC errors with status codes, configuring TLS/mTLS, testing with bufconn, or working with streaming RPCs.
93
93%
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 clearly defines its scope (gRPC in Golang microservices), lists specific concrete capabilities, and provides comprehensive trigger terms in an explicit 'Use when...' clause. It uses proper third-person voice throughout and covers both common and advanced use cases (from basic proto files to mTLS and bufconn testing). The description is concise yet thorough, making it easy for Claude to select this skill precisely when needed.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions: gRPC usage guidelines, protobuf organization, production-ready patterns, implementing/reviewing/debugging gRPC servers/clients, writing proto files, setting up interceptors, handling gRPC errors with status codes, configuring TLS/mTLS, testing with bufconn, and working with streaming RPCs. | 3 / 3 |
Completeness | Clearly answers both 'what' (provides gRPC usage guidelines, protobuf organization, and production-ready patterns for Golang microservices) and 'when' (explicit 'Use when...' clause listing specific trigger scenarios like implementing gRPC servers/clients, writing proto files, setting up interceptors, etc.). | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural terms users would say: 'gRPC', 'protobuf', 'proto files', 'interceptors', 'status codes', 'TLS/mTLS', 'bufconn', 'streaming RPCs', 'Golang', 'microservices'. These are all terms developers would naturally use when seeking help in this domain. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive with a clear niche: gRPC + Golang + microservices. The specific technical terms like 'bufconn', 'protobuf', 'interceptors', 'mTLS', and 'streaming RPCs' make it very unlikely to conflict with other skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
87%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a high-quality skill that is concise, actionable, and well-organized. It provides production-ready Go code examples, clear tables for quick reference, and appropriate progressive disclosure through external references. The main weakness is the lack of explicit step-by-step workflows with validation checkpoints for the declared 'Build mode' and 'Review mode', which would help guide Claude through multi-step service implementation or audit processes.
Suggestions
Add an explicit step-by-step workflow for 'Build mode' (e.g., 1. Define protos → 2. Generate code → 3. Implement server → 4. Validate with bufconn test → 5. Add interceptors) with validation checkpoints at each stage.
Add a concrete 'Review mode' checklist that Claude can follow when auditing existing gRPC code, referencing the Common Mistakes table as verification criteria.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The content is lean and efficient throughout. It avoids explaining what gRPC is or how Go works, assumes Claude's competence, and every section delivers actionable information without padding. The tables are dense and useful, and explanatory comments are terse but informative (e.g., explaining *why* a practice matters in a dash-separated clause). | 3 / 3 |
Actionability | Provides fully executable Go code for server setup with graceful shutdown, interceptor patterns, client configuration with retry policy, error handling with good/bad examples, and streaming. The service config JSON, status code table, and common mistakes table all give concrete, copy-paste-ready guidance. | 3 / 3 |
Workflow Clarity | The skill covers multiple concerns (server, client, errors, streaming, security, testing) with clear sections, but lacks explicit multi-step workflows with validation checkpoints. For example, there's no step-by-step 'build a new service from scratch' workflow despite declaring a 'Build mode', and no verification steps after proto generation or server setup. | 2 / 3 |
Progressive Disclosure | Excellent structure with a quick reference table up front, concise inline content for each concern, and clear one-level-deep references to external files (references/protoc-reference.md, references/testing.md) and cross-references to related skills. Content is appropriately split — detailed testing and proto generation are delegated to reference files. | 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.