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".
72
67%
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 its domain (gRPC/Protocol Buffers), lists specific concrete outputs (definitions, stubs, implementations), and provides explicit trigger guidance with natural user phrases. The description is concise, uses third-person voice correctly, 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' (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', 'implementations'. 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 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
35%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill provides a comprehensive conceptual overview of gRPC service generation but critically lacks executable code examples—no proto snippets, no actual protoc commands with flags, no server implementation code in any language. The workflow is logically sequenced but missing validation checkpoints for what is a multi-step, error-prone process. Referenced bundle files (implementation.md, errors.md, examples.md) don't exist, undermining the progressive disclosure structure.
Suggestions
Add executable code examples: a minimal .proto file definition, the exact protoc command with plugin flags, and a basic server handler implementation in at least one language.
Add validation checkpoints to the workflow: e.g., 'Verify generated stubs exist and compile before implementing handlers' and 'Run proto linting with buf before compilation'.
Create the referenced bundle files (implementation.md, errors.md, examples.md) or remove the references if they don't exist.
Trim the examples section to include actual code snippets rather than prose descriptions of hypothetical services.
| 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 without executable code, and some instruction steps are verbose descriptions rather than lean directives. | 2 / 3 |
Actionability | Despite covering many topics, the skill provides zero executable code examples—no proto file snippets, no protoc commands with actual flags, no server implementation code. Every instruction step is a high-level description ('Compile .proto files with protoc') rather than a concrete, copy-paste-ready command or code block. | 1 / 3 |
Workflow Clarity | The 9-step sequence is logically ordered and covers the full lifecycle from proto definition to testing. However, there are no validation checkpoints (e.g., verify proto compilation succeeded before implementing handlers, validate generated stubs exist), 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, making these references dead links. The main file itself is moderately well-organized with clear sections, but the error handling table and examples could arguably live in referenced files to keep the overview leaner. | 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
3a2d27d
- 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.