This reality hits:
deadlines, new team members, rushed PRs, “we’ll fix it later.”
Most #dotnet projects don’t fall apart because of bad developers.
They fall apart because nobody decided how things should look when things get messy.
At the beginning:
✔ clean structure
✔ good intentions
✔ “we’ll keep it tidy”
Then reality hits:
• deadlines
• new team members
• rushed PRs
• “we’ll fix it later”
And suddenly the codebase starts fighting back.
This carousel shows the full curriculum of Pragmatic .NET Code Rules.
Not as a syllabus.
But as a system.
A system that:
- removes pointless decisions
- enforces consistency automatically
- keeps projects clean even when teams grow
I made this course for developers who:
• are tired of style debates
• want predictable projects
• care about long-term sanity, not quick wins
Already 50+ developers joined during pre-order.
And yes, you get access immediately.
And yes, you get access to the community.
You don’t wait.
You apply.
You improve your project while the course grows.
40% OFF Preorder price: $59.89
(Only 4 spots left at the price and only today)
Original price is $150.
👉 Get it now here:
https://t.co/xhEsynIezB
Curious, what’s the one rule your current codebase is missing?
FunctionInvokingChatClient in .NET allows up to 40 model round trips per request by default.
One confused agent, 40 paid calls for a single question.
Set MaximumIterationsPerRequest to what your flow actually needs.
Your API endpoint takes 5 minutes to respond. That's not an endpoint. That's a hostage situation. 😅
- The user stares at a spinner.
- Your server holds a thread for the whole time.
- A load balancer quietly kills the request after 60 seconds.
- The client retries, and now the same report is being built twice.
A faster endpoint won't save you here. A different shape will.
Here's the flow (follow the numbers on the visual):
1. Client sends POST /reports
2. API answers in ~20 ms with 202 Accepted + a Location header pointing to /reports/42
3. API drops the job into a queue - nothing heavy happens in the request
4. A background worker picks it up and does the 5-minute work
5. Client polls GET /reports/42 and gets "Running"
6. Client polls again and gets "Done" + the result URL
What you get:
→ Request threads are free in milliseconds, not minutes
→ No more proxy timeouts, because no request lives longer than a few ms
→ Workers scale independently of the web tier - 10 workers, 2 API instances, your call
→ Retries are safe, because the client asks for the status of job 42 instead of starting a new one
Two small details that make it production-ready:
→ Return a Retry-After header, so clients know how often to poll
→ Swap polling for SignalR or a webhook when you need push instead of pull
The mental shift: long-running work is a resource you create, not a response you wait for.
How do you handle long-running work in your APIs today - polling, webhooks or SignalR?
Join 25k+ engineers to learn more every week: https://t.co/mqkOvjdlIJ
@AntonMartyniuk Love the “once you have evals, swapping models is easy” point. In .NET it gets even easier: code against IChatClient, run your evals with Microsoft.Extensions .AI.Evaluation, and trying a cheaper model becomes a config change plus one test run.
Most teams that move to microservices don't have a scaling problem.
They have an organization problem, and they pick a distributed system to solve it.
Start with a modular monolith. Extract a module when it really needs to scale on its own.
@mjovanovictech Simple rule I’d start with: if the answer depends on who’s asking, it doesn’t go in a shared cache. Then start with a strict threshold, log the near-misses, and only loosen it once you’ve checked that those matches were actually correct.
If you save to the database and then publish a message as two separate steps, you will eventually lose a message.
That's what the Outbox pattern fixes: data and message in one transaction, a background worker publishes later.
An AI agent in .NET is a loop:
IChatClient sends the message + tools -> the model asks for a tool -> FunctionInvokingChatClient runs your C# method -> the result goes back -> repeat.
The model never touches your database. It only asks.
I tried to commit a file, and git said no.
An AI read my staged diff, found a hardcoded Stripe key, and blocked the commit (Headless agent).
~10 lines of PowerShell:
claude -p + --json-schema + a pre-commit hook. Fail closed.
Full video: https://t.co/71uZgzogay
#ClaudeCode #dotnet
I tried to commit a file, and git said no.
An AI read my staged diff, found a hardcoded Stripe key, and blocked the commit (Headless agent).
~10 lines of PowerShell:
claude -p + --json-schema + a pre-commit hook. Fail closed.
Full video: https://t.co/71uZgzogay
#ClaudeCode #dotnet
An AI agent in .NET is a loop:
IChatClient sends the message + tools -> the model asks for a tool -> FunctionInvokingChatClient runs your C# method -> the result goes back -> repeat.
The model never touches your database. It only asks.
@AntonMartyniuk The Miro MCP server is the bridge. Connect it to your AI tool (Claude Code / Cursor / Copilot) once, and the agent can read and write your boards directly
An AI reviewed my .NET pull request on a whiteboard and caught 3 real bugs hidden in a 60-file diff - before I hit merge.
Full walkthrough, every prompt: https://t.co/gtoQJxc4Uf
An AI reviewed my .NET pull request on a whiteboard and caught 3 real bugs hidden in a 60-file diff - before I hit merge.
Full walkthrough, every prompt: https://t.co/gtoQJxc4Uf
Before you blame the model, count how many times this week you typed "we don't use MediatR" to it.
That's not a model problem. That's a missing CLAUDE. md.
The biggest productivity gain I got from AI agents didn't come from a better model.
It came from writing our conventions down once, so I stopped re-explaining them every session.
A CLAUDE. md inside src/MyShop.Infrastructure/ only loads when the agent touches a file in that folder.
So your EF Core rules don't have to sit in context while it writes an endpoint.
Split instructions by where the code lives.