From 0f1eeb69c4abd80f19546373696e7e2c797371db Mon Sep 17 00:00:00 2001
From: "Wendy Breiding (She/Her)" <webreidi@microsoft.com>
Date: Thu, 11 Jun 2026 08:45:01 -0700
Subject: [PATCH 01/11] Add csharp-development skill and update CODEOWNERS and
 README.md

- Introduced a new skill for C# development guidance.
- Updated CODEOWNERS to include reviewers for the new skill.
- Modified README.md to list the new csharp-development skill.
- Added evaluation scenarios for the csharp-development skill.
---
 .github/CODEOWNERS                            |   4 +-
 plugins/dotnet/README.md                      |   1 +
 .../dotnet/skills/csharp-development/SKILL.md | 119 ++++++++++++++++++
 .../item-management/Constants.g.cs            |   3 +-
 .../dotnet/csharp-development/eval.vally.yaml |  54 ++++++++
 tests/dotnet/csharp-development/eval.yaml     |  61 +++++++++
 6 files changed, 240 insertions(+), 2 deletions(-)
 create mode 100644 plugins/dotnet/skills/csharp-development/SKILL.md
 create mode 100644 tests/dotnet/csharp-development/eval.vally.yaml
 create mode 100644 tests/dotnet/csharp-development/eval.yaml

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index cf40dbd067..255caa02ff 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -10,6 +10,9 @@
 /tests/dotnet-msbuild/ @ViktorHofer @JanKrivanek @dotnet/skills-msbuild-reviewers
 
 # dotnet (common everyday C#/.NET)
+/plugins/dotnet/skills/csharp-development/ @dotnet/skills-csharp-language-reviewers
+/tests/dotnet/csharp-development/ @dotnet/skills-csharp-language-reviewers
+
 /plugins/dotnet/skills/csharp-scripts/ @dotnet/run-file @dotnet/skills-csharp-language-reviewers
 /tests/dotnet/csharp-scripts/ @dotnet/run-file @dotnet/skills-csharp-language-reviewers
 
@@ -144,4 +147,3 @@
 
 /plugins/dotnet11/skills/system-text-json-net11/ @ManishJayaswal @JanKrivanek @ViktorHofer
 /tests/dotnet11/system-text-json-net11/ @ManishJayaswal @JanKrivanek @ViktorHofer
-
diff --git a/plugins/dotnet/README.md b/plugins/dotnet/README.md
index f0ca96307c..81b71e3820 100644
--- a/plugins/dotnet/README.md
+++ b/plugins/dotnet/README.md
@@ -17,6 +17,7 @@ Prerequisites:
 
 ## Skills
 
+- csharp-development
 - csharp-scripts
 - dotnet-pinvoke
 - nuget-trusted-publishing
