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".
75
71%
Does it follow best practices?
Impact
Pending
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 strong skill description that clearly identifies the specific domain (gRPC/Protocol Buffers), lists concrete actions (definitions, stubs, implementations), and provides explicit trigger guidance with natural user phrases. It is concise, uses third-person voice, and occupies a distinct niche that minimizes conflict risk with other skills.
| 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' (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 natural variations. | 3 / 3 |
Distinctiveness Conflict Risk | gRPC and Protocol Buffers are a very specific niche. The triggers are highly distinct ('gRPC service', 'gRPC API', 'gRPC server') and unlikely to conflict with general API or code generation skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
42%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill is well-structured with good progressive disclosure and a logical workflow sequence, but critically lacks any executable code or concrete commands. The entire content reads as abstract instructions rather than actionable guidance—there are no .proto file examples, no protoc commands with actual flags, and no implementation snippets. For a code generation skill, this is a significant gap.
Suggestions
Add a concrete, executable example: a minimal .proto file definition with the exact protoc command (including plugin flags) to generate stubs, e.g., `protoc --go_out=. --go-grpc_out=. proto/user.proto`
Include at least one copy-paste ready code snippet for a server-side RPC handler implementation in a target language
Add explicit validation checkpoints: 'Run `buf lint` before compiling' and 'Verify generated code compiles before implementing handlers'
Replace the conceptual examples section with at least one concrete example showing input .proto → generated output → handler implementation
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The content is moderately efficient but includes some unnecessary elaboration. For example, the examples section describes use cases at a conceptual level without providing executable code, and the prerequisites list things Claude would already know about. The error handling table adds value but some entries over-explain. | 2 / 3 |
Actionability | Despite listing 9 steps, the skill provides zero executable code, no concrete protoc commands, no example .proto file, and no copy-paste ready snippets. Every instruction is abstract description ('Define proto3 message types', 'Compile .proto files with protoc') rather than concrete, executable guidance. The examples section describes scenarios conceptually without any actual code. | 1 / 3 |
Workflow Clarity | The 9 steps are sequenced logically from proto definition through compilation, implementation, testing, and gateway generation. However, there are no validation checkpoints—no step says 'verify the generated stubs compile' or 'validate proto files with buf lint before proceeding.' For a multi-step code generation workflow, the absence of feedback loops caps this at 2. | 2 / 3 |
Progressive Disclosure | The skill provides a clear overview with well-signaled one-level-deep references to implementation.md, errors.md, and examples.md. Content is appropriately split between the overview skill file and reference documents, with clear navigation signals throughout. | 3 / 3 |
Total | 8 / 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
3e83543
- 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.