Build or review gRPC services and clients in .NET. An agent skill from managedcode/dotnet-skills.

MITAuto-check passedBackend & APIs

Install Grpc

skills CLI
$ npx skills add managedcode/dotnet-skills --skill grpc -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install managedcode/dotnet-skills grpc --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/managedcode/dotnet-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/catalog/Frameworks/gRPC/skills/grpc .claude/skills/grpc && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
grpc
GitHub stars
486
Token cost
~1.4k tokens
SKILL.md length
536 words
Files
4 (incl. references)
Skills in repo
81
Repo updated
First seen
Licence
MIT

At a glance

Build or review gRPC services and clients in .NET. An agent skill from managedcode/dotnet-skills.

  • Works in 6 steps: Validate the architecture fit before… → Treat .proto files as the source of truth. → Choose the RPC shape from the… → …
  • : ASP.NET Core gRPC
  • SKILL.md covers Trigger On, Do Not Use For, Load References and Workflow, plus 5 more sections
  • Calls dotnet

What it does

Grpc is an agent skill from managedcode/dotnet-skills. Build or review gRPC services and clients in .NET. USE FOR: ASP.NET Core gRPC, protobuf contracts, unary or streaming RPC, gRPC client factory, interceptors, deadlines, cancellation, channel reuse, backend service integration. DO NOT USE FOR: broad browser-facing APIs without gRPC-Web tradeoff review, SignalR realtime hubs, plain REST APIs. INVOKES: dotnet build/test and focused service or client smoke checks when code changes.

Its SKILL.md is about 1.4k tokens, which your agent loads only when the skill is triggered. The skill folder holds 4 other files, including reference files (for example `manifest.json`, `references/anti-patterns.md` and `references/patterns.md`). Compatibility notes: Requires ASP.NET Core gRPC or gRPC client projects.

It sits in Backend & APIs, covering gRPC and Protobuf. It works with gRPC, .NET and ASP.NET Core. The repository describes itself as: Installable .NET skill catalog and CLI for Codex, Claude Code, GitHub Copilot, and Gemini. The licence is MIT.

When your agent uses it

  • : ASP.NET Core gRPC
  • Protobuf contracts
  • GRPC client factory
  • Backend service integration

Example prompts

  • “/grpc”

Requirements

  • Compatibility (from SKILL.md): Requires ASP.NET Core gRPC or gRPC client projects.

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

  1. Validate the architecture fit before touching code.
  2. Treat .proto files as the source of truth.
  3. Choose the RPC shape from the interaction model.
  4. Wire server and client behavior together.
  5. Add observability and resilience where the boundary justifies it.
  6. Validate with the repo's normal build and tests, plus a focused smoke call when runnable.

What it can do on your machine

Read from SKILL.md and the folder at commit 535dd55. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • dotnet

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

  • Compatibility

    Requires ASP.NET Core gRPC or gRPC client projects.

    From compatibility in the SKILL.md frontmatter.

Context cost

Grpc loads about 1.4k tokens when it runs, and up to ~13k if it reads all its reference files. Until then it costs about 109 tokens; SKILL.md has 536 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~109
When it runs · the whole SKILL.md, loaded when a task matches
~1.4k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~13k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from managedcode/dotnet-skills at commit 535dd55, republished under its MIT licence (© managedcode). 536 words, ~1,366 tokens.

Download SKILL.mdSave it as .claude/skills/grpc/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
name
grpc
description
Build or review gRPC services and clients in .NET. USE FOR: ASP.NET Core gRPC, protobuf contracts, unary or streaming RPC, gRPC client factory, interceptors, deadlines, cancellation, channel reuse, backend service integration. DO NOT USE FOR: broad browser-facing APIs without gRPC-Web tradeoff review, SignalR realtime hubs, plain REST APIs. INVOKES: dotnet build/test and focused service or client smoke checks when code changes.
compatibility
Requires ASP.NET Core gRPC or gRPC client projects.

gRPC for .NET

Trigger On

  • building backend-to-backend RPC services or clients
  • adding protobuf contracts, streaming calls, or interceptors
  • deciding between gRPC, HTTP APIs, and SignalR
  • optimizing gRPC performance, deadlines, cancellation, or connection reuse
  • integrating service-to-service communication in microservices

Do Not Use For

  • public browser-first APIs unless gRPC-Web limitations are explicitly acceptable
  • SignalR hub design, realtime UI fan-out, or websocket-style client collaboration
  • generic ASP.NET Core minimal APIs or REST controllers with no protobuf/RPC requirement
  • non-.NET gRPC work unless the user asks for cross-stack contract guidance

Load References

  • references/patterns.md for proto design, streaming implementations, interceptors, health checks, load balancing, and client factory setup.
  • references/anti-patterns.md for common channel, deadline, streaming, message-size, and exception-handling mistakes.

