generating-grpc-services
Generate gRPC service definitions, stubs, and implementations from Protocol Buffers. Use when creating high-performance gRPC services. Trigger with phrases like "generate gRPC service", "create gRPC API", or "build gRPC server".
57
67%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/api-development/grpc-service-generator/skills/generating-grpc-services/SKILL.mdQuality
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 a well-crafted skill description that clearly identifies the specific domain (gRPC/Protocol Buffers), lists concrete deliverables (definitions, stubs, implementations), and provides explicit trigger guidance with natural user phrases. It uses proper third-person voice and is concise without being vague.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions: 'Generate gRPC service definitions, stubs, and implementations from Protocol Buffers.' These are distinct, concrete deliverables. | 3 / 3 |
Completeness | Clearly answers both 'what' (generate gRPC service definitions, stubs, and implementations from Protocol Buffers) and 'when' (when creating high-performance gRPC services, with explicit trigger phrases). Has an explicit 'Use when' clause and a 'Trigger with' clause. | 3 / 3 |
Trigger Term Quality | Includes natural trigger phrases users would say: 'generate gRPC service', 'create gRPC API', 'build gRPC server', plus domain terms like 'Protocol Buffers', 'gRPC', 'stubs', 'service definitions'. Good coverage of how users would phrase requests. | 3 / 3 |
Distinctiveness Conflict Risk | gRPC and Protocol Buffers are a very specific niche. The triggers are highly distinctive ('gRPC service', 'gRPC API', 'gRPC server') and unlikely to conflict with general API or code generation skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
35%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill covers gRPC service generation comprehensively in terms of topics but fails critically on actionability — it reads more like a high-level architecture guide than an executable skill. There are zero code examples, no protoc commands, no sample .proto files, and no implementation snippets despite the skill being fundamentally about code generation. The workflow is sequenced but lacks validation checkpoints for what is a complex, multi-step process with fragile compilation steps.
Suggestions
Add a concrete, executable example showing a complete .proto file definition and the exact protoc command to compile it, including plugin flags for at least one target language.
Include a minimal but complete server implementation code block (e.g., Python or Go) showing an RPC handler with proper status code usage, so Claude has a copy-paste ready template.
Add explicit validation checkpoints between steps, such as 'Verify proto compiles without errors before proceeding' and 'Test health check endpoint with grpcurl before adding TLS configuration'.
Provide the referenced bundle files (implementation.md, errors.md, examples.md) or move the detailed examples and error patterns inline if bundle files won't exist.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The content is reasonably structured but includes some unnecessary elaboration. The prerequisites section explains things Claude would know (what grpcurl/evans/BloomRPC are), the examples section describes scenarios abstractly rather than providing executable code, and some instruction steps are verbose descriptions rather than lean directives. | 2 / 3 |
Actionability | Despite covering many topics, the skill provides no executable code, no concrete protoc commands, no example .proto file, and no actual implementation snippets. Every instruction step is a high-level description ('Compile .proto files with protoc', 'Implement server-side RPC handlers') without copy-paste ready commands or code blocks. The examples section describes scenarios in prose rather than showing actual proto definitions or code. | 1 / 3 |
Workflow Clarity | The 9 steps provide a reasonable sequence for building a gRPC service, and the error handling table is well-structured. However, there are no validation checkpoints between steps (e.g., no 'verify proto compiles before implementing handlers', no 'test health check endpoint before adding TLS'), and no feedback loops for error recovery during the multi-step process. | 2 / 3 |
Progressive Disclosure | The skill references external files (implementation.md, errors.md, examples.md) which is good structure, but no bundle files are provided, meaning these references lead nowhere. The main file itself is moderately well-organized with clear sections, but the examples and error handling content that's inline could arguably be in the referenced files, creating an inconsistent split between what's here and what's referenced. | 2 / 3 |
Total | 7 / 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 |
|---|---|---|
allowed_tools_field | 'allowed-tools' contains unusual tool name(s) | Warning |
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 9 / 11 Passed | |
- Commit
16dfbca
- 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.