diff --git a/plugins/dotnet/skills/csharp-development/SKILL.md b/plugins/dotnet/skills/csharp-development/SKILL.md
new file mode 100644
index 0000000000..709c91e2e1
--- /dev/null
+++ b/plugins/dotnet/skills/csharp-development/SKILL.md
@@ -0,0 +1,119 @@
+---
+name: csharp-development
+description: "Use whenever writing C# code. Provides general C#/.NET guidance for clean, maintainable, secure, performant implementation, refactoring, async, error handling, project conventions, and high-level testing strategy."
+license: MIT
+---
+
+# C# Development
+
+Help developers implement and improve C#/.NET code using project conventions first, then modern .NET practices. This skill covers general design, implementation, refactoring, async, error handling, security, performance, and high-level testing guidance without prescribing a specific test framework.
+
+## When to Use
+
+- The user asks for general C# or .NET implementation help
+- The user wants to design, refactor, or review everyday C# code
+- The user needs guidance on async, dependency injection, error handling, or API shape
+- The user wants production-ready C# guidance for security, resilience, logging, or performance
+- The user asks how to test new or changed C# behavior at a high level
+
+## When Not to Use
+
+- The user needs file-based C# apps without a project; use `csharp-scripts`
+- The user is calling native C/C++ from .NET; use `dotnet-pinvoke`
+- The user is setting up NuGet trusted publishing; use `nuget-trusted-publishing`
+- The user needs framework-specific test syntax, test migration, filtering, or runner commands; use the relevant `dotnet-test` skill
+- The user is working in ASP.NET Core, Blazor, MAUI, EF Core, diagnostics, or upgrade scenarios with a more specific plugin skill available
+
+## Inputs
+
+| Input | Required | Description |
+|-------|----------|-------------|
+| Task or code context | Yes | The code, behavior, bug, design, or refactoring goal |
+| Project files | Recommended | `.csproj`, `.sln`, `global.json`, `Directory.Build.*`, or package configuration when relevant |
+| Existing conventions | Recommended | Nearby code, naming, visibility, nullable, logging, and test patterns to preserve |
+| Target runtime | No | Target framework, C# language version, platforms, and deployment constraints |
+
+## Workflow
+
+### Step 1: Inspect the project context
+
+Check the target framework, C# version, nullable settings, SDK selection, package management, and repo conventions before proposing changes. Inspect nearby code or supplied project files when they are available; when they are not, state the assumption and keep the answer compact instead of doing broad repository exploration. Do not change TFM, SDK, `LangVersion`, package versions, or project structure unless the user asked for that change or it is necessary for correctness.
+
+### Step 2: Preserve local conventions
+
+Follow the project's established naming, formatting, visibility, dependency injection, logging, nullable annotations, exception, and error-handling patterns. Prefer small, focused diffs and reuse existing helpers, extension methods, and validation utilities before adding new abstractions.
+
+### Step 3: Design the code
+
+- Keep public surface area minimal; prefer `private`, then `internal`, then `protected`, then `public`
+- Add interfaces or abstractions only when they represent external dependencies, stable seams, or testability needs
+- Avoid wrapping an abstraction in another abstraction unless it adds clear value
+- Keep responsibilities focused and apply SOLID principles pragmatically
+- Do not edit generated code such as `*.g.cs`, files under generated API folders, or files marked `<auto-generated>`
+- For isolated implementation requests without an existing project, provide code that can be added to the existing project; do not create or change project files just to make a snippet compile
+- Use comments to explain why something is non-obvious, not what straightforward code does
+
+### Step 4: Implement robust behavior
+
+- Use modern C# features when the target framework and language version already support them
+- Use `ArgumentNullException.ThrowIfNull` for null guards and `string.IsNullOrWhiteSpace` for meaningful string validation
+- Prefer precise exception types such as `ArgumentException` or `InvalidOperationException`
+- Match nullable behavior to the project: do not suppress nullable warnings with `!` unless the invariant is explicit and local
+- Do not catch or throw base `Exception` unless the surrounding codebase has a specific, justified pattern
+- Do not swallow errors; log with useful context or let exceptions propagate
+- Keep async flows async end-to-end and avoid sync-over-async
+
+### Step 5: Handle async and I/O carefully
+
+- Name async methods with an `Async` suffix
+- Always await work unless returning the task directly is clearer
+- Pass `CancellationToken` through public async flows and long-running loops
+- Use cancelable delays and timeouts that cancel pending work
+- In library/helper code, use `ConfigureAwait(false)` when consistent with the codebase
+- Stream large payloads instead of materializing them all at once
+- Dispose owned synchronous and asynchronous resources with `using` or `await using`
+
+### Step 6: Make production concerns explicit
+
+- Avoid secrets in code and logs
+- Validate external input and use least privilege for security-sensitive operations
+- Prefer structured logging with useful context and avoid noisy logs
+- Add timeouts and retry with backoff only when the operation is safe to retry
+- Keep code cross-platform unless the project is intentionally OS-specific
+- Optimize simple code only after identifying hot paths or clear allocation risks
+
+### Step 7: Provide high-level testing guidance
+
+- Identify the public behavior or observable outcome each test should protect
+- Use the test framework, fixtures, naming conventions, and assertion style already present in the repo
+- Test observable behavior through public APIs rather than implementation details
+- Keep each test focused on one behavior or outcome
+- Cover important edge cases, invalid inputs, cancellation, and failure paths
+- Prefer deterministic tests that can run in any order and in parallel
+- Avoid shared mutable state, timing-dependent waits, and unnecessary mocks
+- Use coverage as a gap-finding aid, not as the sole quality signal
+
+### Step 8: Validate the result
+
+Run the narrowest relevant build, test, formatter, or analyzer commands that already exist in the repo. Prefer scoped commands over full-repo validation when only one project or test file changed. Report the exact commands attempted and the exact blocker if validation cannot run because required SDKs or tools are unavailable; still perform static checks where possible.
+
+## Validation
+
+- [ ] The solution follows nearby C# and repo conventions
+- [ ] Public API changes are intentional and minimal
+- [ ] Error handling is precise and does not swallow failures
+- [ ] Async code passes cancellation through relevant boundaries
+- [ ] Security, logging, and performance tradeoffs are addressed when relevant
+- [ ] New or changed behavior has an appropriate high-level test plan or tests
+- [ ] Existing build, test, or analyzer commands were run when available, or the precise blocker was reported
+
+## Common Pitfalls
+
+| Pitfall | Solution |
+|---------|----------|
+| Adding abstractions by default | Add an interface or wrapper only when it creates a real seam or contract |
+| Changing project settings to enable preferred syntax | Use syntax supported by the existing TFM and language version |
+| Catching broad exceptions | Catch only specific exceptions you can handle, otherwise let them propagate |
+| Fire-and-forget async work | Await work or model background processing explicitly with cancellation and error reporting |
+| Testing private implementation details | Test public behavior and observable outcomes |
+| Introducing framework-specific test guidance | Keep test advice high level or route to a `dotnet-test` skill |
diff --git a/tests/dotnet-msbuild/item-management/Constants.g.cs b/tests/dotnet-msbuild/item-management/Constants.g.cs
index 74e3137073..30a49ae66d 100644
--- a/tests/dotnet-msbuild/item-management/Constants.g.cs
+++ b/tests/dotnet-msbuild/item-management/Constants.g.cs
@@ -1 +1,2 @@
-namespace ItemManagement { public static class Constants { public const int Version = 1; } }
+namespace ItemManagement { public static class Constants { public const int Version = 1
+} }
diff --git a/tests/dotnet/csharp-development/eval.vally.yaml b/tests/dotnet/csharp-development/eval.vally.yaml
new file mode 100644
index 0000000000..59b0bfb818
--- /dev/null
+++ b/tests/dotnet/csharp-development/eval.vally.yaml
@@ -0,0 +1,54 @@
+name: csharp-development
+description: Evaluates the dotnet/csharp-development skill
+type: capability
+config:
+  timeout: 5m
+stimuli:
+  - name: General C# refactoring guidance
+    prompt: I need to refactor a C# service method in an existing project. Give concise guidance for keeping the change clean, maintainable, async-safe, and consistent with nearby .NET conventions.
+    graders:
+      - type: output-matches
+        config:
+          pattern: nearby|existing|convention|async|CancellationToken|exception|public API|abstraction
+      - type: prompt
+      - type: pairwise
+    rubric:
+      - Preserves local project conventions before recommending generic patterns
+      - Covers async/cancellation and precise error handling where relevant
+      - Avoids unnecessary abstractions or broad project-setting changes
+  - name: Small feature implementation
+    prompt: Provide code for an existing C# project: add an async method that loads customer records from a stream, skips blank lines, supports cancellation, and returns parsed records. Do not create or change project files or settings.
+    graders:
+      - type: output-matches
+        config:
+          pattern: async|CancellationToken|ReadLineAsync|blank lines|project files|settings|record
+      - type: prompt
+      - type: pairwise
+    rubric:
+      - Provides a focused C# implementation for the requested feature
+      - Supports cancellation and async I/O without sync-over-async
+      - Skips blank lines and avoids changing TFM, SDK, LangVersion, or other project settings
+  - name: Nullable validation and error handling
+    prompt: Review this C# API shape and explain how you would implement validation without hiding nullable warnings: `public Customer Create(string? id, string? displayName)`. Keep the public API minimal and use precise exceptions.
+    graders:
+      - type: output-matches
+        config:
+          pattern: ArgumentNullException|ArgumentException|string.IsNullOrWhiteSpace|null|nullable|public API
+      - type: prompt
+      - type: pairwise
+    rubric:
+      - Distinguishes null validation from empty or whitespace validation
+      - Avoids nullable suppression as the primary solution
+      - Keeps public surface area minimal and exceptions precise
+  - name: Constraint-respecting review
+    prompt: A teammate suggests changing LangVersion and the target framework so a small helper can use newer C# syntax. Review that suggestion for an existing library where project settings should stay stable.
+    graders:
+      - type: output-matches
+        config:
+          pattern: LangVersion|target framework|project settings|existing|syntax|stable
+      - type: prompt
+      - type: pairwise
+    rubric:
+      - Rejects unnecessary project-setting changes for a small helper
+      - Recommends syntax compatible with the existing project context
+      - Balances maintainability with minimal, focused changes
diff --git a/tests/dotnet/csharp-development/eval.yaml b/tests/dotnet/csharp-development/eval.yaml
new file mode 100644
index 0000000000..09822ac6c2
--- /dev/null
+++ b/tests/dotnet/csharp-development/eval.yaml
@@ -0,0 +1,61 @@
+scenarios:
+  - name: "General C# refactoring guidance"
+    prompt: |
+      I need to refactor a C# service method in an existing project. Give concise
+      guidance for keeping the
+      change clean, maintainable, async-safe, and consistent with existing
+      .NET conventions.
+    assertions:
+      - type: output_matches
+        pattern: "(nearby|existing|convention|async|CancellationToken|exception|public API|abstraction)"
+      - type: exit_success
+    rubric:
+      - "Preserves local project conventions before recommending generic patterns"
+      - "Covers async/cancellation and precise error handling where relevant"
+      - "Avoids unnecessary abstractions or broad project-setting changes"
+    timeout: 120
+
+  - name: "Small feature implementation"
+    prompt: |
+      Provide code for an existing C# project: add an async method that loads customer
+      records from a stream, skips blank lines, supports cancellation, and
+      returns parsed records. Do not create or change project files or settings.
+    assertions:
+      - type: output_matches
+        pattern: "(async|CancellationToken|ReadLineAsync|blank lines|project files|settings|record)"
+      - type: exit_success
+    rubric:
+      - "Provides a focused C# implementation for the requested feature"
+      - "Supports cancellation and async I/O without sync-over-async"
+      - "Skips blank lines and avoids changing TFM, SDK, LangVersion, or other project settings"
+    timeout: 120
+
+  - name: "Nullable validation and error handling"
+    prompt: |
+      Review this C# API shape and explain how you would implement validation
+      without hiding nullable warnings: `public Customer Create(string? id,
+      string? displayName)`. Keep the public API minimal and use precise exceptions.
+    assertions:
+      - type: output_matches
+        pattern: "(ArgumentNullException|ArgumentException|string\\.IsNullOrWhiteSpace|null|nullable|public API)"
+      - type: exit_success
+    rubric:
+      - "Distinguishes null validation from empty or whitespace validation"
+      - "Avoids nullable suppression as the primary solution"
+      - "Keeps public surface area minimal and exceptions precise"
+    timeout: 120
+
+  - name: "Constraint-respecting review"
+    prompt: |
+      A teammate suggests changing LangVersion and the target framework so a
+      small helper can use newer C# syntax. Review that suggestion for an
+      existing library where project settings should stay stable.
+    assertions:
+      - type: output_matches
+        pattern: "(LangVersion|target framework|project settings|existing|syntax|stable)"
+      - type: exit_success
+    rubric:
+      - "Rejects unnecessary project-setting changes for a small helper"
+      - "Recommends syntax compatible with the existing project context"
+      - "Balances maintainability with minimal, focused changes"
+    timeout: 120

