Skip to content
Back to search

dotnet-agentic-engineering

MarketplaceWorks with Claude CodeGitHub

Battle-tested agentic engineering for .NET, Aspire, Azure, Fabric, Orleans and Uno Platform

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/vincenth-net--dotnet-agentic-engineering/badge.svg)](/listings/vincenth-net--dotnet-agentic-engineering)

HTML

<a href="/listings/vincenth-net--dotnet-agentic-engineering"><img src="/api/listings/vincenth-net--dotnet-agentic-engineering/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

From a repo root folder, run:

dnx agentic.check

This detects .NET, ASP.NET Core, Orleans and Uno Platform usage, lists the recommended directives, skills and tools, and lets you select which to install or update.

For Uno Platform, the offered skills are further refined depending on detected:

- MVVM or MVUX update pattern - Pure XAML markup or XAML combined with either Uno C# Markup or C# Markup 2 - Fluent / Material / Simple / Cupertino design system - Uno.Sdk version: from 7.0 on you get the current [Uno Platform Studio](https://github.com/unoplatform/studio) skills, which are written for Uno.Sdk 7; on an earlier Uno.Sdk you get the Studio skills written for it

When you move a repo to Uno.Sdk 7, the next `dna check` offers to replace the earlier Studio skills with the current ones.

For .NET, the `cli-e2e-testing` skill is offered only when a project interacts with a terminal: it is packaged as a dotnet tool, references a command-line or terminal UI package such as System.CommandLine, Spectre.Console or Hex1b, or reads console input. A console app that only writes output does not qualify.

With `--preview`, the `dotnet-breaking-changes` skill is offered only when a project is a published library, whose callers are outside the repo: it tracks its public API (`PublicAPI.Shipped.txt`, package validation or ApiCompat), or it sets `PackageId`, `IsPackable` or `GeneratePackageOnBuild` and is not a dotnet tool. A class library that only the same repo uses does not qualify. The `process-api-net11` and `system-text-json-net11` skills are offered, also with `--preview`, only when a project targets `net11.0` or later. The `migrate-dotnet10-to-dotnet11` skill is offered only when a project still targets `net10.0`.

By default skills come from the latest stable release in each source repo; `--preview` switches that to each source repo's default branch. The Studio skills for an Uno.Sdk before 7.0 come from the last Studio release that has them, on either channel. Target agents default to the ones found on your machine; `--agents` overrides that and decides the skills directories, such as `.claude/skills` and `.agents/skills`. For more options such as `--dry-run` and `--preview`, run:

dnx agentic.check -- -h

Directives are installed in `AGENTS.md` (which is included in `CLAUDE.md`), skills with `gh skill`, tools with `dotnet tool`; for Codex, rules to run `dotnet` with network access go in `.codex/rules`. Whenever `dna check` has something to apply in a repository whose `README.md` does not link here yet, it also offers a "built with: dna" badge, selected like every other recommendation and deselectable in the list.

GitHub login is optional. Without it, public sources are read anonymously, which is enough for a handful of skills. If GitHub's anonymous rate limit is reached, `agentic.check` stops and asks you to run `gh auth login`or wait, and then rerun; completed changes are kept. When you are logged in, the `gh` credential is reused for all GitHub requests. Automation can set `GH_TOKEN` or `GITHUB_TOKEN`.

`agentic.check` offers to install or update `dotnet agentic` in your repo when a selected directive or skill depends on it.

A directive that tells agents to use a skill is selected together with that skill: selecting the directive selects the skill, and deselecting the skill deselects the directive.

It also offers to install the global `dna`shorthand command for `agentic.check` and `dotnet agentic` (the repo setup tool and the repo-local tool that directives and skills call). After this, you can also install or update repo's with:

dna check

> [!TIP] > The `dna`shorthand is not _required_; if you cannot install a global tool, or another `dna` command is on your PATH, use `dnx agentic.check` instead of `dna check` and use `dotnet agentic <command>`for any other `dna <command>`.

