Updated June 2026

AI-Assisted Development with C#

Class Duration

35 hours of live training delivered over 5 days.

Student Prerequisites

Professional C# and .NET development experience
Working knowledge of Git and GitHub (issues, pull requests, branches, reviews)
Comfort with the command line and the .NET CLI
No prior AI tool experience required

Target Audience

Professional C# developers who want a structured, end-to-end path from AI-curious to AI-proficient. Ideal for engineers and teams adopting AI coding tools across the full development lifecycle - writing, refactoring, testing, reviewing, and shipping .NET code - who also need to understand the security, licensing, and governance implications of doing so responsibly. This is a tool-agnostic course: each delivery is tailored to the AI tools your organization chooses - Claude Code, GitHub Copilot, Codex, Cursor, Windsurf, Gemini CLI, or others - and the skills transfer to whichever assistants your team adopts. Labs run in both Visual Studio and VS Code. For the language-agnostic version of this material, see AI-Assisted Software Engineering Fundamentals.

Description

The .NET ecosystem gives AI coding tools an unusually strong foundation to work against: a rich type system, Roslyn analyzers, and a mature test ecosystem provide fast, reliable feedback that agentic workflows thrive on. This five-day intensive teaches professional C# developers how to take full advantage, starting with how large language models generate code, setting up and configuring whichever tools your organization chooses in Visual Studio and VS Code, and prompting and context engineering techniques that produce idiomatic, nullable-aware, modern C# aligned with current .NET 10 APIs. Daily practice follows: disciplined inline assistance, chat-driven explain-refactor-generate workflows, grounding assistants in solution context with CLAUDE.md / AGENTS.md and rules files, and full agentic workflows where the agent builds, reads compiler and analyzer output, and runs tests. Day four applies AI to quality across the lifecycle: xUnit suites, integration testing ASP.NET Core, AI-assisted debugging, refactoring at scale, modernizing legacy .NET Framework code, and documentation. Day five addresses team-scale adoption: NuGet supply-chain risks, secret handling, licensing and IP questions, organizational policy, cost management, and rolling AI out with honest productivity measurement. This is a tool-agnostic course: each delivery is tailored to the AI tools your organization chooses (Claude Code, GitHub Copilot, Codex, Cursor, Windsurf, Gemini CLI, or others).

Learning Outcomes

Explain how LLMs generate code, choose the right frontier model for a given C# task, and set up and configure your chosen AI tools in Visual Studio and VS Code with sound privacy and data controls.
Apply prompting and context engineering techniques that produce idiomatic, nullable-aware, async-correct, modern C#.
Use inline completions and chat-driven explain, refactor, and generate workflows with discipline: well-scoped context, clean conversation hygiene, and review reflexes.
Ground assistants and agents in solution context with CLAUDE.md / AGENTS.md, rules files, MCP servers, and shared team prompt libraries, and use AI to read and understand unfamiliar .NET solutions.
Drive agentic coding sessions with your chosen coding agents, with dotnet build, analyzers, and tests in the loop, including issue-to-PR automation.
Generate, evaluate, and maintain xUnit and integration test suites with AI assistance, and turn exceptions, async stack traces, and production logs into root causes faster.
Refactor at scale and modernize legacy .NET Framework code to .NET 10 behind characterization tests, and generate documentation: XML doc comments, READMEs, and architecture decision records.
Recognize C#-specific AI failure modes (stale APIs, async anti-patterns, nullable violations), apply NuGet supply-chain and secret-handling guardrails, and contribute to team standards for cost, licensing, governance, rollout, and measuring real productivity impact.

Training Materials

Comprehensive courseware is distributed online at the start of class. All students receive a downloadable MP4 recording of the training.

Software Requirements

.NET 10 SDK, Visual Studio 2026 or VS Code with the C# Dev Kit, access to your organization's chosen AI coding tools (such as GitHub Copilot, Claude Code, Codex, Cursor, Windsurf, or Gemini CLI; trials and free tiers are acceptable), Git, and the GitHub CLI.

Training Topics

Foundations: How AI Writes Code

How LLMs generate code: tokens, context windows, and training data
The frontier models for coding: Claude, GPT, and Gemini compared
Capability tradeoffs: speed, cost, context size, and reasoning
Where AI excels in .NET work and where it reliably fails
Setting expectations: assistant, pair programmer, or junior engineer?

Setting Up and Configuring Your Chosen Tools

Accounts, seats, and enterprise policy: who gets access to what
Integration with Visual Studio 2026, VS Code, and the .NET CLI
Model selection and switching: defaults, tiers, and per-task choices
Privacy and data controls: retention, training opt-outs, and telemetry
.NET-aware configuration: SDK versions, solutions, and the C# Dev Kit
Verifying your setup: a smoke-test workflow before daily use

Prompting and Context Engineering for C#