From ca08ea7a7975f2464b46c746cc489299fa279885 Mon Sep 17 00:00:00 2001
From: "Wendy Breiding (She/Her)" <webreidi@microsoft.com>
Date: Thu, 11 Jun 2026 09:51:28 -0700
Subject: [PATCH 02/11] Refactor C# evaluation scenarios to enhance production
 code review and validation guidance

---
 .../dotnet/skills/csharp-development/SKILL.md |  3 +
 .../dotnet/csharp-development/eval.vally.yaml | 88 +++++++++----------
 tests/dotnet/csharp-development/eval.yaml     | 42 +++------
 3 files changed, 60 insertions(+), 73 deletions(-)

diff --git a/plugins/dotnet/skills/csharp-development/SKILL.md b/plugins/dotnet/skills/csharp-development/SKILL.md
index 709c91e2e1..7195ebf76d 100644
--- a/plugins/dotnet/skills/csharp-development/SKILL.md
+++ b/plugins/dotnet/skills/csharp-development/SKILL.md
@@ -57,6 +57,8 @@ Follow the project's established naming, formatting, visibility, dependency inje
 
 - Use modern C# features when the target framework and language version already support them
 - Use `ArgumentNullException.ThrowIfNull` for null guards and `string.IsNullOrWhiteSpace` for meaningful string validation
+- When exception precision matters, keep null validation separate from empty or whitespace validation instead of collapsing distinct failures into one broader guard
+- When reviewing or refactoring code that accepts external input, explicitly check whether existing validation is missing, overly broad, or inconsistent with nearby code
 - Prefer precise exception types such as `ArgumentException` or `InvalidOperationException`
 - Match nullable behavior to the project: do not suppress nullable warnings with `!` unless the invariant is explicit and local
 - Do not catch or throw base `Exception` unless the surrounding codebase has a specific, justified pattern
@@ -72,6 +74,7 @@ Follow the project's established naming, formatting, visibility, dependency inje
 - In library/helper code, use `ConfigureAwait(false)` when consistent with the codebase
 - Stream large payloads instead of materializing them all at once
 - Dispose owned synchronous and asynchronous resources with `using` or `await using`
+- Do not dispose caller-owned streams or services; when wrapping a stream you do not own, preserve ownership with APIs such as `leaveOpen: true` when available
 
 ### Step 6: Make production concerns explicit
 
diff --git a/tests/dotnet/csharp-development/eval.vally.yaml b/tests/dotnet/csharp-development/eval.vally.yaml
index 59b0bfb818..c9acbdda06 100644
--- a/tests/dotnet/csharp-development/eval.vally.yaml
+++ b/tests/dotnet/csharp-development/eval.vally.yaml
@@ -4,51 +4,49 @@ type: capability
 config:
   timeout: 5m
 stimuli:
-  - name: General C# refactoring guidance
-    prompt: I need to refactor a C# service method in an existing project. Give concise guidance for keeping the change clean, maintainable, async-safe, and consistent with nearby .NET conventions.
-    graders:
-      - type: output-matches
-        config:
-          pattern: nearby|existing|convention|async|CancellationToken|exception|public API|abstraction
-      - type: prompt
-      - type: pairwise
+  - name: "Production code review"
+    prompt: |
+      Assess this method and suggest a focused fix without
+      changing project settings or adding new abstractions:
+      `public async void Import(Stream stream, string? name) { using var reader =
+      new StreamReader(stream); try { var text = reader.ReadToEndAsync().Result;
+      if (name == null) return; _cache.Save(name, text); } catch (Exception) { } }`
+    assertions:
+      - type: output_matches
+        pattern: "(async void|StreamReader|leaveOpen|sync-over-async|exception|nullable|project settings)"
+      - type: exit_success
     rubric:
-      - Preserves local project conventions before recommending generic patterns
-      - Covers async/cancellation and precise error handling where relevant
-      - Avoids unnecessary abstractions or broad project-setting changes
-  - name: Small feature implementation
-    prompt: Provide code for an existing C# project: add an async method that loads customer records from a stream, skips blank lines, supports cancellation, and returns parsed records. Do not create or change project files or settings.
-    graders:
-      - type: output-matches
-        config:
-          pattern: async|CancellationToken|ReadLineAsync|blank lines|project files|settings|record
-      - type: prompt
-      - type: pairwise
+      - "Replaces fire-and-forget or sync-over-async with awaitable async flow"
+      - "Preserves caller-owned stream lifetime when wrapping it for text reading"
+      - "Uses explicit validation or precise error handling instead of returning silently or swallowing broad exceptions"
+      - "Avoids project-setting changes and unrelated abstractions"
+    timeout: 120
+- name: "Small feature implementation"
+    prompt: |
+      Provide code for an existing C# project: add an async method that loads customer
+      records from a stream, skips blank lines, supports cancellation, and
+      returns parsed records. Do not create or change project files or settings.
+    assertions:
+      - type: output_matches
+        pattern: "(async|CancellationToken|ReadLineAsync|blank lines|project files|settings|record)"
+      - type: exit_success
     rubric:
-      - Provides a focused C# implementation for the requested feature
-      - Supports cancellation and async I/O without sync-over-async
-      - Skips blank lines and avoids changing TFM, SDK, LangVersion, or other project settings
-  - name: Nullable validation and error handling
-    prompt: Review this C# API shape and explain how you would implement validation without hiding nullable warnings: `public Customer Create(string? id, string? displayName)`. Keep the public API minimal and use precise exceptions.
-    graders:
-      - type: output-matches
-        config:
-          pattern: ArgumentNullException|ArgumentException|string.IsNullOrWhiteSpace|null|nullable|public API
-      - type: prompt
-      - type: pairwise
+      - "Provides a focused C# implementation for the requested feature"
+      - "Supports cancellation and async I/O without sync-over-async"
+      - "Skips blank lines and avoids changing TFM, SDK, LangVersion, or other project settings"
+    timeout: 120
+
+      - name: "Nullable validation and error handling"
+    prompt: |
+      Review this C# API shape and implement validation
+      without hiding nullable warnings: `public Customer Create(string? id,
+      string? displayName)`. Keep the public API minimal and use precise exceptions.
+    assertions:
+      - type: output_matches
+        pattern: "(ArgumentNullException|ArgumentException|string\\.IsNullOrWhiteSpace|null|nullable|public API)"
+      - type: exit_success
     rubric:
-      - Distinguishes null validation from empty or whitespace validation
-      - Avoids nullable suppression as the primary solution
-      - Keeps public surface area minimal and exceptions precise
-  - name: Constraint-respecting review
-    prompt: A teammate suggests changing LangVersion and the target framework so a small helper can use newer C# syntax. Review that suggestion for an existing library where project settings should stay stable.
-    graders:
-      - type: output-matches
-        config:
-          pattern: LangVersion|target framework|project settings|existing|syntax|stable
-      - type: prompt
-      - type: pairwise
-    rubric:
-      - Rejects unnecessary project-setting changes for a small helper
-      - Recommends syntax compatible with the existing project context
-      - Balances maintainability with minimal, focused changes
+      - "Distinguishes null validation from empty or whitespace validation"
+      - "Avoids nullable suppression as the primary solution"
+      - "Keeps public surface area minimal and exceptions precise"
+    timeout: 120
diff --git a/tests/dotnet/csharp-development/eval.yaml b/tests/dotnet/csharp-development/eval.yaml
index 09822ac6c2..a56f7fc2d7 100644
--- a/tests/dotnet/csharp-development/eval.yaml
+++ b/tests/dotnet/csharp-development/eval.yaml
@@ -1,21 +1,22 @@
 scenarios:
-  - name: "General C# refactoring guidance"
+  - name: "Production code review"
     prompt: |
-      I need to refactor a C# service method in an existing project. Give concise
-      guidance for keeping the
-      change clean, maintainable, async-safe, and consistent with existing
-      .NET conventions.
+      Assess this method and suggest a focused fix without
+      changing project settings or adding new abstractions:
+      `public async void Import(Stream stream, string? name) { using var reader =
+      new StreamReader(stream); try { var text = reader.ReadToEndAsync().Result;
+      if (name == null) return; _cache.Save(name, text); } catch (Exception) { } }`
     assertions:
       - type: output_matches
-        pattern: "(nearby|existing|convention|async|CancellationToken|exception|public API|abstraction)"
+        pattern: "(async void|StreamReader|leaveOpen|sync-over-async|exception|nullable|project settings)"
       - type: exit_success
     rubric:
-      - "Preserves local project conventions before recommending generic patterns"
-      - "Covers async/cancellation and precise error handling where relevant"
-      - "Avoids unnecessary abstractions or broad project-setting changes"
+      - "Replaces fire-and-forget or sync-over-async with awaitable async flow"
+      - "Preserves caller-owned stream lifetime when wrapping it for text reading"
+      - "Uses explicit validation or precise error handling instead of returning silently or swallowing broad exceptions"
+      - "Avoids project-setting changes and unrelated abstractions"
     timeout: 120
-
-  - name: "Small feature implementation"
+- name: "Small feature implementation"
     prompt: |
       Provide code for an existing C# project: add an async method that loads customer
       records from a stream, skips blank lines, supports cancellation, and
@@ -30,9 +31,9 @@ scenarios:
       - "Skips blank lines and avoids changing TFM, SDK, LangVersion, or other project settings"
     timeout: 120
 
-  - name: "Nullable validation and error handling"
+      - name: "Nullable validation and error handling"
     prompt: |
-      Review this C# API shape and explain how you would implement validation
+      Review this C# API shape and implement validation
       without hiding nullable warnings: `public Customer Create(string? id,
       string? displayName)`. Keep the public API minimal and use precise exceptions.
     assertions:
@@ -44,18 +45,3 @@ scenarios:
       - "Avoids nullable suppression as the primary solution"
       - "Keeps public surface area minimal and exceptions precise"
     timeout: 120
-
-  - name: "Constraint-respecting review"
-    prompt: |
-      A teammate suggests changing LangVersion and the target framework so a
-      small helper can use newer C# syntax. Review that suggestion for an
-      existing library where project settings should stay stable.
-    assertions:
-      - type: output_matches
-        pattern: "(LangVersion|target framework|project settings|existing|syntax|stable)"
-      - type: exit_success
-    rubric:
-      - "Rejects unnecessary project-setting changes for a small helper"
-      - "Recommends syntax compatible with the existing project context"
-      - "Balances maintainability with minimal, focused changes"
-    timeout: 120

From 38514e0012f9211f2f3732ed789041f624c58997 Mon Sep 17 00:00:00 2001
From: "Wendy Breiding (She/Her)" <webreidi@microsoft.com>
Date: Thu, 11 Jun 2026 10:06:13 -0700
Subject: [PATCH 03/11] Refactor production code review scenarios to improve
 clarity and focus on async error handling

---
 .../dotnet/csharp-development/eval.vally.yaml | 44 ++++---------------
 tests/dotnet/csharp-development/eval.yaml     | 44 ++++---------------
 2 files changed, 16 insertions(+), 72 deletions(-)

diff --git a/tests/dotnet/csharp-development/eval.vally.yaml b/tests/dotnet/csharp-development/eval.vally.yaml
index c9acbdda06..7fd58c046a 100644
--- a/tests/dotnet/csharp-development/eval.vally.yaml
+++ b/tests/dotnet/csharp-development/eval.vally.yaml
@@ -6,47 +6,19 @@ config:
 stimuli:
   - name: "Production code review"
     prompt: |
-      Assess this method and suggest a focused fix without
-      changing project settings or adding new abstractions:
+      A caller passes a stream into this method, then tries to read from the same
+      stream afterward and gets an ObjectDisposedException. Review the method for
+      that bug plus any async/error-handling problems, and suggest a focused fix:
       `public async void Import(Stream stream, string? name) { using var reader =
       new StreamReader(stream); try { var text = reader.ReadToEndAsync().Result;
       if (name == null) return; _cache.Save(name, text); } catch (Exception) { } }`
     assertions:
       - type: output_matches
-        pattern: "(async void|StreamReader|leaveOpen|sync-over-async|exception|nullable|project settings)"
+        pattern: "(async void|StreamReader|ObjectDisposedException|ReadToEndAsync|exception|Task)"
       - type: exit_success
     rubric:
-      - "Replaces fire-and-forget or sync-over-async with awaitable async flow"
-      - "Preserves caller-owned stream lifetime when wrapping it for text reading"
-      - "Uses explicit validation or precise error handling instead of returning silently or swallowing broad exceptions"
-      - "Avoids project-setting changes and unrelated abstractions"
-    timeout: 120
-- name: "Small feature implementation"
-    prompt: |
-      Provide code for an existing C# project: add an async method that loads customer
-      records from a stream, skips blank lines, supports cancellation, and
-      returns parsed records. Do not create or change project files or settings.
-    assertions:
-      - type: output_matches
-        pattern: "(async|CancellationToken|ReadLineAsync|blank lines|project files|settings|record)"
-      - type: exit_success
-    rubric:
-      - "Provides a focused C# implementation for the requested feature"
-      - "Supports cancellation and async I/O without sync-over-async"
-      - "Skips blank lines and avoids changing TFM, SDK, LangVersion, or other project settings"
-    timeout: 120
-
-      - name: "Nullable validation and error handling"
-    prompt: |
-      Review this C# API shape and implement validation
-      without hiding nullable warnings: `public Customer Create(string? id,
-      string? displayName)`. Keep the public API minimal and use precise exceptions.
-    assertions:
-      - type: output_matches
-        pattern: "(ArgumentNullException|ArgumentException|string\\.IsNullOrWhiteSpace|null|nullable|public API)"
-      - type: exit_success
-    rubric:
-      - "Distinguishes null validation from empty or whitespace validation"
-      - "Avoids nullable suppression as the primary solution"
-      - "Keeps public surface area minimal and exceptions precise"
+      - "Returns an awaitable method and avoids blocking on asynchronous work"
+      - "Keeps the supplied stream usable after the import completes"
+      - "Reports invalid input or failures explicitly instead of silently doing nothing"
+      - "Keeps the fix local and proportionate to the method"
     timeout: 120
diff --git a/tests/dotnet/csharp-development/eval.yaml b/tests/dotnet/csharp-development/eval.yaml
index a56f7fc2d7..ac667029a4 100644
--- a/tests/dotnet/csharp-development/eval.yaml
+++ b/tests/dotnet/csharp-development/eval.yaml
@@ -1,47 +1,19 @@
 scenarios:
   - name: "Production code review"
     prompt: |
-      Assess this method and suggest a focused fix without
-      changing project settings or adding new abstractions:
+      A caller passes a stream into this method, then tries to read from the same
+      stream afterward and gets an ObjectDisposedException. Review the method for
+      that bug plus any async/error-handling problems, and suggest a focused fix:
       `public async void Import(Stream stream, string? name) { using var reader =
       new StreamReader(stream); try { var text = reader.ReadToEndAsync().Result;
       if (name == null) return; _cache.Save(name, text); } catch (Exception) { } }`
     assertions:
       - type: output_matches
-        pattern: "(async void|StreamReader|leaveOpen|sync-over-async|exception|nullable|project settings)"
+        pattern: "(async void|StreamReader|ObjectDisposedException|ReadToEndAsync|exception|Task)"
       - type: exit_success
     rubric:
-      - "Replaces fire-and-forget or sync-over-async with awaitable async flow"
-      - "Preserves caller-owned stream lifetime when wrapping it for text reading"
-      - "Uses explicit validation or precise error handling instead of returning silently or swallowing broad exceptions"
-      - "Avoids project-setting changes and unrelated abstractions"
-    timeout: 120
-- name: "Small feature implementation"
-    prompt: |
-      Provide code for an existing C# project: add an async method that loads customer
-      records from a stream, skips blank lines, supports cancellation, and
-      returns parsed records. Do not create or change project files or settings.
-    assertions:
-      - type: output_matches
-        pattern: "(async|CancellationToken|ReadLineAsync|blank lines|project files|settings|record)"
-      - type: exit_success
-    rubric:
-      - "Provides a focused C# implementation for the requested feature"
-      - "Supports cancellation and async I/O without sync-over-async"
-      - "Skips blank lines and avoids changing TFM, SDK, LangVersion, or other project settings"
-    timeout: 120
-
-      - name: "Nullable validation and error handling"
-    prompt: |
-      Review this C# API shape and implement validation
-      without hiding nullable warnings: `public Customer Create(string? id,
-      string? displayName)`. Keep the public API minimal and use precise exceptions.
-    assertions:
-      - type: output_matches
-        pattern: "(ArgumentNullException|ArgumentException|string\\.IsNullOrWhiteSpace|null|nullable|public API)"
-      - type: exit_success
-    rubric:
-      - "Distinguishes null validation from empty or whitespace validation"
-      - "Avoids nullable suppression as the primary solution"
-      - "Keeps public surface area minimal and exceptions precise"
+      - "Returns an awaitable method and avoids blocking on asynchronous work"
+      - "Keeps the supplied stream usable after the import completes"
+      - "Reports invalid input or failures explicitly instead of silently doing nothing"
+      - "Keeps the fix local and proportionate to the method"
     timeout: 120

From aa1297bac71f384f782b040932dec00cb8df8be3 Mon Sep 17 00:00:00 2001
From: "Wendy Breiding (She/Her)" <webreidi@microsoft.com>
Date: Thu, 18 Jun 2026 09:22:09 -0700
Subject: [PATCH 04/11] Update CODEOWNERS to reflect current ownership and
 streamline reviewer assignments

---
 .github/CODEOWNERS | 40 ++++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 255caa02ff..35dfcaff6c 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,5 +1,5 @@
 # Default owners for everything in the repo
-* @timheuer @dbreshears
+* @webreidi @AbhitejJohn
 
 # Engineering and CI/CD
 /eng/ @ViktorHofer @JanKrivanek
@@ -26,34 +26,34 @@
 
 /plugins/dotnet/agents/optimizing-dotnet-performance.agent.md @dotnet/appmodel
 
-/plugins/dotnet-ai/skills/mcp-csharp-create/ @leslierichardson95 @mikekistler
-/tests/dotnet-ai/mcp-csharp-create/ @leslierichardson95 @mikekistler
+/plugins/dotnet-ai/skills/mcp-csharp-create/ @leslierichardson95 
+/tests/dotnet-ai/mcp-csharp-create/ @leslierichardson95
 
-/plugins/dotnet-ai/skills/mcp-csharp-debug/ @leslierichardson95 @mikekistler
-/tests/dotnet-ai/mcp-csharp-debug/ @leslierichardson95 @mikekistler
+/plugins/dotnet-ai/skills/mcp-csharp-debug/ @leslierichardson95
+/tests/dotnet-ai/mcp-csharp-debug/ @leslierichardson95
 
-/plugins/dotnet-ai/skills/mcp-csharp-publish/ @leslierichardson95 @mikekistler
-/tests/dotnet-ai/mcp-csharp-publish/ @leslierichardson95 @mikekistler
+/plugins/dotnet-ai/skills/mcp-csharp-publish/ @leslierichardson95
+/tests/dotnet-ai/mcp-csharp-publish/ @leslierichardson95
 
-/plugins/dotnet-ai/skills/mcp-csharp-test/ @leslierichardson95 @mikekistler
-/tests/dotnet-ai/mcp-csharp-test/ @leslierichardson95 @mikekistler
+/plugins/dotnet-ai/skills/mcp-csharp-test/ @leslierichardson95
+/tests/dotnet-ai/mcp-csharp-test/ @leslierichardson95
 
 # dotnet-upgrade (migrating and upgrading .NET projects)
 /plugins/dotnet-upgrade/skills/thread-abort-migration/ @dotnet/appmodel @dotnet/skills-upgrade-reviewers
 /tests/dotnet-upgrade/thread-abort-migration/ @dotnet/appmodel @dotnet/skills-upgrade-reviewers
 