Specialize folders

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 28 lines
  1. {
  2. "name": "dotnet-agentic-engineering",
  3. "owner": {
  4. "name": "Vincent Hoogendoorn",
  5. "url": "https://github.com/VincentH-Net"
  6. },
  7. "metadata": {
  8. "description": "Battle-tested agentic engineering plugins for .NET, Orleans, and Uno Platform",
  9. "version": "1.4.5"
  10. },
  11. "plugins": [
  12. {
  13. "name": "dotnet",
  14. "source": "./plugins/dotnet",
  15. "description": "Skills for .NET development including CLI end-to-end testing, charting with LiveCharts2, a modern C# 14 editorconfig baseline and C# refactoring"
  16. },
  17. {
  18. "name": "orleans",
  19. "source": "./plugins/orleans",
  20. "description": "Skills for Microsoft Orleans 10 development including the result pattern, the multiservice modular-monolith pattern and multitenancy"
  21. },
  22. {
  23. "name": "uno-platform",
  24. "source": "./plugins/uno-platform",
  25. "description": "Skills for Uno Platform cross-platform development including Fluent design, navigation, responsive layouts, C# Markup 2 (CSharpForMarkup), agentic app run support, and testing"
  26. }
  27. ]
  28. }
README.md · README · 219 lines
  1. # dotnet-agentic-engineering
  2. [![built with: dna](https://img.shields.io/badge/built%20with-dna-512BD4)](https://github.com/VincentH-Net/dotnet-agentic-engineering)
  3. Battle-tested agentic engineering for [.NET](https://dotnet.microsoft.com), [Aspire](https://aspire.dev), [Azure](https://azure.microsoft.com), [Fabric](https://www.microsoft.com/en-us/microsoft-fabric), [Orleans](https://learn.microsoft.com/en-us/dotnet/orleans) and [Uno Platform](https://platform.uno)
  4. ## What this is
  5. Agentic engineering `directives`, `skills` and `tools` that I use for building real-world .NET applications, plus the [dev environment setup](docs/dev-environment-setup.md) I use them with. Everything here has been used with real-world codebases - not generated with prompts and published untested.
  6. > [!NOTE]
  7. > [Directives](#directives-catalog) are small markdown snippets with agent instructions. They are included in `AGENTS.md`to ensure that agents consistently apply key habits, skills and tools.
  8. Install `dna` once per machine, then one command does everything:
  9. - **`dna check`** scans your repo, detects your tech stack, and composes, installs and updates an optimized set of directives and skills, directly from best-in-class GitHub skills repo's. Where a directive or skill needs deterministic tooling, it installs that tool too, pinned once per repository. Run it again any time: directives, skills and tools are updated together, so they stay compatible, and a tool that is already the latest on nuget.org is left alone. A skill that a newer release no longer offers is removed again, so a repository never keeps two generations of the same skills.
  10. - **`dotnet agentic`** is the repo-local tool that directives and skills call for their deterministic steps; `dna check` installs it and keeps it versioned with them, and then `dna` acts as a shortcut for the `dotnet agentic` commands so you have less to remember and type.
  11. - **`dna prompt-log`** shows the prompts and answers that produced your commits.
  12. > [!NOTE]
  13. > `dna`: [dotnet-agentic-engineering](https://github.com/VincentH-Net/dotnet-agentic-engineering) in one command
  14. This 66-second video shows the check on a new Uno Platform 7 app on .NET 11:
  15. https://github.com/user-attachments/assets/e2b27903-7cfa-48a1-87b6-9d489a4288d5
  16. This 73-second video shows what an agent then does in such a repo with one prompt, "Run the app":
  17. https://github.com/user-attachments/assets/202a8ec0-8527-4dfc-a732-bd42f05cc93b
  18. The skills available for composition are carefully tested and are selected from best-in-class GitHub skills repo's:
  19. - [dotnet/skills](https://github.com/dotnet/skills)
  20. - [unoplatform/studio](https://github.com/unoplatform/studio)
  21. - [noknowscode/UnoPlatformSkills](https://github.com/noknowscode/UnoPlatformSkills)
  22. - [VincentH-Net/dotnet-agentic-engineering](https://github.com/VincentH-Net/dotnet-agentic-engineering)
  23. This repo saves .NET software engineers a significant, ongoing effort:
  24. - **filter** proven engineering value from untested content and marketing in the agentic ecosystem
  25. - **fill** agentic ecosystem gaps, both technology-independent and for specific technologies
  26. - **extend** the agentic ecosystem with specialized technology/pattern skills for distributed/cross-platform applications
  27. - **compose** an optimal set of directives, skills and tools for your repo and tech stack, while avoiding contradictions and ambiguities that may cause agent mistakes
  28. - eliminate papercuts: prevents long codex timeout delays from repeatedly trying to run `dotnet` without network access
  29. - **improve agent reliability and reduce context usage** by moving deterministic logic out of directives and skills into `dotnet agentic`, a repo-local tool
  30. Demos:
  31. - [.NET Agentic Engineering](https://x.com/vincenth_net/status/2060378391459586239)
  32. (post with steps to get started)
  33. - [LiveCharts2 with Uno Platform](https://x.com/vincenth_net/status/2033966275324444819)
  34. (post with app video)
  35. - [GPT 5.4 vs Opus 4.6 for UI with Uno Platform](https://x.com/vincenth_net/status/2031408477344587799)
  36. (article with side-by-side apps video)
  37. 👁️/⭐ this repo if this includes what you are looking for!
  38. ## Get started
  39. Prerequisites:
  40. - [.NET 10 SDK](https://dotnet.microsoft.com/download) or later
  41. - [`gh` CLI](https://cli.github.com/). Skills are installed with `gh skill`, which uses GitHub's API quota. Anonymous access is enough for a handful of skills; `gh auth login` gives you a much higher quota, and `agentic.check` tells you when you need it.
  42. - Optional: [Git](https://git-scm.com/downloads). Inside a repository that has a `.gitignore`, `dna check` takes its file list from git, so ignored output folders are never scanned. Otherwise it walks the folder and skips `bin`, `obj`, `TestResults` and similar output folders.
  43. - Recommended: check the [Agentic Development Environment Setup](docs/dev-environment-setup.md) for models, harnesses and MCPs
  44. ### 1. Install or update in a repo
  45. From a repo root folder, run:
  46. ```bash
  47. dnx agentic.check
  48. ```
  49. This detects .NET, ASP.NET Core, Orleans and Uno Platform usage, lists the recommended directives, skills and tools, and lets you select which to install or update.
  50. For Uno Platform, the offered skills are further refined depending on detected:
  51. - MVVM or MVUX update pattern
  52. - Pure XAML markup or XAML combined with either Uno C# Markup or C# Markup 2
  53. - Fluent / Material / Simple / Cupertino design system
  54. - Uno.Sdk version: from 7.0 on you get the current [Uno Platform Studio](https://github.com/unoplatform/studio) skills, which are written for Uno.Sdk 7; on an earlier Uno.Sdk you get the Studio skills written for it
  55. When you move a repo to Uno.Sdk 7, the next `dna check` offers to replace the earlier Studio skills with the current ones.
  56. For .NET, the `cli-e2e-testing` skill is offered only when a project interacts with a terminal: it is packaged as a dotnet tool, references a command-line or terminal UI package such as System.CommandLine, Spectre.Console or Hex1b, or reads console input. A console app that only writes output does not qualify.
  57. With `--preview`, the `dotnet-breaking-changes` skill is offered only when a project is a published library, whose callers are outside the repo: it tracks its public API (`PublicAPI.Shipped.txt`, package validation or ApiCompat), or it sets `PackageId`, `IsPackable` or `GeneratePackageOnBuild` and is not a dotnet tool. A class library that only the same repo uses does not qualify. The `process-api-net11` and `system-text-json-net11` skills are offered, also with `--preview`, only when a project targets `net11.0` or later. The `migrate-dotnet10-to-dotnet11` skill is offered only when a project still targets `net10.0`.
  58. By default skills come from the latest stable release in each source repo; `--preview` switches that to each source repo's default branch. The Studio skills for an Uno.Sdk before 7.0 come from the last Studio release that has them, on either channel. Target agents default to the ones found on your machine; `--agents` overrides that and decides the skills directories, such as `.claude/skills` and `.agents/skills`. For more options such as `--dry-run` and `--preview`, run:
  59. ```bash
  60. dnx agentic.check -- -h
  61. ```
  62. Directives are installed in `AGENTS.md` (which is included in `CLAUDE.md`), skills with `gh skill`, tools with `dotnet tool`; for Codex, rules to run `dotnet` with network access go in `.codex/rules`. Whenever `dna check` has something to apply in a repository whose `README.md` does not link here yet, it also offers a "built with: dna" badge, selected like every other recommendation and deselectable in the list.
  63. GitHub login is optional. Without it, public sources are read anonymously, which is enough for
  64. a handful of skills. If GitHub's anonymous rate limit is reached, `agentic.check` stops and asks
  65. you to run `gh auth login`or wait, and then rerun; completed changes are kept. When you are logged in, the
  66. `gh` credential is reused for all GitHub requests. Automation can set `GH_TOKEN` or `GITHUB_TOKEN`.
  67. `agentic.check` offers to install or update `dotnet agentic` in your repo when a selected directive or skill depends on it.
  68. A directive that tells agents to use a skill is selected together with that skill: selecting the directive selects the skill, and deselecting the skill deselects the directive.
  69. It also offers to install the global `dna`shorthand command for `agentic.check` and `dotnet agentic` (the repo setup tool and the repo-local tool that directives and skills call). After this, you can also install or update repo's with:
  70. ```bash
  71. dna check
  72. ```
  73. > [!TIP]
  74. > The `dna`shorthand is not _required_; if you cannot install a global tool, or another `dna` command is on your PATH, use `dnx agentic.check` instead of `dna check` and use `dotnet agentic <command>`for any other `dna <command>`.
  75. #### Specialize folders
  76. You can specialize folders within your repo with subsets of directives and skills local to that context, e.g. frontend or backend folders. This reduces your agent context size as compared to installing all directives and skills in the repo root. A directive and the skill it tells agents to use are installed in the same folder. For details on this:
  77. ```bash
  78. dna check -h
  79. ```
  80. #### Keep your repo current
  81. Run `dna check` again after adding a technology, and regularly to pick up skill updates. Directives, skills and tools are updated together. Teammates who clone the repo install `dna` the same way and run `dna check`, which restores the pinned tool; `dotnet tool restore` restores it alone.
  82. Alternatively, you can [manually compose and install directives and skills](docs/manual-install.md).
  83. ### 2. Work with your agent
  84. Agents follow the installed directives and skills. Directives may use skills; directives and skills may use `dotnet agentic`. Humans use `dna`; to see the available commands, run:
  85. ```bash
  86. dna -h
  87. ```
  88. #### The prompt log
  89. With the [Prompt Log directive](directives/foundation-prompt-log.md), every code commit an agent creates carries the prompts and answers that produced it - the most important part of your source : your input.
  90. This preserves intent across sessions and agents; it enables reusing intent for context in later sessions, or even replaying intent when more capable models appear. Read it back any time:
  91. ```bash
  92. dna prompt-log -h
  93. dna prompt-log
  94. dna prompt-log --since 2026-09-01
  95. ```
  96. ## The tools
  97. | Package | Command | Installed | Purpose |
  98. |---|---|---|---|
  99. | [Agentic.Check](src/Agentic.Check/README.md) | `dna check` | Not installed; `dna check` runs the latest stable version, as does `dnx agentic.check` | Detects your stack; composes, installs and updates directives, skills and tools |
  100. | [InnoWvate.Agentic](src/Agentic/README.md) | `dna <command>` | Once per repository, pinned in the repo root's `.config/dotnet-tools.json` | Deterministic logic that directives and skills delegate to, as commands for agents and humans; today prompt logging, plus `check` for the latest Agentic.Check |
  101. | [InnoWvate.Dna](src/Dna/README.md) | `dna` | Global, once per machine | Shorthand for `agentic.check`and the repo-local `dotnet agentic` |
  102. ## What's included
  103. Currently this repo includes technology-independent content and content specific for [.NET](https://dotnet.microsoft.com), [Microsoft Orleans](https://learn.microsoft.com/en-us/dotnet/orleans) and [Uno Platform](https://platform.uno).
  104. In the coming months I will be adding content for the latest [.NET](https://dotnet.microsoft.com), [Aspire](https://aspire.dev), [Azure](https://azure.microsoft.com), [Fabric](https://www.microsoft.com/en-us/microsoft-fabric), [Orleans](https://learn.microsoft.com/en-us/dotnet/orleans) and [Uno Platform](https://platform.uno) as I progress applying agentic engineering to a real-world distributed, cross-platform application that I am building with this technology stack.
  105. ## Directives catalog
  106. This repo offers the following directives (markdown snippets to include in your AGENTS.md / CLAUDE.md):
  107. | Directive | Description |
  108. |----------|-------------|
  109. | [`foundation-documentation-sources`](./directives/foundation-documentation-sources.md) | Prioritizes first-party vendor MCPs for external documentation, e.g. using Microsoft Learn before Context7 for Microsoft technologies. |
  110. | [`foundation-prompt-log`](./directives/foundation-prompt-log.md) | Records sanitized user prompts and agent question-and-answer pairs in code commit messages so intent is preserved and can be replayed later. Uses the `dotnet agentic` tool. |
  111. | [`dotnet-cli-run`](./directives/dotnet-cli-run.md) | Prevents long agent timeout delays from running `dotnet` without network access. For Codex, `dna check` also offers rules that run `dotnet` outside the sandbox without approval prompts. |
  112. | [`dotnet-build-errors-and-warnings`](./directives/dotnet-build-errors-and-warnings.md) | Configures .NET build warnings and errors and a modern C# .editorconfig, then directs agents to fix build errors and warnings or document rare justified suppressions. Uses the `dotnet-modern-csharp-editorconfig` skill. |
  113. | [`dotnet-backward-compatible-renames`](./directives/dotnet-backward-compatible-renames.md) | Keeps stored data, deployed settings and other clients working when agents rename or restructure: a name that leaves the repo keeps working, or what uses it is migrated. Name the directive in a request to allow a breaking rename for that change. Deselect it in `dna check` while nothing outside the repo depends on the project yet. Uses the `dotnet-refactoring` skill. |
  114. | [`uno-build-and-run`](./directives/uno-build-and-run.md) | Registers the Uno Platform MCPs at folder scope when they are missing, and standardizes Uno app launch for agents by skipping redundant pre-builds, writing per-run stdout logs via `AGENT_CONSOLE_LOG`, and verifying or stopping the app with the Uno runtime tools. After a change to platform-specific code, the agent also builds the other targets that compile it. Uses the `uno-agentic-support` skill. |
  115. ## Skills catalog
  116. To complement the skills from the other GitHub repo's (listed above), this repo offers below skills. They are grouped in plugins for ease of [manual installation](docs/manual-install.md), however `dna check` selects or excludes each skill individually.
  117. ### dotnet plugin
  118. Skills for .NET development.
  119. | Skill | Description |
  120. |-------|-------------|
  121. | `cli-e2e-testing` | CLI end-to-end testing guide for real terminal flows with Hex1b automation, keyboard input, observable terminal output, and asciinema recordings. |
  122. | `dotnet-livecharts2` | LiveCharts2 development guide — installation, XAML source generator integration, theme config, gotchas, and sample index with exact repo file paths. Covers all platforms (WinUI, Uno, Avalonia, MAUI, WPF, Blazor, WinForms, Eto). |
  123. | `dotnet-modern-csharp-editorconfig` | Drop-in opinionated `.editorconfig` for modern C# (C# 14 / .NET 10, also works with C# 10–13) — formatting, naming, style, and preview analyzer severities. Covers required `.csproj` flags and the .NET 8 vs .NET 9+ build-respect-editorconfig distinction. |
  124. | `dotnet-refactoring` | What a green build does not check when C# code is refactored — names read at runtime, edits to text that only looks like a reference, behavior drift while deduplicating, generated and partial code, and targets the default build skips. Follows the `dotnet-backward-compatible-renames` directive for names that leave the repo. |
  125. ### orleans plugin
  126. Skills for [Microsoft Orleans 10](https://learn.microsoft.com/en-us/dotnet/orleans) actor-based distributed applications.
  127. | Skill | Description |
  128. |-------|-------------|
  129. | `orleans-result-pattern` | Concise, version-tolerant result pattern for Orleans 8+ grain calls — `Result` / `Result<T>` with `enum ErrorNr` + `string` errors, `[Immutable]` for zero-copy within-silo calls, implicit conversions, and RFC7807 `ValidationProblemDetails` via `TryAsValidationErrors`. |
  130. | `orleans-multiservice-pattern` | Modular-monolith pattern for Orleans 10 — host multiple logical services in one silo with strict `Apis → Contracts`, `Apis → Service`, `Service → Contracts` dependency rules so any logical service can later be extracted to its own physical microservice with minimal changes. |
  131. | `orleans-multitenant` | Multitenancy for Orleans 10 with [Orleans.Multitenant](https://github.com/VincentH-Net/Orleans.Multitenant) — per-tenant grain storage and tenant separation of grain calls and streams. Covers adding the package, silo configuration, the tenant aware API for grains and streams, stream subscriptions, cross-tenant authorization, troubleshooting, and the 4.x to 5.x upgrade. |
  132. ### uno-platform plugin
  133. Skills for [Uno Platform](https://platform.uno) cross-platform app development.
  134. | Skill | Description |
  135. |-------|-------------|
  136. | `uno-agentic-support` | In-app support for agent-driven Uno app runs — detects `AGENT_CONSOLE_LOG`, captures early stdout/stderr logging, and disables Uno Studio Hot Reload / Hot Design UI during agent UI testing. |
  137. | `uno-csharpmarkup2` | Build a Uno Platform 6 UI in pure C# with [C# Markup 2 (CSharpForMarkup)](https://github.com/VincentH-Net/CSharpForMarkup) — covers both the initial Presentation-project setup and ongoing per-page authoring via the included `New-View.ps1` helper. MVVM/MVUX, Skia/native renderer, bind-without-strings, Spread, conditional children, and the markup/logic partial-class split. |
  138. | `uno-fluent2` | Fluent 2 Design System for Uno Platform — color, typography, geometry, materials, motion, iconography, spacing, elevation, lightweight styling, and responsive breakpoints. |
  139. | `uno-hamburgermenu-databinding` | Data-bound, hierarchical hamburger menu with dynamic navigation using Uno Navigation Extensions `NavigationView` and MVVM. |
  140. | `uno-livecharts2-theme-switching` | Reliable in-app dark/light/system theme switching for LiveCharts2 in Uno Platform — shared palettes, central chart refresh, and rendered-pixel verification. |
  141. | `uno-mvvm` | Uno Platform MVVM with CommunityToolkit.Mvvm — partial observable properties, generated commands, constructor DI, x:Bind patterns, and Uno Navigation from ViewModels. |
  142. | `uno-xaml` | Uno Platform XAML correctness and performance — deferred loading, virtualized templates, UI lifecycle cleanup, UI-thread safety, input scopes, keyboard accelerators, focus, and drag/drop caveats without overriding selected MVVM, navigation, or design-system guidance. |
  143. | `uno-responsive-spanning-gridwrap-layout` | A responsive, non-virtualizing wrapping grid layout with column spans, proportional stretch-to-fill, and vertically aligned gaps. |
  144. | `uno-test-resize-app-window` | Resize a running Uno Platform desktop app window on macOS for visual testing using the Accessibility API. |
  145. ## License
  146. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.