EARLY ACCESS · NEW COURSE

.NET & Blazor with AI
Pilot, not passenger.

You will not write much code. You will decide what gets built, constrain how it gets built, and know whether what came back is right. A complete workflow for AI-assisted .NET, built from two live cohorts and ten live sessions with working developers.

Get early access - $149 $149 while it is unfinished · $249 when it is done See the full curriculum →

Early access: you get every module as it lands, plus the finished course

33 lectures live now 10 modules Deployed app MCP server Lifetime access
THE PROMISE

Construction got cheap.
Deciding and verifying did not.

Most AI content teaches you to prompt faster. This teaches you the harness: the constraints, structure, and review discipline that make AI-generated .NET code something you can actually ship and defend.

Direct the work

Constrain the architecture up front, ban the patterns you do not want, and delegate whole slices of work instead of accepting line-by-line autocomplete.

Verify what comes back

Read AI output like a pull request from a talented junior: fast, capable, occasionally confidently wrong, and never accountable. Catch invented packages and wrong turns early.

Ship it for real

Building got fast, deploying did not. Azure, a pipeline, migrations in production, and what you still own once strangers start using it.

WHY THIS DOES NOT AGE

The leverage moved from which model to how you drive it.

The frontier models have converged. Three experienced developers in the second cohort independently concluded they could drop to a weaker model and not feel the difference, as long as the harness was good. If that holds, and the benchmarks say it does, then the durable skill is not the model you pick. It is the constraints you put around it.

So this course is built around the harness. No model version numbers, no tool-specific tricks that break next quarter. Everything here still applies when the next release lands.

WHAT YOU BUILD

A real issue tracker. Then you let an agent use it.

One project, built across the whole course. Auth, roles, real data, real structure - then deployed, then given an MCP server so an agent can read a ticket, work it, and report back. That last part is not in any other .NET course.

Built properly

Blazor Web App on .NET 10, Identity, SQL Server, vertical slices, commands and queries, and a custom mediator in about forty lines. No paid packages.

Given an MCP server

The AI already knows your code. It does not know your data. You build the server that lets an agent query real issues, act on them, and stay inside boundaries you set.

With an AI feature inside

Not "how to use Claude" but how to put an LLM inside software you ship: structured output, streaming, and sane handling for timeouts, rate limits, refusals and garbage.

Course slide listing what you build: login and roles, issues and comments, labels and search, deployed to Azure
What the finished project does, by the end of the course.
Course slide showing one change touching nine files across four projects
One small change, nine files, four projects. This is the problem vertical slices solve.
VS Code showing the issue tracker project structure with Common Mediator and Features Diagnostics Ping folders
The real project in Module 3: slice folders, a hand-rolled mediator, and the commit history.
CURRICULUM

Four modules live now. Ten when it is done.

33 lectures, 2h 19m, ready the moment you buy. The remaining six modules land as they are recorded and cost you nothing extra. Sequential, because the project accumulates.

Welcome Live now
Welcome, and what you are going to build
2:38
How to follow along
1:59

You know what you are building, and how to follow along.

1 · How these things actually work, and what they cost Live now
What this course is, and what it is not
3:18
Tokens, in plain terms
2:40
The context window, and why it fills
2:58
What burns tokens without you noticing
2:37
Reading your own usage
9:08
The plateau, and why it changes your strategy
5:19
The one rule that saves the most money
2:37
Setting up the project
2:28
The first real prompt
5:47

You finish with an empty but running project, and a mental model of what you are spending.

2 · The harness Live now
What is actually happening in that chat window
7:42
Why unconstrained output is inconsistent
2:30
Generate it, do not write it
1:55
Prompting for the AGENTS.md
6:13
Reading what it wrote, line by line
12:06
The packages rule
2:03
What happens without it?
5:03
Moving to the terminal
2:37

You finish with a working AGENTS.md, and evidence that it changes the output.

3 · Structure so context is cheap Live now
Why vertical slices work unreasonably well with AI
2:33
Slices vs layers, honestly
2:20
Commands and queries
2:06
Into the terminal, and a custom mediator
10:59
Building the first slice: create an issue
9:01
The second slice, and a broken rule
7:49
Where slices break down
1:55

You finish able to create and list issues, with the pattern established.

4 · Working in sessions Live now
The real problem is drift, not memory
2:09
Breaking work into phases
1:40
Planning before implementing
2:14
The handover document
1:57
Plan, implement, hand over.
9:35
Resuming cold
2:09
Handovers as an architectural log
1:33

You finish able to stop mid-feature and pick it up cold without losing the thread.

5 · Delegation Coming
Autocomplete vs delegation
Goals: completion conditions
Loops: time-driven work
Combining them
Working remotely, the night shift
Skills: knowledge
Subagents: workers
Context economy
Building a review subagent

You finish delegating whole units of work instead of supervising every line.

6 · Review discipline Coming
Read it like a PR from a talented junior
Invented packages and imports
The self-validation trap
Wrong architectural turns
Off the beaten path
What to always check yourself
Tests as your verification layer

You finish able to catch the failure modes that actually cost you time.

7 · Shipping Coming
I never told it this would be on the internet
What changes when strangers arrive
Azure setup
GitHub Actions pipeline
Migrations in production
When the deploy fails
What you still own

You finish with the app live on Azure, deploying on push.