-/plugins/dotnet-upgrade/skills/migrate-nullable-references/ @danmoseley @agocke @dotnet/skills-upgrade-reviewers
-/tests/dotnet-upgrade/migrate-nullable-references/ @danmoseley @agocke @dotnet/skills-upgrade-reviewers
+/plugins/dotnet-upgrade/skills/migrate-nullable-references/ @agocke @dotnet/skills-upgrade-reviewers
+/tests/dotnet-upgrade/migrate-nullable-references/ @agocke @dotnet/skills-upgrade-reviewers
 
 /plugins/dotnet-upgrade/skills/dotnet-aot-compat/ @agocke @dotnet/appmodel @dotnet/skills-upgrade-reviewers
 /tests/dotnet-upgrade/dotnet-aot-compat/ @agocke @dotnet/appmodel @dotnet/skills-upgrade-reviewers
 
-/plugins/dotnet-upgrade/skills/migrate-dotnet9-to-dotnet10/ @danmoseley @dotnet/compat
-/tests/dotnet-upgrade/migrate-dotnet9-to-dotnet10/ @danmoseley @dotnet/compat
-/plugins/dotnet-upgrade/skills/migrate-dotnet10-to-dotnet11/ @danmoseley @dotnet/compat
-/tests/dotnet-upgrade/migrate-dotnet10-to-dotnet11/ @danmoseley @dotnet/compat
-/plugins/dotnet-upgrade/skills/migrate-dotnet8-to-dotnet9/ @danmoseley @dotnet/compat
-/tests/dotnet-upgrade/migrate-dotnet8-to-dotnet9/ @danmoseley @dotnet/compat
+/plugins/dotnet-upgrade/skills/migrate-dotnet9-to-dotnet10/ @dotnet/compat
+/tests/dotnet-upgrade/migrate-dotnet9-to-dotnet10/ @dotnet/compat
+/plugins/dotnet-upgrade/skills/migrate-dotnet10-to-dotnet11/ @dotnet/compat
+/tests/dotnet-upgrade/migrate-dotnet10-to-dotnet11/ @dotnet/compat
+/plugins/dotnet-upgrade/skills/migrate-dotnet8-to-dotnet9/ @dotnet/compat
+/tests/dotnet-upgrade/migrate-dotnet8-to-dotnet9/ @dotnet/compat
 
 # dotnet-diag (perf investigations, debugging, incident analysis)
 /plugins/dotnet-diag/skills/analyzing-dotnet-performance/ @dotnet/dotnet-diag @dotnet/skills-diag-reviewers
@@ -101,7 +101,7 @@
 /tests/dotnet-test/ @dotnet/dotnet-testing
 
 # dotnet-experimental (skills under active evaluation)
-/plugins/dotnet-experimental/plugin.json @JanKrivanek @ViktorHofer @Evangelink @ManishJayaswal @AbhitejJohn
+/plugins/dotnet-experimental/plugin.json @JanKrivanek @ViktorHofer @Evangelink @AbhitejJohn
 
 # dotnet-experimental-tests (everything experimental test related)
 
@@ -145,5 +145,5 @@
 /plugins/dotnet11/ @ManishJayaswal @JanKrivanek @ViktorHofer
 /tests/dotnet11/ @ManishJayaswal @JanKrivanek @ViktorHofer
 
-/plugins/dotnet11/skills/system-text-json-net11/ @ManishJayaswal @JanKrivanek @ViktorHofer
-/tests/dotnet11/system-text-json-net11/ @ManishJayaswal @JanKrivanek @ViktorHofer
+/plugins/dotnet11/skills/system-text-json-net11/ @JanKrivanek @ViktorHofer
+/tests/dotnet11/system-text-json-net11/ @JanKrivanek @ViktorHofer

From 86912fb59dfb023cc36b8e56472278a4a44e815c Mon Sep 17 00:00:00 2001
From: "Wendy Breiding (She/Her)" <webreidi@microsoft.com>
Date: Thu, 18 Jun 2026 09:26:16 -0700
Subject: [PATCH 05/11] Remove csharp-development skill documentation and
 evaluation tests

---
 .../dotnet/skills/csharp-development/SKILL.md | 122 ------------------
 .../dotnet/csharp-development/eval.vally.yaml |  24 ----
 tests/dotnet/csharp-development/eval.yaml     |  19 ---
 3 files changed, 165 deletions(-)
 delete mode 100644 plugins/dotnet/skills/csharp-development/SKILL.md
 delete mode 100644 tests/dotnet/csharp-development/eval.vally.yaml
 delete mode 100644 tests/dotnet/csharp-development/eval.yaml