Workflow

  1. Validate the architecture fit before touching code.
    • prefer gRPC for backend RPC, strong contracts, low-latency calls, or streaming
    • prefer REST or minimal APIs for broad browser compatibility and loosely coupled public APIs
    • prefer SignalR for browser/client realtime fan-out and UI collaboration
  2. Treat .proto files as the source of truth.
    • keep package names, csharp_namespace, service names, and versioning deliberate
    • reserve removed field numbers and avoid reusing tags
    • use wrapper types or explicit messages when optionality matters
  3. Choose the RPC shape from the interaction model.
    • unary for request/response
    • server streaming for large or progressive result sets
    • client streaming for uploads or batches
    • bidirectional streaming for coordinated two-way flows
  4. Wire server and client behavior together.
    • register services with AddGrpc
    • use AddGrpcClient or long-lived GrpcChannel reuse
    • set deadlines and propagate cancellation
    • convert domain failures to appropriate RpcException status codes
  5. Add observability and resilience where the boundary justifies it.
    • logging or exception interceptors
    • OpenTelemetry traces and status-code metrics
    • retry policy only for safe idempotent calls
  6. Validate with the repo's normal build and tests, plus a focused smoke call when runnable.
Show full SKILL.md (243 more words)Show less

Current Upstream Notes

  • dotnet/aspnetcore v10.0.11 is servicing and does not change the gRPC programming model. Keep guidance focused on proto compatibility, streaming shape, deadlines, cancellation, channel reuse, and smoke calls.
  • The August 2026 ASP.NET Core overview still treats gRPC as a contract-first RPC option. After package servicing updates, regenerate protobuf outputs only when inputs or generator packages actually changed; do not churn generated files as a proxy for validation.
mermaid
flowchart LR
  A["RPC requirement"] --> B["proto contract"]
  B --> C["server implementation"]
  B --> D["client factory or channel"]
  C --> E["deadlines / cancellation / status codes"]
  D --> E
  E --> F["build, tests, smoke call"]

Examples

Use client factory for normal app integration:

csharp
builder.Services.AddGrpcClient<Greeter.GreeterClient>(options =>
{
    options.Address = new Uri("https://localhost:5001");
});

Always set a deadline and pass cancellation:

csharp
var response = await client.SayHelloAsync(
    new HelloRequest { Name = name },
    deadline: DateTime.UtcNow.AddSeconds(5),
    cancellationToken: cancellationToken);

For streaming, check cancellation inside the read/write loop and keep message sizes bounded. Load references/patterns.md before writing detailed streaming code.

Anti-Patterns

  • creating a new GrpcChannel per call
  • omitting deadlines and relying only on client-side cancellation
  • ignoring ServerCallContext.CancellationToken in streaming handlers
  • sending large single messages instead of chunking or streaming
  • using gRPC as the default public browser API
  • swallowing exceptions inside interceptors
  • retrying non-idempotent calls without explicit policy

Deliver

  • stable protobuf contracts and generated-code ownership
  • service and client code that match the RPC shape
  • explicit deadline, cancellation, retry, and status-code behavior
  • tests or smoke checks for serialization and call behavior
  • documentation of browser, transport, or deployment constraints when relevant

Validate

  • dotnet build succeeds after contract or generated-code changes
  • tests or smoke checks exercise at least one server/client call
  • streaming methods respect cancellation and bounded message sizes
  • channels are reused through client factory or a long-lived channel
  • status-code handling is intentional and observable
  • browser constraints are documented if gRPC-Web is involved

© managedcode, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 3 other files (references) in catalog/Frameworks/gRPC/skills/grpc of managedcode/dotnet-skills.

  • SKILL.md
  • manifest.json
  • references/anti-patterns.md
  • references/patterns.md

Open the folder on GitHubat commit 535dd55

Compare with similar skills

Grpc next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Grpc compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Grpc this skillmanagedcode/dotnet-skills486—~1.4kAutomated safety check: PassMIT
Aspnet Corefanslead/ReverseProxy.Store1632 repos~1.4kAutomated safety check: PassApache-2.0
Dotnet APInovotnyllc/dotnet-artisan233—~1.6kAutomated safety check: PassMIT
Using Dotnetnovotnyllc/dotnet-artisan233—~2.3kAutomated safety check: WarnMIT
Dotnet Webapidotnet/skills5.6k2 repos~5.5kAutomated safety check: PassMIT
SerializationAaronontheweb/dotnet-skills1.2k1 repos~2.7kAutomated safety check: PassMIT

