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.

Quality

89%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Advisory

Suggest reviewing before use

Quality

Content

79%

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, well-organized gRPC skill that provides excellent actionable guidance with concrete code examples, proper error handling patterns, and a comprehensive common mistakes table. Its main weaknesses are the absence of explicit multi-step workflows with validation checkpoints and missing bundle files for the referenced paths. The content is impressively concise while covering a broad surface area of gRPC concerns.

Suggestions

Add the referenced bundle files (references/protoc-reference.md and references/testing.md) to support the progressive disclosure structure

Add an explicit build workflow with validation steps, e.g., 1. Write proto → 2. Generate code (`buf generate`) → 3. Verify generated files exist → 4. Implement server → 5. Test with bufconn → 6. Verify status codes

Dimension	Reasoning	Score
Conciseness	The content is lean and efficient throughout. It assumes Claude's competence as a Go developer, avoids explaining basic concepts, and every section delivers actionable information without padding. The tables, code examples, and bullet points are all information-dense.	3 / 3
Actionability	Provides fully executable code examples for server setup with graceful shutdown, interceptor patterns, client configuration with retry policy, error handling with good/bad comparisons, and streaming. The dependency installation commands are concrete and copy-paste ready.	3 / 3
Workflow Clarity	The skill covers many concerns (server, client, errors, streaming, security, testing) with clear guidance for each, but lacks explicit multi-step workflows with validation checkpoints. For example, the proto-to-server workflow (generate protos → implement server → add interceptors → test) is not sequenced, and there's no validate-then-proceed pattern for the build process.	2 / 3
Progressive Disclosure	References to `references/protoc-reference.md` and `references/testing.md` show good intent for progressive disclosure, but no bundle files are provided, meaning these references are broken. The cross-references to other skills are well-structured, but the inline content is fairly long and some sections (like the Performance and Common Mistakes tables) could potentially be in reference files.	2 / 3
	Total	10 / 12 Passed

Description

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 guidance via an explicit 'Use when' clause. The description uses appropriate third-person voice and includes a rich set of domain-specific keywords that users would naturally use when seeking this kind of help.

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 covering implementing, reviewing, debugging, 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 a developer 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 trigger terms like bufconn, protobuf, interceptors, mTLS, and streaming RPCs make it very unlikely to conflict with other skills.	3 / 3
	Total	12 / 12 Passed

Validation

81%

Warnings & errors only

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: a5e0e59

Reviewed: 14 days ago

Table of Contents

Discovery Implementation Validation

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.