33 posts on .NET, SQL, architecture, and the craft of building software. (page 1 of 2)
A founder said that MCP will die within two years and that the CLI will replace it. He is right about composability. He is wrong about the deadline. I build both. This post shows where the terminal wins, where the protocol stays, and the question that settles the argument.
People present ReAct as a prompting trick. It is a design pattern. If you shipped function calling, you already use it, and you probably use it badly. This post shows the participants, a C# implementation, the trust boundary, and the consequences.
The last 20% of ChatBot is the part no demo shows: per-query caching, slow-query monitoring, conversation memory with a hard limit, fuzzy entity matching, and rate limiting. Here is how it became durable in production, and where I think it goes next with MCP.
The demo version of ChatBot would answer anything. The production version refuses, scopes, and logs. Here is the authorization model, the write-intent guard that fires before the LLM is called, and the unglamorous QA cycle that caught the over-answers before users saw them.
Block's thesis rests on one sentence they drop almost in passing: everything they do creates artifacts. That's not an organizational choice. It's an architecture choice, and most enterprises made the opposite one fifteen years ago.
A third of ChatBot's correctness does not live in C# at all. It lives in ten versioned prompt files. Here is how I structured them, why prompts belong in source control, and the single rule that killed an entire category of confident, wrong, dangerous answers.
ChatBot never sees the database. It calls the same Dapper services the rest of the app calls. Here is the function-calling pipeline that makes that work: the thin controller, the tool definitions, the executor, and the caching decorator. And why this architecture is a gift to enterprise .NET developers.
A trade show gave me a deadline. A live enterprise .NET billing system gave me the constraints. This is the start of a five-part series on building ChatBot, a natural-language assistant over real operational data, and what it actually takes to ship one into production.
On June 16, Microsoft's .NET Day on Agentic Modernization put a real-world WinForms line-of-business app on stage and modernized it live with Copilot, Aspire, and Foundry. It's almost exactly the system I've spent nine months converting. Here's the practitioner read: where the demo is right, and where it skips the parts that actually take the time.
Back in February I shipped a standalone 10-agent TypeScript tool that read legacy WinForms and emitted conversion metadata. I just pulled it out of the workflow. Here's the in-repo pipeline that replaced it: nine native Claude Code subagents, a slash-command orchestrator that fans them out in waves, and the conversion commands that turn their output into a spec.
Part 4 gave you the governance model on paper. This is what it actually became three months later: the real constitution, eighteen agents, the skill catalog, the rule sheets, and the SpecKit lifecycle wiring it all together. Names, versions, and code pulled straight from the repo.
Two hours of mechanical work catches months of confidently-wrong code generation. Here's the exact process I run on BargeOps to keep our AI memory file honest: the grep patterns, the PR template, the calendar cadence, and a worked example.
Narrate your architecture. Let SpecKit turn it into a spec, a plan, tasks, and working code. No keyboard. No lossy translation.
We had a workflow: end of every session, ask Claude to update the memory files with what we learned. It worked until we added UI specialists, dedicated agents, and more parallel sessions. All additive. None checking what the others had written. Here's the governance model that stopped it.
Claude was confidently generating deprecated code. We trusted the memory file. Here's what we found and why these bugs are invisible to code review.
A 564-line CLAUDE.md became a 23-line router. Eleven memory files became seven on-demand skills. Always-loaded context dropped 82%. The procedural knowledge didn't disappear. It grew. Here's the full arc.
I found 12 uneeded skill/plugins in my .NET development environment. Here's how they got there and exactly how to remove them.
You've been writing C# for years. Now every tool wants you to talk to an AI. Here's how to actually start, without throwing out everything you already know.
A developer's honest look at what happens when your brain can't stop prompting, even when you're cleaning out the garage on a Saturday.
The biggest first-mover opportunity in the .NET AI ecosystem, and almost nobody's taking it.