8 · Give your app an MCP server Coming
What MCP actually is
Why this is different
Deciding what to expose
Building the server
Connecting an agent to it
The payoff: agent reads a ticket and fixes it
Security and boundaries
Other things worth an MCP server

You finish with an agent that can read a ticket from your app and work it.

9 · Build an AI feature with the Claude API Coming
Calling an LLM from .NET
Keys, secrets and configuration
The feature: describe a bug, get a structured issue
Structured output
Streaming
When it fails
What it costs you per call
Swapping providers

You finish with an AI feature inside the product, not beside it.

10 · What stays human Coming
What actually got cheap
The bottleneck moved
Domain knowledge is the moat now
The things nobody prompts you for
Pilot, not passenger
Working sustainably
Where to go next

You finish knowing which parts of the job are still yours.

WHO IT'S FOR

Working .NET developers who already use AI, and want to trust the output.

  • You know C# and some Blazor, and you have shipped something before
  • You already use Copilot, Claude, or similar, and the results feel inconsistent
  • You want a repeatable workflow rather than prompts that worked once
  • You care what this costs you per month, and want to control it

Not for you if you are new to .NET, or you want a tour of one specific AI tool. This is tool-agnostic on purpose, and it assumes you can already read and judge C#. New to Blazor? Start with the free Blazor AI Jumpstart, then come back.

You will need: the .NET 10 SDK, VS Code or Visual Studio, and an AI coding tool of your choice.

Patrick God, founder of .NET Web Academy
YOUR INSTRUCTOR

Patrick God

.NET Developer · YouTuber · Founder of .NET Web Academy

15+ years building production .NET apps. 80,000+ developers on YouTube. This course is not theory: it is built from two paid live cohorts and ten live sessions with working developers, where the same problems came up again and again - cost, drift, review, and what to do when the agent is confidently wrong.

Everything here is what actually survived contact with real projects.

EARLY ACCESS

$149 while it is being finished.
$249 the day it is done.

Early access means you get modules as they land, you help shape what gets covered, and you keep the finished course. The early access price holds while the course is still being recorded and ends when the last module lands, expected mid-October. Finish sooner and it rises sooner, so the earlier you buy, the less you pay.

SAVE $100

THE COURSE

Yours for good

$249
$ 149
Early access price

One-time payment. $149 now, $249 once the course is complete.

  • Modules 1-4 available today - 33 lectures, 2h 19m
  • Modules 5-10 as they are recorded
  • All 10 modules when complete
  • The finished course when it lands
  • Full source code for the issue tracker
  • Lifetime access. Watch any time.
  • Shape what gets covered
Get early access - $149
BEST VALUE

Yearly All Access Pass

Best value • save 59%

$490 /year

$40.83/mo billed annually • 59% cheaper than monthly

Twice Monthly Live Sessions

Real time with Patrick. Join live or watch the replay

Private Community & Direct Answers

Members-only Discord with Patrick and other devs

Full Course Library

Every course and future releases FREE

All Live Workshops Included
Source Code on GitHub
Certificates of Completion
Cancel Anytime
Join & Save
This course is included in the All Access Pass, along with every other course and the live sessions.
RISK-FREE

30-day money-back guarantee

I'm sure you'll find this course incredibly valuable. But if it doesn't feel like the right fit, no problem. You're covered by a 30-day money-back guarantee. No questions asked.

30-Day Money-Back Guarantee

Frequently Asked Questions

What does early access actually mean?

You buy now at $149 and get modules as they are released, rather than waiting for the whole thing. You also keep the finished course at no extra cost, and you can tell me what you want covered while it is still being made. The early access price holds while the course is unfinished and ends when the last module lands, expected mid-October. If recording goes faster it rises sooner, so buying earlier is always the cheaper option.

What if you never finish it?

Fair question, and the honest answer is that you are trusting me a little. What I can point at: modules 1 to 4 are already recorded and watchable today, so you are not buying an empty promise, and the remaining six are outlined lecture by lecture in the curriculum above. Recording runs through the rest of September and into October. On top of that you have a 30-day money-back guarantee, so if the pace is not what you expected, email me and you get your money back, no questions asked.

Do I need a specific AI tool?

No. The course is tool-agnostic on purpose. The examples use current frontier models, but the whole point is the harness around the tool, not the tool itself. It works with Claude, Copilot, or whatever replaces them next year.

Will this go out of date when the next model ships?

That is exactly what it is designed to avoid. The models have converged, so the leverage has moved from which model you use to how you constrain it. Nothing in this course depends on a specific version number.

How is this different from the Blazor AI Workshop?

The workshop is a three-hour recorded live build of a shopping list app, in one sitting. This is a structured course, ten modules, a different project, and it goes far further: sessions and handovers, delegation, review discipline, deploying, an MCP server, and a real AI feature. They do not overlap.

Is it included in the All Access Pass?

Yes. Every course is included in the All Access Pass, and this one is no exception. If you are weighing the two, the Pass gets you this course plus every other course in the academy and twice-monthly live sessions.

Do I need to know Blazor already?

Basic C# and Blazor, yes. You do not need to be an expert, but this is not a beginner course and it assumes you can read and judge C#. If you are new to Blazor, start with the free Blazor AI Jumpstart first.

PILOT, NOT PASSENGER

The bottleneck moved.
It did not disappear.

Construction got cheap. Deciding what to build and knowing whether it is right did not. This is the workflow for staying the one who decides.

Get early access - $149 $249 once it is finished