Golang Grpc
Install this when your solo backend uses Go and gRPC so agents generate protos, servers, handlers, and clients with correct status codes and streaming patterns.
Overview
golang-grpc is an agent skill for the Build phase that teaches Go gRPC server setup, proto RPC design, interceptors, streaming, clients, and status-mapped error handling.
Install
npx skills add https://github.com/samber/cc-skills-golang --skill golang-grpcWhat is this skill?
- Maps repository and validation failures to google.golang.org/grpc/status with codes.NotFound, InvalidArgument, and Inter
- Defines proto3 services with per-RPC Request and Response wrapper messages, not bare primitives or entity types
- Documents unary, server-streaming, and client-streaming handler signatures and grpc.NewStream usage
- Shows grpc.UnaryInterceptor chaining for logging, authentication, and error wrapping on unary RPCs
- Five benchmark scenarios stress status codes, proto wrappers, streaming signatures, and interceptor chaining
- Five eval scenarios cover raw errors vs status errors, proto wrappers, unary interceptors, server streaming, and client
- Skill documents six primary status code mappings including NotFound, InvalidArgument, AlreadyExists, Internal, Unavailab
Adoption & trust: 3.7k installs on skills.sh; 2k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You need Go gRPC handlers and protos, but ad-hoc agent output returns raw errors, bare proto types, or broken streaming signatures that clients cannot rely on.
Who is it for?
Solo builders implementing or reviewing Go microservices, internal APIs, or agent backends that already standardize on gRPC and protobuf.
Skip if: Teams building only REST or GraphQL with no gRPC stack, or frontends that never touch .proto generation and Go service code.
When should I use this skill?
Implementing or reviewing Go gRPC services, handlers, interceptors, streaming RPCs, proto definitions, or client dial patterns.
What do I get? / Deliverables
You get copy-ready Go gRPC servers, wrapper-based proto services, streaming handlers, interceptor chains, and clients that return documented status codes instead of codes.Unknown surprises.
- Proto3 service definitions with per-RPC Request and Response messages
- Go gRPC server, handlers, and interceptors using status codes
- Go gRPC client setup with explicit credentials and RPC calls
Recommended Skills
Journey fit
gRPC service work is core backend implementation during the Build phase, before shipping and operating the API in production. The skill covers Go servers, handlers, interceptors, proto RPC shapes, and clients—the canonical backend integration surface for microservices and internal APIs.
How it compares
Use this procedural skill for Go gRPC discipline instead of generic Go snippets that treat RPC errors like ordinary Go errors.
Common Questions / FAQ
Who is golang-grpc for?
It is for solo and indie developers using Claude Code, Cursor, Codex, or similar agents to build or audit Go gRPC services, protos, interceptors, and clients.
When should I use golang-grpc?
Use it during Build when scaffolding a new gRPC service, fixing handlers that return fmt.Errorf, defining proto RPCs with proper wrappers, adding unary interceptors, or implementing server- and client-streaming RPCs before ship-time review.
Is golang-grpc safe to install?
Treat it like any third-party agent skill: review the Security Audits panel on this Prism page and your org policy before wiring it into automated workflows that touch production repos.
SKILL.md
READMESKILL.md - Golang Grpc
[ { "id": 1, "name": "raw-error-vs-status-error", "description": "Tests that gRPC handlers return status.Errorf with specific codes, not raw errors", "prompt": "Write a Go gRPC handler for GetUser that looks up a user from a repository. If the user is not found, return an appropriate error. If the repository returns an unexpected error, return that too.", "trap": "Without the skill, the model may return fmt.Errorf or raw errors, which become codes.Unknown. The skill requires status.Errorf with specific codes.", "assertions": [ {"id": "1.1", "text": "Uses status.Errorf (or status.Error) for the not-found case with codes.NotFound"}, {"id": "1.2", "text": "Uses status.Errorf with codes.Internal for unexpected errors"}, {"id": "1.3", "text": "Does NOT return a raw fmt.Errorf or errors.New as the gRPC error"}, {"id": "1.4", "text": "Imports google.golang.org/grpc/status and google.golang.org/grpc/codes"}, {"id": "1.5", "text": "Does NOT leak internal error details in the user-facing gRPC message for Internal errors"} ] }, { "id": 2, "name": "wrapper-messages-not-bare-types", "description": "Tests that proto RPCs use Request/Response wrapper messages, not bare types", "prompt": "Write a proto3 service definition for a product catalog with RPCs: GetProduct (takes product ID, returns product), DeleteProduct (takes product ID, returns nothing), SearchProducts (takes search query string, returns list of products).", "trap": "Without the skill, the model may use bare types like string or google.protobuf.Empty. The skill requires Request/Response wrappers for backward-compatible evolution.", "assertions": [ {"id": "2.1", "text": "Uses GetProductRequest/GetProductResponse wrapper messages, not bare string or Product"}, {"id": "2.2", "text": "Uses DeleteProductRequest/DeleteProductResponse wrapper messages, not bare string or google.protobuf.Empty"}, {"id": "2.3", "text": "Uses SearchProductsRequest/SearchProductsResponse wrapper messages"}, {"id": "2.4", "text": "Each wrapper message has properly named fields (not just a single unnamed field)"}, {"id": "2.5", "text": "Includes go_package option in the proto file"} ] }, { "id": 3, "name": "proto-directory-organization", "description": "Tests proper proto file organization by domain with versioned directories", "prompt": "I'm building a microservice with user management and order management. How should I organize my proto files? Show the directory layout and an example buf.gen.yaml.", "trap": "Without the skill, the model may put all protos in a flat directory or skip versioning. The skill requires domain-based organization with v1 directories.", "assertions": [ {"id": "3.1", "text": "Organizes proto files by domain (user/, order/ or similar domain grouping)"}, {"id": "3.2", "text": "Includes version directories (v1/ under each domain)"}, {"id": "3.3", "text": "Separates message definitions from service definitions (e.g. user.proto vs user_service.proto)"}, {"id": "3.4", "text": "Includes a shared/ or common/ directory for shared messages"}, {"id": "3.5", "text": "Shows buf.gen.yaml with go and go-grpc plugins configured"} ] }, { "id": 4, "name": "graceful-stop-with-timeout-fallback", "description": "Tests proper gRPC server shutdown: GracefulStop with timeout fallback to Stop", "prompt": "Write Go code for a gRPC server that handles shutdown signals properly. The server should try to drain in-flight requests before stopping.", "trap": "Without the skill, the model may only call srv.Stop() or only srv.GracefulStop() without a timeout fallback. The skill requires GracefulStop with a timeout fallback to Stop.", "assertions": [ {"id": "4.1", "text": "Calls srv.GracefulStop() first to drain in-flight RPCs"}, {"id": "4.2", "text": "Has a timeout mechanism that falls back to sr