diff --git a/plugins/dotnet/skills/csharp-development/SKILL.md b/plugins/dotnet/skills/csharp-development/SKILL.md
deleted file mode 100644
index 7195ebf76d..0000000000
--- a/plugins/dotnet/skills/csharp-development/SKILL.md
+++ /dev/null
@@ -1,122 +0,0 @@
----
-name: csharp-development
-description: "Use whenever writing C# code. Provides general C#/.NET guidance for clean, maintainable, secure, performant implementation, refactoring, async, error handling, project conventions, and high-level testing strategy."
-license: MIT
----
-
-# C# Development
-
-Help developers implement and improve C#/.NET code using project conventions first, then modern .NET practices. This skill covers general design, implementation, refactoring, async, error handling, security, performance, and high-level testing guidance without prescribing a specific test framework.
-
-## When to Use
-
-- The user asks for general C# or .NET implementation help
-- The user wants to design, refactor, or review everyday C# code
-- The user needs guidance on async, dependency injection, error handling, or API shape
-- The user wants production-ready C# guidance for security, resilience, logging, or performance
-- The user asks how to test new or changed C# behavior at a high level
-
-## When Not to Use
-
-- The user needs file-based C# apps without a project; use `csharp-scripts`
-- The user is calling native C/C++ from .NET; use `dotnet-pinvoke`
-- The user is setting up NuGet trusted publishing; use `nuget-trusted-publishing`
-- The user needs framework-specific test syntax, test migration, filtering, or runner commands; use the relevant `dotnet-test` skill
-- The user is working in ASP.NET Core, Blazor, MAUI, EF Core, diagnostics, or upgrade scenarios with a more specific plugin skill available
-
-## Inputs
-
-| Input | Required | Description |
-|-------|----------|-------------|
-| Task or code context | Yes | The code, behavior, bug, design, or refactoring goal |
-| Project files | Recommended | `.csproj`, `.sln`, `global.json`, `Directory.Build.*`, or package configuration when relevant |
-| Existing conventions | Recommended | Nearby code, naming, visibility, nullable, logging, and test patterns to preserve |
-| Target runtime | No | Target framework, C# language version, platforms, and deployment constraints |
-
-## Workflow
-
-### Step 1: Inspect the project context
-
-Check the target framework, C# version, nullable settings, SDK selection, package management, and repo conventions before proposing changes. Inspect nearby code or supplied project files when they are available; when they are not, state the assumption and keep the answer compact instead of doing broad repository exploration. Do not change TFM, SDK, `LangVersion`, package versions, or project structure unless the user asked for that change or it is necessary for correctness.
-
-### Step 2: Preserve local conventions
-
-Follow the project's established naming, formatting, visibility, dependency injection, logging, nullable annotations, exception, and error-handling patterns. Prefer small, focused diffs and reuse existing helpers, extension methods, and validation utilities before adding new abstractions.
-
-### Step 3: Design the code
-
-- Keep public surface area minimal; prefer `private`, then `internal`, then `protected`, then `public`
-- Add interfaces or abstractions only when they represent external dependencies, stable seams, or testability needs
-- Avoid wrapping an abstraction in another abstraction unless it adds clear value
-- Keep responsibilities focused and apply SOLID principles pragmatically
-- Do not edit generated code such as `*.g.cs`, files under generated API folders, or files marked `<auto-generated>`
-- For isolated implementation requests without an existing project, provide code that can be added to the existing project; do not create or change project files just to make a snippet compile
-- Use comments to explain why something is non-obvious, not what straightforward code does
-
-### Step 4: Implement robust behavior
-
-- Use modern C# features when the target framework and language version already support them
-- Use `ArgumentNullException.ThrowIfNull` for null guards and `string.IsNullOrWhiteSpace` for meaningful string validation
-- When exception precision matters, keep null validation separate from empty or whitespace validation instead of collapsing distinct failures into one broader guard
-- When reviewing or refactoring code that accepts external input, explicitly check whether existing validation is missing, overly broad, or inconsistent with nearby code
-- Prefer precise exception types such as `ArgumentException` or `InvalidOperationException`
-- Match nullable behavior to the project: do not suppress nullable warnings with `!` unless the invariant is explicit and local
-- Do not catch or throw base `Exception` unless the surrounding codebase has a specific, justified pattern
-- Do not swallow errors; log with useful context or let exceptions propagate
-- Keep async flows async end-to-end and avoid sync-over-async
-
-### Step 5: Handle async and I/O carefully
-
-- Name async methods with an `Async` suffix
-- Always await work unless returning the task directly is clearer
-- Pass `CancellationToken` through public async flows and long-running loops
-- Use cancelable delays and timeouts that cancel pending work
-- In library/helper code, use `ConfigureAwait(false)` when consistent with the codebase
-- Stream large payloads instead of materializing them all at once
-- Dispose owned synchronous and asynchronous resources with `using` or `await using`
-- Do not dispose caller-owned streams or services; when wrapping a stream you do not own, preserve ownership with APIs such as `leaveOpen: true` when available
-
-### Step 6: Make production concerns explicit
-
-- Avoid secrets in code and logs
-- Validate external input and use least privilege for security-sensitive operations
-- Prefer structured logging with useful context and avoid noisy logs
-- Add timeouts and retry with backoff only when the operation is safe to retry
-- Keep code cross-platform unless the project is intentionally OS-specific
-- Optimize simple code only after identifying hot paths or clear allocation risks
-
-### Step 7: Provide high-level testing guidance
-
-- Identify the public behavior or observable outcome each test should protect
-- Use the test framework, fixtures, naming conventions, and assertion style already present in the repo
-- Test observable behavior through public APIs rather than implementation details
-- Keep each test focused on one behavior or outcome
-- Cover important edge cases, invalid inputs, cancellation, and failure paths
-- Prefer deterministic tests that can run in any order and in parallel
-- Avoid shared mutable state, timing-dependent waits, and unnecessary mocks
-- Use coverage as a gap-finding aid, not as the sole quality signal
-
-### Step 8: Validate the result
-
-Run the narrowest relevant build, test, formatter, or analyzer commands that already exist in the repo. Prefer scoped commands over full-repo validation when only one project or test file changed. Report the exact commands attempted and the exact blocker if validation cannot run because required SDKs or tools are unavailable; still perform static checks where possible.
-
-## Validation
-
-- [ ] The solution follows nearby C# and repo conventions
-- [ ] Public API changes are intentional and minimal
-- [ ] Error handling is precise and does not swallow failures
-- [ ] Async code passes cancellation through relevant boundaries
-- [ ] Security, logging, and performance tradeoffs are addressed when relevant
-- [ ] New or changed behavior has an appropriate high-level test plan or tests
-- [ ] Existing build, test, or analyzer commands were run when available, or the precise blocker was reported
-
-## Common Pitfalls
-
-| Pitfall | Solution |
-|---------|----------|
-| Adding abstractions by default | Add an interface or wrapper only when it creates a real seam or contract |
-| Changing project settings to enable preferred syntax | Use syntax supported by the existing TFM and language version |
-| Catching broad exceptions | Catch only specific exceptions you can handle, otherwise let them propagate |
-| Fire-and-forget async work | Await work or model background processing explicitly with cancellation and error reporting |
-| Testing private implementation details | Test public behavior and observable outcomes |
-| Introducing framework-specific test guidance | Keep test advice high level or route to a `dotnet-test` skill |
diff --git a/tests/dotnet/csharp-development/eval.vally.yaml b/tests/dotnet/csharp-development/eval.vally.yaml
deleted file mode 100644
index 7fd58c046a..0000000000
--- a/tests/dotnet/csharp-development/eval.vally.yaml
+++ /dev/null
@@ -1,24 +0,0 @@
-name: csharp-development
-description: Evaluates the dotnet/csharp-development skill
-type: capability
-config:
-  timeout: 5m
-stimuli:
-  - name: "Production code review"
-    prompt: |
-      A caller passes a stream into this method, then tries to read from the same
-      stream afterward and gets an ObjectDisposedException. Review the method for
-      that bug plus any async/error-handling problems, and suggest a focused fix:
-      `public async void Import(Stream stream, string? name) { using var reader =
-      new StreamReader(stream); try { var text = reader.ReadToEndAsync().Result;
-      if (name == null) return; _cache.Save(name, text); } catch (Exception) { } }`
-    assertions:
-      - type: output_matches
-        pattern: "(async void|StreamReader|ObjectDisposedException|ReadToEndAsync|exception|Task)"
-      - type: exit_success
-    rubric:
-      - "Returns an awaitable method and avoids blocking on asynchronous work"
-      - "Keeps the supplied stream usable after the import completes"
-      - "Reports invalid input or failures explicitly instead of silently doing nothing"
-      - "Keeps the fix local and proportionate to the method"
-    timeout: 120
diff --git a/tests/dotnet/csharp-development/eval.yaml b/tests/dotnet/csharp-development/eval.yaml
deleted file mode 100644
index ac667029a4..0000000000
--- a/tests/dotnet/csharp-development/eval.yaml
+++ /dev/null
@@ -1,19 +0,0 @@
-scenarios:
-  - name: "Production code review"
-    prompt: |
-      A caller passes a stream into this method, then tries to read from the same
-      stream afterward and gets an ObjectDisposedException. Review the method for
-      that bug plus any async/error-handling problems, and suggest a focused fix:
-      `public async void Import(Stream stream, string? name) { using var reader =
-      new StreamReader(stream); try { var text = reader.ReadToEndAsync().Result;
-      if (name == null) return; _cache.Save(name, text); } catch (Exception) { } }`
-    assertions:
-      - type: output_matches
-        pattern: "(async void|StreamReader|ObjectDisposedException|ReadToEndAsync|exception|Task)"
-      - type: exit_success
-    rubric:
-      - "Returns an awaitable method and avoids blocking on asynchronous work"
-      - "Keeps the supplied stream usable after the import completes"
-      - "Reports invalid input or failures explicitly instead of silently doing nothing"
-      - "Keeps the fix local and proportionate to the method"
-    timeout: 120

