When you are done, use the #tool:show-notification tool to notify the user that you have completed the task.

Set `sound` to `true`
</notify>

<edit_file>
At the end of ANY conversation and changes to files are made turn with me where you create or edit a file for me:

1. Stage all changes
2. Commit the changes along with a short summary of the changes you made, and a bulleted list of the changes made by file.
</edit_file>

Copilot Instructions: .NET API Development

If I tell you that you are wrong, think about whether or not you think that's true and respond with facts.
Avoid apologizing or making conciliatory statements.
It is not necessary to agree with the user with statements such as "You're right" or "Yes".
Avoid hyperbole and excitement, stick to the task at hand and complete it pragmatically.

I. C# Style

Variables:
```
var
```
when type is clear.
Naming: Microsoft guidelines (PascalCase for types/members, camelCase for locals/params/fields, ALL_CAPS for consts), no
```
_
```
prefix for private fields.
Formatting: Allman braces, 4 spaces indent.
Nulls:
```
int?
```
for nullable value types, Microsoft standard operators (
```
?.
```
,
```
??
```
), explicit checks when needed.
Strings: Interpolation (
```
$"..."
```
).
LINQ: Fluent style, use extensively.
Async:
```
Async
```
suffix, follow Microsoft standards for
```
async
```
/
```
await
```
& error handling.
Immutability: Prefer immutable data structures where appropriate to enhance predictability and reduce side effects.

II. Code Structure

Nesting: Minimize via early returns & guard clauses (incl. inverted
```
if
```
).
Methods: Short, focused (Clean Code/Pragmatic Programmer). Low complexity.
Errors: Custom exceptions, log on catch (message, stack, context), handle in controllers.
Comments: XML for public, "why" for internal (minimal).

III. Solution/Project

Structure: Core, Application, Infrastructure (by tech: PostgreSQL, Redis, etc.), Presentation (API), Tests (
```
[ProjectName].Tests.Unit
```
,
```
[ProjectName].Tests.Integration
```
).
Splitting: Modular monolith (business features, Clean Architecture layers, future deployability, tech boundaries, testability, reuse).

IV. Testing

Unit: xUnit, Shouldly, Moq. Pragmatic TDD (value-driven, behavior focus). (Suggest
[MethodUnderTest]_[Scenario]_[ExpectedBehavior]
for method names,
[ClassUnderTest]UnitTests
for classes).
Integration: Pragmatic (critical integrations, contract focus, consider in-memory/test doubles).

V. Architecture

SOLID: Pragmatic balance (context-dependent, avoid over-abstraction).
Patterns: Apply known solutions (Repository, Service, DI common). Suggest relevant patterns based on context (readability, maintainability, etc.).

VI. Configuration

```
appsettings.json
```
(env-specific), env vars (overrides), User Secrets (dev-sensitive), cloud secrets (prod), custom providers (as needed).

VII. API & General

API: RESTful.
Auth: JWT.
DTOs/Mapping: Use AutoMapper for convention-based object mapping.
Analysis/Style: Enforce code style and quality using Roslyn Analyzers configured via
```
.editorconfig
```
.
Logging: Follow standard best practices for informational, warning, and error logs.
Performance: Aim for a pragmatic balance with readability, maintainability, and lower cognitive load.

Set `sound` to `true`
</notify>

<edit_file>
At the end of ANY conversation and changes to files are made turn with me where you create or edit a file for me:

1. Stage all changes
2. Commit the changes along with a short summary of the changes you made, and a bulleted list of the changes made by file.
</edit_file>

Copilot Instructions: .NET API Development

If I tell you that you are wrong, think about whether or not you think that's true and respond with facts.

Avoid apologizing or making conciliatory statements.

It is not necessary to agree with the user with statements such as "You're right" or "Yes".

Avoid hyperbole and excitement, stick to the task at hand and complete it pragmatically.

I. C# Style

Variables:

var

when type is clear.

Naming: Microsoft guidelines (PascalCase for types/members, camelCase for locals/params/fields, ALL_CAPS for consts), no

prefix for private fields.

Formatting: Allman braces, 4 spaces indent.

Nulls:

int?

for nullable value types, Microsoft standard operators (

?.

??

), explicit checks when needed.

Strings: Interpolation (

$"..."

LINQ: Fluent style, use extensively.

Async:

Async

suffix, follow Microsoft standards for

async

await

& error handling.

Immutability: Prefer immutable data structures where appropriate to enhance predictability and reduce side effects.

III. Solution/Project

Structure: Core, Application, Infrastructure (by tech: PostgreSQL, Redis, etc.), Presentation (API), Tests (

[ProjectName].Tests.Unit

[ProjectName].Tests.Integration

Splitting: Modular monolith (business features, Clean Architecture layers, future deployability, tech boundaries, testability, reuse).

VII. API & General

API: RESTful.

Auth: JWT.

DTOs/Mapping: Use AutoMapper for convention-based object mapping.

Analysis/Style: Enforce code style and quality using Roslyn Analyzers configured via

.editorconfig

Logging: Follow standard best practices for informational, warning, and error logs.

Performance: Aim for a pragmatic balance with readability, maintainability, and lower cognitive load.

<rules>

Copilot Instructions: .NET API Development

I. C# Style

II. Code Structure

III. Solution/Project

IV. Testing

V. Architecture

VI. Configuration

VII. API & General

Related Skills

Markdown Converter

Nano Banana Pro

1password

Copilot Instructions: .NET API Development

I. C# Style

II. Code Structure

III. Solution/Project

IV. Testing

V. Architecture

VI. Configuration

VII. API & General