Similar skills

  • Aspnet Core

    fanslead/ReverseProxy.Store

    Build, review, refactor, or architect ASP.NET Core web applications using current official guidance for .NET web development.

    163 GitHub starsUsed in 2 repos~1.4k tokens
    Backend & APIsAuto-check passed
  • Dotnet API

    novotnyllc/dotnet-artisan

    Builds ASP.NET Core APIs, EF Core data access, gRPC, SignalR, and backend services with middleware, security (OAuth, JWT, OWASP), resilience, messaging, OpenAPI, .NET Aspire, Semantic Kernel…

    233 GitHub stars~1.6k tokensUpdated today
    Backend & APIsAuto-check passed
  • Using Dotnet

    novotnyllc/dotnet-artisan

    Detects .NET intent for any C, ASP.NET Core, EF Core, Blazor, MAUI, Uno Platform, WPF, WinUI, SignalR, gRPC, xUnit, NuGet, or MSBuild request from prompt keywords and repository signals (.sln…

    233 GitHub stars~2.3k tokensUpdated today
    Backend & APIsAuto-check: warnings
  • Dotnet Webapi

    dotnet/skills

    Official

    Guides creation and modification of ASP.NET Core Web API endpoints with correct HTTP semantics, OpenAPI metadata, and error handling.

    5.6k GitHub starsUsed in 2 repos~5.5k tokens
    Backend & APIsAuto-check passed
  • Serialization

    Aaronontheweb/dotnet-skills

    Choose the right serialization format for .NET applications.

    1.2k GitHub starsUsed in 1 repo~2.7k tokens
    Backend & APIsAuto-check passed
  • Use Yaak

    mountain-loop/yaak

    A skill your agent uses when the user mentions Yaak, a Yaak workspace, or the yaak command, or asks to call, hit, or smoke test HTTP/REST endpoints, save or organize API requests for reuse or manual…

    19k GitHub stars~1.9k tokensUpdated yesterday
    Backend & APIsAuto-check passed

More from managedcode/dotnet-skills

All 81 skills in this repo
  • Analyzer Config

    managedcode/dotnet-skills

    Use a repo-root .editorconfig to configure free .NET analyzer and style rules.

    486 GitHub stars~1.3k tokensUpdated today
    Auto-check passed
  • Archunitnet

    managedcode/dotnet-skills

    Use the open-source free ArchUnitNET library for architecture rules in .NET tests.

    486 GitHub stars~1.2k tokensUpdated today
    Auto-check passed
  • Aspire

    managedcode/dotnet-skills

    Build, upgrade, and operate Aspire 13.5.x C or TypeScript application hosts with the current CLI, AppHost, ServiceDefaults, integrations, dashboard, testing, MCP, and deployment patterns for…

    486 GitHub stars~3.6k tokensUpdated today
    Auto-check passed
  • Aspnet Core

    managedcode/dotnet-skills

    Build, debug, modernize, or review ASP.NET Core applications with correct hosting, middleware, security, configuration, logging, and deployment patterns on current .NET.

    486 GitHub stars~2.1k tokensUpdated today
    Auto-check passed
  • Asynkron Profiler

    managedcode/dotnet-skills

    Use the open-source free Asynkron.Profiler dotnet tool for CLI-first CPU, allocation, exception, contention, and heap profiling of .NET commands or existing trace artifacts.

    486 GitHub stars~1.7k tokensUpdated today
    Auto-check passed
  • Azure Functions

    managedcode/dotnet-skills

    Build, review, or migrate Azure Functions in .NET with correct execution model, isolated worker setup, bindings, DI, and Durable Functions patterns.

    486 GitHub stars~2.6k tokensUpdated today
    Auto-check passed

Categories

Questions about Grpc

What does Grpc do?

Build or review gRPC services and clients in .NET. An agent skill from managedcode/dotnet-skills. Grpc is an agent skill from managedcode/dotnet-skills.NET.

When should I use Grpc?

Grpc fits situations like: : ASP.NET Core gRPC; protobuf contracts; GRPC client factory; backend service integration.

How do I install Grpc in Claude Code?

Run `npx skills add managedcode/dotnet-skills --skill grpc -a claude-code`. Or copy the skill folder (catalog/Frameworks/gRPC/skills/grpc in managedcode/dotnet-skills) into .claude/skills/grpc in your project. Claude Code loads it when a task matches its description.

How do I install Grpc in Codex?

Run `npx skills add managedcode/dotnet-skills --skill grpc -a codex`. Or copy the skill folder (catalog/Frameworks/gRPC/skills/grpc in managedcode/dotnet-skills) into .agents/skills/grpc in your project. Codex loads it when a task matches its description.

Can I use Grpc in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add managedcode/dotnet-skills --skill grpc -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/grpc, .gemini/skills/grpc, .github/skills/grpc and .opencode/skills/grpc in your project.

What does Grpc need to run?

Going by SKILL.md and its folder, Grpc needs the command-line tools its instructions call (dotnet). Compatibility (from SKILL.md): Requires ASP.NET Core gRPC or gRPC client projects..

Does Grpc access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Grpc safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Grpc use?

Grpc is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Grpc use?

About 1.4k tokens (SKILL.md is roughly 5.5k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 12k tokens, read only when the agent opens those files.

What are the alternatives to Grpc?

Skills that share tags, products or a category with Grpc: Aspnet Core (fanslead/ReverseProxy.Store, 163 stars), Dotnet API (novotnyllc/dotnet-artisan, 233 stars), Using Dotnet (novotnyllc/dotnet-artisan, 233 stars) and Dotnet Webapi (dotnet/skills, 5.6k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Grpc?

managedcode (a GitHub organization) maintains it in managedcode/dotnet-skills, which has 486 GitHub stars. The repository holds 81 skills in this directory. The repository was last updated on October 7, 2026.

Source: managedcode/dotnet-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.