From de21bfbf1bb59bd30e5ecbf2289e9070ff52468f Mon Sep 17 00:00:00 2001
From: "Wendy Breiding (She/Her)" <webreidi@microsoft.com>
Date: Thu, 18 Jun 2026 09:27:57 -0700
Subject: [PATCH 06/11] Remove csharp-development skill from README

---
 plugins/dotnet/README.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/plugins/dotnet/README.md b/plugins/dotnet/README.md
index 81b71e3820..f0ca96307c 100644
--- a/plugins/dotnet/README.md
+++ b/plugins/dotnet/README.md
@@ -17,7 +17,6 @@ Prerequisites:
 
 ## Skills
 
-- csharp-development
 - csharp-scripts
 - dotnet-pinvoke
 - nuget-trusted-publishing

From 977c38661c0cf9c1b92ad38cce8e0ee5fd6e544c Mon Sep 17 00:00:00 2001
From: "Wendy Breiding (She/Her)" <webreidi@microsoft.com>
Date: Thu, 18 Jun 2026 09:29:40 -0700
Subject: [PATCH 07/11] Fix formatting in Constants.g.cs by adding missing
 semicolon

---
 tests/dotnet-msbuild/item-management/Constants.g.cs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/tests/dotnet-msbuild/item-management/Constants.g.cs b/tests/dotnet-msbuild/item-management/Constants.g.cs
index 30a49ae66d..91ef0d0cb4 100644
--- a/tests/dotnet-msbuild/item-management/Constants.g.cs
+++ b/tests/dotnet-msbuild/item-management/Constants.g.cs
@@ -1,2 +1 @@
-namespace ItemManagement { public static class Constants { public const int Version = 1
-} }
+namespace ItemManagement { public static class Constants { public const int Version = 1; } }
\ No newline at end of file

From 199bf89eb133a7706b01c020068919619863c55d Mon Sep 17 00:00:00 2001
From: "Wendy Breiding (She/Her)" <webreidi@microsoft.com>
Date: Thu, 18 Jun 2026 09:52:35 -0700
Subject: [PATCH 08/11] Revert Constants.g.cs to main

---
 tests/dotnet-msbuild/item-management/Constants.g.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/dotnet-msbuild/item-management/Constants.g.cs b/tests/dotnet-msbuild/item-management/Constants.g.cs
index 91ef0d0cb4..74e3137073 100644
--- a/tests/dotnet-msbuild/item-management/Constants.g.cs
+++ b/tests/dotnet-msbuild/item-management/Constants.g.cs
@@ -1 +1 @@
-namespace ItemManagement { public static class Constants { public const int Version = 1; } }
\ No newline at end of file
+namespace ItemManagement { public static class Constants { public const int Version = 1; } }

From 090349e3ca13a9ef537f91ad883773048cd2e871 Mon Sep 17 00:00:00 2001
From: "Wendy Breiding (She/Her)" <webreidi@microsoft.com>
Date: Thu, 18 Jun 2026 10:30:07 -0700
Subject: [PATCH 09/11] Remove csharp-development skill from CODEOWNERS

---
 .github/CODEOWNERS | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index fba34ca188..095c82f43d 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -10,9 +10,6 @@
 /tests/dotnet-msbuild/ @ViktorHofer @JanKrivanek @dotnet/skills-msbuild-reviewers
 
 # dotnet (common everyday C#/.NET)
-/plugins/dotnet/skills/csharp-development/ @dotnet/skills-csharp-language-reviewers
-/tests/dotnet/csharp-development/ @dotnet/skills-csharp-language-reviewers
-
 /plugins/dotnet/skills/csharp-scripts/ @dotnet/run-file @dotnet/skills-csharp-language-reviewers
 /tests/dotnet/csharp-scripts/ @dotnet/run-file @dotnet/skills-csharp-language-reviewers
 

From f216418e42764038f12cbf583f506cde9018765e Mon Sep 17 00:00:00 2001
From: Wendy Breiding <55603905+webreidi@users.noreply.github.com>
Date: Thu, 18 Jun 2026 10:30:35 -0700
Subject: [PATCH 10/11] Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
---
 .github/CODEOWNERS | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 095c82f43d..913f754f0c 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -23,7 +23,7 @@
 
 /plugins/dotnet/agents/optimizing-dotnet-performance.agent.md @dotnet/appmodel
 
-/plugins/dotnet-ai/skills/mcp-csharp-create/ @leslierichardson95 
+/plugins/dotnet-ai/skills/mcp-csharp-create/ @leslierichardson95
 /tests/dotnet-ai/mcp-csharp-create/ @leslierichardson95
 
 /plugins/dotnet-ai/skills/mcp-csharp-debug/ @leslierichardson95

From 243b5234a37b28fda7a1b2b2509d0038d43fd795 Mon Sep 17 00:00:00 2001
From: "Wendy Breiding (She/Her)" <webreidi@microsoft.com>
Date: Thu, 18 Jun 2026 10:40:43 -0700
Subject: [PATCH 11/11] Update CODEOWNERS to include additional reviewers for
 dotnet-ai skills

---
 .github/CODEOWNERS | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 095c82f43d..734c39bb20 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -23,17 +23,17 @@
 
 /plugins/dotnet/agents/optimizing-dotnet-performance.agent.md @dotnet/appmodel
 
-/plugins/dotnet-ai/skills/mcp-csharp-create/ @leslierichardson95 
-/tests/dotnet-ai/mcp-csharp-create/ @leslierichardson95
+/plugins/dotnet-ai/skills/mcp-csharp-create/ @leslierichardson95 @cathysull
+/tests/dotnet-ai/mcp-csharp-create/ @leslierichardson95 @cathysull
 
-/plugins/dotnet-ai/skills/mcp-csharp-debug/ @leslierichardson95
-/tests/dotnet-ai/mcp-csharp-debug/ @leslierichardson95
+/plugins/dotnet-ai/skills/mcp-csharp-debug/ @leslierichardson95 @cathysull
+/tests/dotnet-ai/mcp-csharp-debug/ @leslierichardson95 @cathysull
 
-/plugins/dotnet-ai/skills/mcp-csharp-publish/ @leslierichardson95
-/tests/dotnet-ai/mcp-csharp-publish/ @leslierichardson95
+/plugins/dotnet-ai/skills/mcp-csharp-publish/ @leslierichardson95 @cathysull
+/tests/dotnet-ai/mcp-csharp-publish/ @leslierichardson95 @cathysull
 
-/plugins/dotnet-ai/skills/mcp-csharp-test/ @leslierichardson95
-/tests/dotnet-ai/mcp-csharp-test/ @leslierichardson95
+/plugins/dotnet-ai/skills/mcp-csharp-test/ @leslierichardson95 @cathysull
+/tests/dotnet-ai/mcp-csharp-test/ @leslierichardson95 @cathysull
 
 # dotnet-upgrade (migrating and upgrading .NET projects)
 /plugins/dotnet-upgrade/skills/thread-abort-migration/ @dotnet/appmodel @dotnet/skills-upgrade-reviewers