Writing prompts that produce idiomatic, modern C# (.NET 10, C# 14)
Steering toward nullable reference types, records, and pattern matching
Async correctness: avoiding generated async void and sync-over-async
Context strategies: solutions, projects, and what to include from large codebases
Avoiding stale .NET Framework idioms in generated code

Everyday Inline Assistance

Completions as a dialogue: writing code that invites good suggestions
When to accept, when to reject: building review reflexes
Comment-driven and XML-doc-driven prompting for completions
Types as steering: signatures, generics, and nullable annotations
Avoiding autopilot: staying in command of code you sign

Chat-Driven Development

Explain, refactor, and generate: the core chat workflows
Scoping context: selections, files, and symbols - only what the question needs
Conversation hygiene: when to iterate and when to start fresh
From chat to edit: applying, reviewing, and adjusting suggested changes
Interrogating generated C#: nullability, async paths, and edge cases

IDE Assistants in Daily C# Work

Deep-dive on your chosen IDE assistants (GitHub Copilot in Visual Studio and VS Code, Cursor, Windsurf, or others): completions, chat, edits, and rules files
The wider landscape: Aider, Cline, JetBrains Junie, and Amazon Kiro
Multi-file edits and chat-driven refactoring across projects
XML doc comments and documentation generation
Customizing assistants with instructions files

Working with Project Context

CLAUDE.md and AGENTS.md in depth: what belongs, what doesn't
Rules and instructions files across tools: one convention, many formats
Encoding repo conventions: style, architecture, and testing norms
Team prompt libraries: capturing prompts that work and sharing them
Solution context: project layout, Directory.Build.props, and EditorConfig
Keeping context files current as the codebase evolves

AI-Assisted Code Reading and Comprehension

Onboarding to unfamiliar .NET solutions with AI guides
Generating explanations, call graphs, and architecture diagrams
Tracing dependency injection, middleware, and async flows
Summarizing projects, namespaces, and pull requests
Code archaeology: reconstructing intent from legacy code and history

Agentic Coding with Your Chosen Tools

The agentic loop: plan, act, observe, iterate
The agent landscape compared - Claude Code, Copilot agent mode, Codex, Cursor CLI, Windsurf Cascade, Gemini CLI - and how to choose
Plan mode and the supervision spectrum: permission prompts to auto mode
CLAUDE.md and AGENTS.md: solution layout, SDK, and convention context
The verify loop: agents reading dotnet build, analyzer, and test output
Issue-to-PR workflows: assigning work to cloud agents
MCP servers: connecting agents to internal tools and data

AI-Driven Testing in Depth

Generating xUnit suites: fixtures, theories, and coverage gaps
Integration testing ASP.NET Core with WebApplicationFactory and AI assistance
Mocking and test doubles: steering AI toward your team's approach
Designing for testability: letting AI surface seams and dependencies
Mutation-style review: testing the tests AI writes
Agentic code review and pull request automation
Maintaining suites over time: updating tests as code changes

AI-Assisted Debugging in Depth

Turning exceptions and async stack traces into hypotheses
Deadlocks, sync-over-async, and threading issues with AI help
Log analysis and structured logging for better AI diagnosis
Debugging across solutions: services, middleware, and configuration
Knowing when the AI is guessing: validating proposed fixes

Refactoring at Scale and Legacy Modernization

Multi-project refactors: planning, executing, and reviewing with agents
Characterization tests as the safety net before any change
Modernizing legacy .NET Framework code to .NET 10 incrementally
C#-specific refactors: nullable adoption, async adoption, records and pattern matching
Incremental modernization: strangler patterns over big rewrites
Keeping diffs reviewable: small steps over heroic changes

Documentation and Knowledge Work

XML doc comments that match project conventions
Public API documentation and DocFX workflows
READMEs, how-to guides, and onboarding docs from real code
Architecture decision records: drafting and maintaining ADRs with AI
Keeping documentation honest: reviewing generated prose for drift

C#-Specific Pitfalls and Verification

Hallucinated NuGet packages and API versions
Stale framework knowledge: verifying against current .NET docs
Nullable violations and analyzer warnings as quality gates
EditorConfig, Roslyn analyzers, and dotnet format for generated code
Performance review: allocations, LINQ overuse, and async overhead

Security, Licensing, and Governance

Prompt injection and untrusted content in agent workflows
Secret leakage: user secrets, appsettings, and context hygiene
NuGet supply-chain vetting and lockfile discipline
Licensing and IP status of AI-generated code
Organizational policy: approved tools, data boundaries, and audit trails
Review requirements: keeping humans accountable for shipped code

Measuring Impact, Cost, and Team Adoption

Tokens, model tiers, and budgets: managing cost without blunting value
Choosing the right model for the task: fast and cheap versus deep and slow
Re-evaluating the tool landscape: selection criteria, trials, and switching costs
Rollout patterns that work: champions, guilds, and paired onboarding
Metrics that matter - and vanity metrics that mislead
Adoption anti-patterns: mandates, leaderboards, and unreviewed merges