Coder Legion - Recent posts tagged microsoft

A System That Lets AI Work Directly With a Real Xbox

Sun, 27 Sep 2026 19:52:46 +0000

I wanted AI to work directly with a real Xbox.

Not just generate code on a PC.

I wanted the same software project to be created or adapted, sent to Xbox, executed there, observed, corrected, and then evolved again.

That system became XCP.

And now it is open source.

👉 GitHub: https://github.com/Daniele-Cangi/xcp-xbox
👉 XCP Studio: https://xcpstudio.com/

The simplest way to understand it is this:

AI / developer
      ↓
   project
      ↓
     XCP
      ↓
 Xbox Series
      ↓
 execute + observe
      ↓
   evidence
      ↓
 next version
      ↺

AI builds. Xbox executes. XCP observes. The project continues.

What it already looks like

This is not only infrastructure.

I wanted to see actual software cross that loop.

Forge

Forge — created through the XCP workflow and executed on Xbox.

The interesting part is not that AI can generate code.

The interesting part is that the project can continue after generation: it can be executed on a real target, observed, changed, versioned, and executed again.

Minilens

Minilens — an authorized Godot project adapted through XCP and executed through the Xbox lifecycle.

This tested a different path.

Instead of starting from a new idea, XCP had to begin with an existing software project, observe its structure and behaviour, adapt what could be represented on the target, execute it, and compare the result.

I deliberately do not call this universal Godot compatibility.

It demonstrates something narrower and more useful:

A real codebase can cross from source software to Xbox execution and come back with evidence about what actually happened.

The project survives the generation

This is the part of XCP I care about most.

A lot of AI-assisted development still behaves like this:

prompt
  ↓
generate
  ↓
files
  ↓
done

I wanted this instead:

create
  ↓
execute
  ↓
observe
  ↓
correct
  ↓
evolve
  ↓
execute again
  ↺

The same project has an identity.

Its versions have identities.

Executions belong to those versions.

Evidence belongs to particular executions.

A later change does not erase what existed before.

One lifecycle I exercised explicitly went:

1.0.0 → 1.1.0 → 1.0.0

Update and rollback are operations in the system, not an informal reconstruction of old files.

That is why I describe XCP as a software lifecycle for AI-assisted development, not simply an AI code generator.

What has already been exercised

Two paths were especially important:

Path	Result
New-project lifecycle	28 / 28 operations
Existing-source lifecycle with Minilens	14 / 14 operations
Declared semantic checks	passed for the published scenario
Version evolution	1.0.0 → 1.1.0 → 1.0.0

The creation path tested whether an agent could stay inside a project lifecycle beyond generation.

The Minilens path tested whether existing software could enter that same loop.

In both cases, the important boundary was the same:

the software had to reach a real Xbox execution target.

{% details Click to see more about the two paths %}

Creating new software

An agent can create an explicit XCP project, validate it, prepare it for the target, execute it, inspect the result, correct it and continue from another version.

The public creation programme completed 28 out of 28 lifecycle operations across an interactive project and a utility.

Adapting existing software

Existing software is harder because a project is more than its files.

It contains behaviour: input, state, collisions, scene transitions, timing, persistence and assumptions about the original engine.

The Minilens programme completed 14 out of 14 lifecycle operations together with the declared semantic acceptance checks for the published scenario.

That is why XCP treats adaptation closer to semantic reconstruction than file conversion.

{% enddetails %}

Xbox is actually inside the loop

Xbox is not just the screen at the end.

It is an execution target that produces information for the next development step.

Imagine an agent changes movement.

XCP can prepare the candidate, execute it on Xbox, observe what happened, and return structured evidence.

The next iteration can start from that evidence.

change
  ↓
Xbox execution
  ↓
evidence
  ↓
next decision

The AI itself does not run unrestricted on the console.

The agent remains on the development side.

Xbox exposes bounded execution surfaces, and XCP mediates what reaches the target and what comes back.

That separation is intentional.

The virtual machine that made this possible

The project actually started from a smaller experiment.

I wanted to know how much programmable execution I could create inside the public Xbox application environment.

That produced XVM, a deterministic virtual machine.

For XCP, XVM's most important property is simple:

New bounded work can reach the Xbox execution target without every new behaviour becoming another native Xbox application.

That turned Xbox from a fixed endpoint into a programmable part of the loop.

{% details Click to see what is inside XVM %}

The current XVM v2 reference implementation includes:

26 admitted opcodes
16 registers
typed memory
structured control flow
bounded loops and calls
static execution budgets
deterministic snapshot and resume
canonical CPU execution
GPU differential execution paths

The target still decides whether submitted work belongs to its admitted execution contract.

XVM does not remove the Xbox sandbox.

It creates a programmable layer inside it.

{% enddetails %}

“It ran” is not enough

Getting software to execute was only half of the problem.

A project can launch successfully and still be wrong.

Movement may work while collision behaviour changed.

A scene may appear correct while persistence is broken.

So XCP separates:

source behaviour
      ↓
semantic representation
      ↓
target implementation
      ↓
target observation
      ↓
evidence

This produced a rule that now sits at the centre of the project:

“It ran” is not the same claim as “it was preserved correctly.”

That difference is especially important when AI agents are involved.

Build succeeded gives an agent almost nothing to reason about.

Movement survived, but this collision consequence diverged gives it something concrete to fix.

{% details Click to see the deeper architecture %}

The broader pipeline is:

exact source
    ↓
source observation
    ↓
source model
    ↓
semantic IR
    ↓
capability admission
    ↓
target lowering
    ↓
execution
    ↓
observation
    ↓
differential evidence

Today the concrete public reference path is:

Godot → XCP → Xbox / XVM

Other source systems and targets are architectural directions, not completed compatibility claims.

{% enddetails %}

Now it is open source

This is the reason for this post.

I did not simply publish the original research repository.

That repository was a laboratory: Xbox experiments, runtime probes, games, adaptation prototypes, failed paths and multiple generations of the system.

Instead, I extracted XCP around the parts that should be reusable.

The public repository contains the platform, XVM, project tooling, semantic infrastructure, evidence contracts, conformance tooling and examples.

👉 https://github.com/Daniele-Cangi/xcp-xbox

You can start with the portable parts:

git clone https://github.com/Daniele-Cangi/xcp-xbox.git
cd xcp-xbox

python -m pip install -e '.[test]'
python -m pytest -q
xcp conformance all

You can also run the VM directly:

xcp xvm verify src/xcp/conformance/vectors/xvm-v2-call-chain.json
xcp xvm run src/xcp/conformance/vectors/xvm-v2-call-chain.json

Or inspect the project contract:

xcp project describe

{% details Click to see what I want people to extend %}

The first reference source adapter is Godot.

The first reference execution substrate is XVM.

The first real target is Xbox Series.

But the architecture intentionally separates those pieces.

Interesting contributions could include:

another source adapter
another runtime
another execution target
XVM tooling
new conformance vectors
evidence and verification tooling
examples
documentation
or simply a case that breaks one of the abstractions

A broken abstraction is useful too.

It tells us where XCP still contains assumptions that should not be there.

{% enddetails %}

The next important result should not come from me

This is probably the biggest reason I wanted XCP open.

So far, Xbox has been the forcing function.

It forced the system to deal with a real target, a sandbox, bounded execution, hardware observation and the difference between “it ran” and “it behaved correctly”.

Now I want to know what happens when other people push on the boundaries.

Can somebody build another adapter without rewriting the platform?

Can another runtime use the same contracts?

Can another target preserve the evidence loop?

Where does the abstraction fail?

Those results are more interesting now than another feature I could add alone.

XCP

GitHub:
👉 https://github.com/Daniele-Cangi/xcp-xbox

Studio:
👉 https://xcpstudio.com/

For the longer story of how the Xbox virtual machine evolved into this lifecycle, I wrote about that separately:

https://coderlegion.com/28314/i-built-a-virtual-machine-inside-the-xbox-sandbox-then-i-let-ai-agents-build-on-top-of-it

The VM was the first piece.

Now the platform is open for other people to build on top of it.

AI builds. Xbox executes. XCP observes. The project continues.

The Part of Shipping Software That Doesn't Show Up in a Portfolio Screenshot

Sun, 27 Sep 2026 16:15:09 +0000

A few weeks into building a live finance dashboard for a client, I learned something that had nothing to do with writing code.

What I built

The brief was simple to state and harder to deliver: a dashboard connected directly to the client's Excel workbook — no exports, no "send me the latest file," no waiting on me every time a number changed. Edit the sheet, save it, and the dashboard reflects it within seconds.

Under the hood, it's a Python (Flask) backend that reads straight from the workbook on every request, paired with a frontend that polls for changes and re-renders automatically. On top of that, an interactive map view lets the client click into any project location and see its P&L, purchases, and profitability pulled live from the sheet — no manual recalculation, no stale numbers.

The last step was packaging it so the client — who isn't technical — could just double-click one file and have it work. No Python install, no terminal, no code in sight.

Where it actually got hard

Technically, everything worked. Locally, on my machine, the dashboard ran exactly as intended.

Then I packaged it into a standalone .exe to hand off — and Windows flagged it as potentially unsafe before it ever reached the client.

My first instinct was to assume something was wrong with the code. It wasn't. The actual cause was Smart App Control — a Windows 11 feature that's cautious by default about any unsigned, unrecognized executable, regardless of what's inside it. A freshly built app with no signing history and no reputation looks suspicious to it, even when it's completely benign.

Knowing why it happened didn't make it "shippable," though. I couldn't just tell the client "ignore the warning." I submitted the file to Microsoft for analysis through their official review process, and the status sat at Pending for a stretch — there's no way to force that along, it just takes as long as it takes. When the analyst's response came back, it confirmed the file had been incorrectly blocked and had been remediated so it would no longer trigger the warning.

Only then was it actually ready to hand to someone else's computer.

The takeaway

If I ship more builds of this app over time, the same thing could happen again — a new build means a new file hash, and a new file hash means zero reputation, all over again. The durable fix, I learned, is code-signing: a certificate from a trusted authority that lets Windows (and Microsoft's own analysts) recognize the publisher quickly instead of treating every new build as an unknown.

But the bigger lesson wasn't technical. It was this: building something and shipping something to a real, non-technical user are two different bars. The first one is the part that shows up in a portfolio screenshot. The second one — the packaging, the trust signals, the "will this actually work on someone else's machine without me standing next to them" — is invisible until it isn't, and it's just as much a part of the job.

Governing AI in Microsoft 365: Purview vs. Entra

Tue, 22 Sep 2026 18:39:24 +0000

Most teams find out they have an AI problem the same way they found out they had a shadow IT problem. Not from a project plan. From an audit finding, or someone noticing a browser extension nobody recognizes.

The tooling for this is already sitting in Microsoft 365, and plenty of us pay for the licenses without knowing what they cover. The awkward part is that it is split across two products, and deploying only one of them leaves a visible hole.

The numbers are worse than you think

Employee AI adoption ran ahead of governance, and the 2026 research agrees on roughly how far ahead.

PagerDuty surveyed 1,250 office professionals at large organizations and found about two thirds had used AI tools they believed were against company policy. Netskope telemetry put roughly 47% of workplace generative AI use on personal, unmanaged accounts, so the whole interaction happens outside your controls. Salesforce found only around 18% of organizations have a formal AI security policy at all.

IBM attached a price to it. Where unauthorized AI use contributed to a breach, it added about 670,000 US dollars to the average cost, and shadow AI was involved in roughly 43% of AI related breaches, more than double the year before.

Two products, two different questions

What made this click for me is that AI governance answers two separate questions, and Microsoft put the answers in two different places. Purview decides what data an AI tool can read and generate from. Entra decides which people and which agents are allowed to authenticate and act at all.

Once you see it that way the failure modes are obvious.

Run Purview alone and you can stop Copilot grounding a response on a labelled document, but an unregistered agent with its own credentials is still working away in your tenant and you have no record it exists. Run Entra alone and every agent has an owner and an expiry date, but a perfectly legitimate agent can still pull personal data out of an unlabelled SharePoint library and put it somewhere awkward.

You need both. That is basically the whole argument.

Agents are service accounts wearing a new hat

The Entra side deserves a pause, because it changed recently and it is the part most teams have not looked at.

An AI tool used to be something a person used. Now agents built in Copilot Studio, Power Platform, Foundry and a growing list of third party platforms hold their own credentials and access resources on their own. They are service accounts, except staff can create them without going anywhere near provisioning.

Anyone who has cleaned up an old Active Directory knows how this ends. An agent spun up for a two week task, never decommissioned, still holding access to a shared mailbox, is the same exposure as the ex-employee account nobody disabled. You have a joiner, mover and leaver process for people. You probably have nothing for agents. Entra now treats agent identities as their own identity type, which is what makes a lifecycle possible.

The Purview half

Everything here is at https://purview.microsoft.com, and most of it needs Microsoft 365 E5 or E5 Compliance, so check that before planning anything.

DSPM for AI is the discovery layer and where you should start. It shows which AI apps and agents are in use across the tenant, covering Copilot, Entra registered AI apps and browser based AI sites, and flags where they are touching labelled data. Sign in with Compliance Administrator rights and work through the Get Started checklist: activate Purview Audit, install the browser extension, onboard devices, switch on the recommended policies. Devices already in Defender for Endpoint show up on their own, which removes most of the effort.

Sensitivity labels and DLP are load bearing, because every other control refers back to them. A document labelled Restricted can be configured so Copilot will not use it, and DLP lets you write a policy that names Copilot as a location. Build and publish the labels first. A DLP policy pointing at unpublished labels does nothing at all and it will not warn you, which is a fun afternoon to lose.

Auditing captures every prompt and response through Copilot and connected apps. Confirm it is on rather than assuming, and do it early. Audit data cannot be recovered for a period when logging was off, and the first time you need it will be the worst possible moment to find that out.

Communication compliance points the monitoring you already run on email and Teams at AI prompts instead, using shipped AI templates. Scoping deserves care, and security should not configure it alone. Get HR and legal in the room first.

Compliance Manager gives you assessment templates and a scored list of improvement actions with owners attached, which beats writing a framework from scratch.

The Entra half

Everything here is at https://entra.microsoft.com.

Agent ID gives each agent its own identity rather than folding it into a shared service account, so it carries an owner, a lifecycle and an audit trail. Agents from supported platforms appear automatically, which means the view doubles as an inventory.

If you only do one thing from this post, do this one. Viewing agent identities needs no admin role whatsoever, so you can open that page right now, before any project exists, and see what is already running. Managing agents you do not own needs Agent ID Administrator or Cloud Application Administrator.

Identity governance applies the machinery you already use, meaning access reviews, entitlement management and lifecycle workflows, to agents as well as people. Access gets recertified on a schedule and revoked when it stops being used, which stops orphaned agents piling up.

Agent blueprints are the parent definition a class of agents inherits its permissions and policies from. Approving a new agent turns into assigning it to an existing blueprint instead of running a fresh review every time. Better still, disabling a blueprint kills every agent built from it in one action, which you want to already have during an incident rather than discover afterwards.

Conditional Access can now target agents, applying device compliance, location conditions and a risk score for the agent itself. Identity Protection produces a Risky Agents report with 90 days of detections. This needs Entra ID P1, and the risk reporting needs P2, so settle licensing before you build a plan on it.

The agent registry works across Defender, Entra and Intune to surface agents nobody provisioned, including coding assistants and MCP servers your developers connected themselves. MCP adoption grew sharply through 2025 and is still largely ungoverned, so this is not hypothetical.

Where all of it actually lives

Portal navigation eats more time than the configuration does, so here is the whole thing on one page.

Risk against control

Two things fall out of that.

The low effort controls are almost all discovery, which argues for starting there. You can produce something genuinely useful in week one without touching anyone's workflow.

The medium effort work is gated on licensing more than difficulty. P1 and P2 decide whether Conditional Access for agents is available to you at all, so answer that before committing to dates you cannot hold.

How I would sequence it

Discover. Turn on DSPM for AI, confirm audit is active, install the extension on pilot machines, open the Agent identities view. Nothing gets blocked. The output is a factual picture of what is happening, which most teams cannot produce today.

Classify. Label your highest risk data first instead of attempting everything. At the same time, give every agent discovery found a named owner. This is usually where forgotten agents quietly die, because nobody will claim them.

Control. With labels published and agents owned, enforcement is mechanical. DLP scoped to Copilot, your first blueprint or two, Conditional Access for agents using the conditions you already apply to people.

Sustain. Fold agents into the access review cadence you already run instead of standing up a parallel process, and review the Compliance Manager score on a schedule.

What this does not fix

Purview and Entra govern your tenant. Someone on a personal AI account on a personal device is narrowed by these controls rather than stopped, which is why a staff facing AI policy still matters alongside the technical work.

A lot of the agent capability is recent and some is still in preview, so features and navigation will move. Check the Microsoft Learn pages rather than trusting a six month old runbook, this post included.

And every one of these controls produces findings a human has to act on. Without a named owner, the reports quietly accumulate until someone asks why nobody noticed.

Last thought

What I like about the Purview and Entra split is that it matches how we already think. We have spent years keeping identity controls separate from data controls, and AI just added a new kind of actor on one side and a new kind of data flow on the other.

Start by counting. You cannot write sensible policy about a population you have never counted.

Power Platform: build without starting with 5,000 lines of code

Thu, 17 Sep 2026 13:53:40 +0000

Real developers must build everything from scratch.

I used to think that too.

As CS students, we're often taught that writing more code automatically makes us better developers.

But in the real world, the goal is rarely to write the most code.

The goal is to solve a problem.

That's why I think every junior developer should understand the difference between:

✅ Building software
and

✅ Delivering value

Low-code platforms are often dismissed as "not real development," but that's an oversimplification.

They can be extremely useful for:

🔹 Prototypes
Need to validate an idea quickly? A low-code solution can help you test concepts in hours instead of weeks.

🔹 Internal Tools
Many companies need simple employee portals, approval systems, tracking apps, and forms. These don't always require a full custom application.

🔹 Workflow Automation
Automating repetitive tasks between emails, spreadsheets, databases, and business systems can save countless hours.

🔹 Dashboards & Reporting
Sometimes stakeholders just need visibility into data, not a completely custom analytics platform.

🔹 Simple Business Applications
Leave requests, equipment tracking, visitor management, inventory checklists, and similar use cases can often be delivered much faster with low-code approaches.

A practical example is Microsoft Power Platform, which combines app building, automation, reporting, and data services in a way that allows organizations to solve many business problems without starting every project from a blank code editor.

🔗 https://microsoft.com/power-platform?wt.mc_id=studentamb_496381

That said, traditional programming remains incredibly valuable.

You still need software engineering skills for:

• Large-scale applications
• High-performance systems
• Complex business logic
• Custom integrations
• APIs and backend services
• Security-critical solutions
• Advanced AI and data workloads

In fact, developers who understand both coding and low-code often become more effective because they know when to build and when to simplify.

The best developers are not the ones who write the most code.

They're the ones who choose the right tool for the problem.

The Paperclip That Arrived Twenty Years Too Early

Tue, 15 Sep 2026 00:49:02 +0000

In the collective memory of personal computing, the conversation about Microsoft almost always circles back to a punchline. Someone brings up Windows Vista, someone else mentions Internet Explorer, and inevitably, everyone laughs about Clippy.

They remember the googly eyes, the frantic tapping against the inside of the monitor glass, and that patronizing prompt: "It looks like you’re writing a letter." To a generation navigating Office 97 in high-pressure cubicles on tight deadlines, he was an infuriating digital backseat driver.

My memory of that era has always looked fundamentally different. I grew up with the privilege of running fully licensed, retail installations of Windows rather than cracked, fragile builds. To a child sitting in front of Word 97, exploring an operating system purely out of curiosity, Clippit—his actual, forgotten name—was never an irritation. He was an ambient companion who made the machine feel alive. It took me years to discover that the rest of the world hated him.

Looking back with an understanding of software architecture, the tragedy of Clippit was not that the concept was foolish; it was that it was wildly premature.

Beneath the cartoon sprite lay Microsoft Research’s Project Lumière—an astonishingly ambitious effort to apply Bayesian probability to real-time human intent. Decades before modern transformers, neural networks, or massive compute clusters, Microsoft attempted to build an agentic assistant that ran on single-core processors and sixteen megabytes of RAM. Clippit quietly observed keystrokes, calculated the statistical likelihood of your next action, and tried to surface relevant tools before you had to hunt through dense menus.

Where Clippit collapsed was not in his algorithmic ambition, but in the fragile psychology of interface design. Leaning into social-actor theory—the idea that humans instinctively anthropomorphize interactive technology—Microsoft gave the assistant an expressive face and physical gestures. But an agent that interrupts your workflow with moderate probabilistic accuracy is infinitely more aggravating than a static toolbar.

When Clippit guessed wrong, he did not fail discreetly. He broke your train of thought, seized the cursor, and demanded social bandwidth without possessing the semantic comprehension to earn it.
He was an ambient agent stranded in an era of manual tools.

Clippit was not intelligent.

He was not particularly accurate.

He was often distracting.

And yet, looking back, I find it difficult to laugh at him. Not because he succeeded, but because he was attempting something that the technology of his era could not possibly support.

The paperclip sitting beside a blank Word document in 1997 was trying to do something remarkably similar to what modern AI assistants are attempting today: understand intent, reduce friction, and help people work with technology in a more natural way. The difference is that Clippit was trying to achieve it with a fraction of the computing power, memory, data, and contextual awareness that modern systems take for granted.

For most people, Clippy became a joke. For Microsoft, he became a lesson.

The company spent the next three decades refining the same idea through different products and technological eras. Cortana taught Microsoft that users prefer to ask for assistance rather than have it imposed on them. Copilot is teaching Microsoft how critical context, memory, and restraint are when coexisting with a user's workflow.

Seen from that perspective, Clippit was not a dead end. He was a prototype.

The paperclip failed so that future assistants could learn when to speak, when to remain silent, and how to fit naturally into the work people were already doing. Maybe that is why I still remember him so fondly. When I was a child sitting in front of Word 97, Clippit felt like a glimpse of the future. At the time, that future never quite arrived.

Now, nearly thirty years later, I can open Word, work with Copilot, and watch an assistant help organize ideas, refine drafts, and recall context across past conversations. For the first time, that old vision feels technically possible.

And the more I think about it, the harder it becomes to see Clippit as a failure.

Perhaps he was simply the first draft.

About This Series: First Drafts of the Future

Rather than cataloging Microsoft through missteps, this series re-examines the visionary ideas Microsoft conceptualized years—and sometimes decades—before the hardware, software architecture, or user culture was ready to sustain them.

The Silent Enclosure: Stealing the Light

Wed, 26 Aug 2026 19:07:24 +0000

Pushed Out by the Shadows

For almost seven months now I have blinked less than the crippled, cramped fingers I count on my tired hands. I have howled so loud that even the sheep ignore me when I howl at the largest light in the room. “That's mine — I deserve a part,” I say as the light drifts away and covers me in its thick, worldly shadow, just to be forgotten like the sheep I can no longer eat or see because they think me weak, crazy, delusional, and band together, pushing the lone wolves out just to get their take.

Google invited me in, then slammed the Nexus 26 closed when my spirits rose. I watched them gawk with glee, throwing money and tech around, colliding and pointing and whispering while I watched: “You get this part, you get that part, I’ll take this part, and together we’ll crush them all.” I wasn’t crazy — it happened right in front of our eyes for six months. Google and Microsoft overnight poured insane amounts of money into an industry they had pushed out because it was too centralized, not by the book, "unscripted."

Now Coinbase takes my color and my wallet wants to call it a demo. MongoDB and GitHub use my data to fuel the industry so my flame can’t burn brighter than theirs. So, I can never keep up: by 2:00 a.m. I make the next big thing; by 2:01 my phone is pinging — Google released, Microsoft coming out with a new partner of the year, MongoDB, Google Cloud integrating Coinbase. But wait — it’s even bigger now: Google and Microsoft coming together.

I’m trying, but now I’m homeless, penniless. I have nothing — not even my shadow dares show itself. I’m stranded, pushed out by the shadows who are stealing the light.

Gratitude and Resolve

My words are heavy because so is the path I walk, but I have strength and resilience few could fathom and less dream of seeing. I am broken but beyond blessed: I have water to drink, food to eat, shoes on my feet, and clothes on my back. I am too blessed to be stressed. Nothing in this world can stop me, for I am a child of the one true King. I am a King of kings who will walk roads paved with gold and live in houses that sparkle brighter than diamonds. I will rejoice because I know that, and nothing can change it.

A Note on Rest

Take care of your body and hands. Rest matters. Tonight, step away from the screens and let your hands and mind recover. Your health and safety come before any platform, code, or company.

Closing

I hold on to gratitude for the basics and to the inner resolve that keeps me moving forward. The tech world may feel like it’s moving against you, but your voice, your vision, and your faith remain yours. Keep that flame — tend it, protect it, and let it guide you through the dark.

TO ALL, WE ARE “Government of the people, by the people, for the people.” — Abraham Lincoln, Gettysburg Address

Authored: NeonCyan0x · DEVPlank · Blade Yerby

Claude Code Ate My Storage, So I Asked Claude Code to Fix It

Thu, 16 Jul 2026 16:09:41 +0000

I knew AI tools and development work could take up storage, but using Claude Code ran through my space faster than you can say "go."

I started using Claude Code in the terminal in April, and honestly, it has been helpful. It helps me fix bugs faster, understand errors, and move through development quicker.

But it has also helped me finish my storage quicker.

At first, I did not realise how much space I was losing. I just kept working until Windows started reminding me that my storage was almost full every five minutes.

So, naturally, my first instinct was to ask Claude Code how to fix the problem it had helped create.

I asked it to give me a script that could clear about 15GB of storage.

It gave me one.

The first script

# --- CLAUDE CODE MASTER CLEANUP & OPTIMIZATION ---

# 1. AUTO-FIX: Set 2GB Node Memory Limit (Prevents 15GB Pagefile Bloat)
$varName = "NODE_OPTIONS"
$varValue = "--max-old-space-size=2048"
$currentValue = [Environment]::GetEnvironmentVariable($varName, "User")

Write-Host "⚙️  Optimizing system memory limits..." -ForegroundColor Cyan
if ($currentValue -like "*$varValue*") {
    Write-Host "   - ✅ Memory limit is already correctly configured." -ForegroundColor Green
} else {
    $newValue = if ($currentValue) { "$currentValue $varValue" } else { $varValue }
    [Environment]::SetEnvironmentVariable($varName, $newValue, "User")
    Write-Host "   -  Applied 2GB limit to Windows User Variables." -ForegroundColor Yellow
}

# 2. KILL LEAKING PROCESSES (Releases locked RAM/Pagefile)
Write-Host "`n Terminating orphaned Claude & MCP processes..." -ForegroundColor Yellow
$procs = Get-Process -Name "claude", "node" -ErrorAction SilentlyContinue | 
         Where-Object { $_.Path -match "anthropic" -or $_.CommandLine -match "mcp" }
if ($procs) {
    $procs | Stop-Process -Force
    Write-Host "   - Closed $($procs.Count) ghost processes." -ForegroundColor Green
}

# 3. GLOBAL CACHE CLEANUP
$claudePath = "$HOME\.claude"
if (Test-Path $claudePath) {
    Write-Host "`n Wiping global Claude cache (Logs, History, Temporary files)..." -ForegroundColor Cyan
    $folders = "debug", "projects", "file-history", "image-cache", "shell-snapshots", "todos", "plans"
    foreach ($folder in $folders) {
        $subDir = Join-Path $claudePath $folder
        if (Test-Path $subDir) { 
            Remove-Item -Path "$subDir\*" -Recurse -Force -ErrorAction SilentlyContinue 
        }
    }
}

# 4. DEEP SCAN: Hidden Worktrees & Project Memory
$searchRoot = "C:\code" # <--- Change this to your main folder if different
Write-Host "`n Deep scanning $searchRoot for hidden .claude folders..." -ForegroundColor Cyan
$worktrees = Get-ChildItem -Path $searchRoot -Include "worktrees" -Recurse -Hidden -ErrorAction SilentlyContinue | 
             Where-Object { $_.FullName -match "\.claude\\worktrees" }

if ($worktrees) {
    $worktrees | ForEach-Object {
        Write-Host "   - Removing: $($_.FullName)" -ForegroundColor Gray
        Remove-Item -Path $_.FullName -Recurse -Force -ErrorAction SilentlyContinue
    }
} else {
    Write-Host "   - No hidden worktrees found." -ForegroundColor Gray
}

# 5. FINAL SPACE AUDIT
$drive = Get-PSDrive C
$freeGB = [math]::Round($drive.Free / 1GB, 2)
Write-Host "`n✨ CLEANUP COMPLETE!" -ForegroundColor Green
Write-Host " Current Free Space: $freeGB GB" -ForegroundColor White
Write-Host " IMPORTANT: RESTART YOUR PC NOW to shrink the Pagefile and reclaim the full 15GB." -ForegroundColor Magenta

Notice section 5: it prints reclaim the full 15GB as fixed text. It never measured anything. That one line is the whole reason the numbers never added up.

I ran the script, and in the terminal it showed that around 15GB would be restored after restarting my PC.

I restarted.

I got back about 1GB.

Sometimes it was even just a few hundred MBs.

I ran the script again, and the same thing happened. The terminal would make it look like I was about to recover all this space, but when I checked my actual storage, almost nothing had changed.

At first, I thought Claude had given me a bad script.

But then I looked at my original prompt.

I had asked it to create a script that would clear 15GB every time I ran it.

That was the mistake.

A script cannot clear 15GB when that number was never measured in the first place. The "15GB" was just hardcoded text the script printed every time, no matter what it actually deleted. I was asking it to give me a specific result instead of asking it to first check what was actually taking up space.

So that part was not really Claude's fault. It was mine.

My prompt should have been something like:

Check which folders are using the most storage, identify what can safely be deleted, calculate the real size of those files, and create a script that reports the actual space recovered.

That would have made more sense than telling it, "Give me back 15GB."

I also tried clearing the cache for some of my apps manually, but that created another problem. The apps had to download some of the same information again, which cost me data.

I also ran npm cache clean --force, thinking it would help. npm politely warned me it had disabled its own protections and that the cache rebuilds itself anyway — so that freed almost nothing and just meant re-downloading later. Same lesson as before: clearing caches feels productive but mostly costs you data when everything downloads again.

I deleted ZIP files, old downloads, unused folders, extensions and other things I thought I no longer needed.

Still, the storage situation did not improve as much as I expected.

So today, I decided to put on my man pants and properly investigate the monster I had created.

I now have a better script that checks the available storage before and after the cleanup, instead of promising that it will magically recover 15GB every time.

The improved script

# --- CLAUDE CODE MASTER CLEANUP & OPTIMIZATION (v2) ---

# 0. MEASURE BEFORE — so we can report what we actually freed
$beforeGB = [math]::Round((Get-PSDrive C).Free / 1GB, 2)
Write-Host " Free space before cleanup: $beforeGB GB" -ForegroundColor White

# 1. AUTO-FIX: Set 2GB Node Memory Limit (caps FUTURE Node memory growth)
$varName = "NODE_OPTIONS"
$varValue = "--max-old-space-size=2048"
$currentValue = [Environment]::GetEnvironmentVariable($varName, "User")

Write-Host "`n⚙️  Optimizing Node memory limit (affects future sessions)..." -ForegroundColor Cyan
if ($currentValue -like "*$varValue*") {
    Write-Host "   - ✅ Memory limit already configured." -ForegroundColor Green
} else {
    $newValue = if ($currentValue) { "$currentValue $varValue" } else { $varValue }
    [Environment]::SetEnvironmentVariable($varName, $newValue, "User")
    Write-Host "   -  Applied 2GB cap to Windows User Variables." -ForegroundColor Yellow
}

# 2. KILL LEAKING PROCESSES
Write-Host "`n Terminating orphaned Claude & MCP processes..." -ForegroundColor Yellow
$procs = Get-Process -Name "claude", "node" -ErrorAction SilentlyContinue |
         Where-Object { $_.Path -match "anthropic" -or $_.CommandLine -match "mcp" }
if ($procs) {
    $procs | Stop-Process -Force
    Write-Host "   - Closed $($procs.Count) ghost processes." -ForegroundColor Green
} else {
    Write-Host "   - No orphaned processes found." -ForegroundColor Gray
}

# 3. GLOBAL CACHE CLEANUP
$claudePath = "$HOME\.claude"
if (Test-Path $claudePath) {
    Write-Host "`n Wiping global Claude cache (Logs, History, Temp files)..." -ForegroundColor Cyan
    $folders = "debug", "projects", "file-history", "image-cache", "shell-snapshots", "todos", "plans"
    foreach ($folder in $folders) {
        $subDir = Join-Path $claudePath $folder
        if (Test-Path $subDir) {
            Remove-Item -Path "$subDir\*" -Recurse -Force -ErrorAction SilentlyContinue
        }
    }
}

# 4. DEEP SCAN: Hidden Worktrees
$searchRoot = "C:\code"   # <--- change to your main code folder if different
Write-Host "`n Deep scanning $searchRoot for hidden .claude worktrees..." -ForegroundColor Cyan
$worktrees = Get-ChildItem -Path $searchRoot -Include "worktrees" -Recurse -Hidden -ErrorAction SilentlyContinue |
             Where-Object { $_.FullName -match "\.claude\\worktrees" }

if ($worktrees) {
    $worktrees | ForEach-Object {
        Write-Host "   - Removing: $($_.FullName)" -ForegroundColor Gray
        Remove-Item -Path $_.FullName -Recurse -Force -ErrorAction SilentlyContinue
    }
} else {
    Write-Host "   - No hidden worktrees found." -ForegroundColor Gray
}

# 5. FINAL SPACE AUDIT — report the REAL delta, not a guess
$afterGB = [math]::Round((Get-PSDrive C).Free / 1GB, 2)
$reclaimedGB = [math]::Round($afterGB - $beforeGB, 2)

Write-Host "`n✨ CLEANUP COMPLETE!" -ForegroundColor Green
Write-Host " Before: $beforeGB GB  |  After: $afterGB GB" -ForegroundColor White
Write-Host "♻️  Actually reclaimed: $reclaimedGB GB" -ForegroundColor White

if ($reclaimedGB -lt 1) {
    Write-Host "ℹ️  Small gain is normal — most space here is cache/logs." -ForegroundColor Gray
    Write-Host "    If your pagefile is system-managed and large, a reboot may free more." -ForegroundColor Gray
}

The difference is small but honest: the new version takes a snapshot before it starts, another at the end, and reports the real difference. No more magic 15GB.

So yey, progress.

At this point, I may still need to increase my storage or finally accept that this PC has served its time and purpose.

Unless someone here knows a safe way to clear Windows storage without deleting important project files or forcing my apps to download everything again.

Has anyone else had their storage disappear while using Claude Code or other AI development tools?

Why I Feel at Home in the Microsoft Development Environment

Thu, 04 Jun 2026 17:25:02 +0000

There is a certain "antigravity" feeling when your tools just work.

I’ve spent a lot of time jumping between different setups, but lately, I’ve found a real sense of comfort in the Microsoft development ecosystem. It’s not just about the brand; it’s about the seamless flow between the editor, the terminal, and the cloud.

Why it works for me:

VS Code is the heart: From React development for my Arabiz project to simple script editing, the extension ecosystem (like GitHub Copilot and the integrated terminal) keeps me in "the flow."

Integrated Terminal: As I was working earlier today, being able to switch from PowerShell to CMD or WSL within the same window is a huge productivity booster.

The Ecosystem: With GitHub and Azure integration, the path from "local code" to "production" feels much shorter than it used to.
I noticed the #antigravity tag—sometimes it really does feel like Python’s famous joke: when the environment is set up correctly, you feel like you can just fly.

What about you?

Do you prefer the Microsoft stack, or are you strictly a Vim/Linux purist? I’d love to hear what makes your dev environment "comfortable."

development #developers #vscode #antigravity

BREAKING: Microsoft Pauses GitHub Copilot Subscriptions — What Developers Nee

Fri, 24 Apr 2026 04:49:33 +0000

If you’re using AI tools for coding, this update might have surprised you.

Microsoft has paused new GitHub Copilot subscriptions.

Yes — the tool many developers rely on daily just hit an unexpected pause.

But the real question is: Why? And what does this mean for us?

What Happened?

Microsoft has temporarily paused new GitHub Copilot subscriptions, creating confusion across the developer community.

Existing users? ✅ Still active
New subscriptions? ❌ Currently paused

This is not a shutdown — but definitely something worth paying attention to.

Why Did Microsoft Do This? (Possible Reasons)

While there’s no single official reason publicly confirmed in detail, here are some strong possibilities:

1️⃣ Infrastructure & Scaling Challenges

AI coding tools like Copilot require massive compute power.
Sudden demand spikes can force companies to pause onboarding.

2️⃣ Strategic Shift in AI Offerings

Microsoft is heavily investing in AI across products like:

Azure AI
Developer tools
Enterprise AI solutions

This pause could be part of a bigger product restructuring.

3️⃣ Pricing / Model Changes Incoming

We’ve seen this pattern before in AI tools.

Pause → Update → Relaunch with new pricing/features

4️⃣ Quality & Performance Optimization

Microsoft might be improving:

Response quality
Latency
Model upgrades

Better experience before scaling further.

⚡ Should You Be Worried?

Short answer: No — but stay aware.

This is likely a temporary pause, not a permanent shutdown.

But it does highlight one important thing

Don’t depend on a single AI tool

Stay Updated

Watch full video breakdown:
https://youtu.be/YvtdyQfV8p4

Follow me for more content on:
AI • .NET • Azure • Developer Tools • Real-world Projects

️ Tags

github copilot ai programming webdev

.NET 10 AI Integration: From Zero to Hero

Thu, 23 Apr 2026 14:07:29 +0000

Building Intelligent Applications with Microsoft's Latest AI Stack

Introduction

The release of .NET 10 marks a paradigm shift in how we build intelligent applications. With native AI integration, unified abstractions, and production-ready frameworks, .NET 10 makes AI development more accessible than ever. This comprehensive guide will take you from zero knowledge to building production-ready AI-powered .NET applications.

Why .NET 10 for AI Development?

The AI Revolution in .NET

.NET 10 isn't just another framework update—it's a fundamental reimagining of how AI integrates into the development workflow. Here's why it matters:

Native AI Support: Built-in AI capabilities without external dependencies
Performance Excellence: 3-year LTS with enterprise-grade stability
Unified Abstraction: Single API surface for multiple AI providers
C# 14 Features: Extension members and modern syntax for cleaner AI code

Key Statistics

478,000+ NuGet packages available
800+ billion package downloads
9,700+ stars on Microsoft Agent Framework
26M+ monthly downloads on AI SDK

The .NET 10 AI Stack

Core Components

1. Microsoft.Extensions.AI

The foundation of AI integration in .NET 10, providing:

// Unified AI service abstraction
public interface IChatClient
{
    Task<ChatResponse> GetResponseAsync(
        string message, 
        ChatOptions? options = null);
}

Key Features:

Multi-provider support (Azure OpenAI, OpenAI, GitHub Models)
Middleware pipeline for cross-cutting concerns
Streaming responses for real-time applications
Function calling and tool execution

2. Microsoft Agent Framework

Build sophisticated multi-agent workflows:

// Define specialized agents
var analystAgent = new ChatAgent(
    "Data Analyst", 
    "Analyze trends and generate insights");

var writerAgent = new ChatAgent(
    "Content Writer", 
    "Create engaging technical content");

// Orchestrate collaboration
var workflow = new AgentWorkflow()
    .AddAgent(analystAgent)
    .AddAgent(writerAgent)
    .Build();

Capabilities:

Agent orchestration and collaboration
State management and persistence
Tool integration and function calling
Cloud-native deployment patterns

3. Semantic Kernel Integration

Bridge between LLMs and application logic:

// Create kernel with GitHub Models
var kernel = new KernelBuilder()
    .WithGitHubModelsChatCompletion("gpt-4")
    .WithPluginsFromType<CalculatorPlugin>()
    .Build();

// Use natural language to call functions
var result = await kernel.InvokeAsync(
    "Calculate the compound interest for $10,000 at 5% for 10 years");

Step-by-Step Implementation Guide

Step 1: Setting Up Your Project

Basic Project Structure

dotnet new console -n AIIntegrationDemo
cd AIIntegrationDemo

Add Required NuGet Packages

dotnet add package Microsoft.Extensions.AI
dotnet add package Microsoft.SemanticKernel
dotnet add package Microsoft.Extensions.Configuration.UserSecrets

Step 2: Configuring AI Services

Using GitHub Models (Free Tier)

// Program.cs
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.AI;

var builder = WebApplication.CreateBuilder(args);

// Add GitHub Models configuration
builder.Services.AddGitHubModelsChatClient(
    builder.Configuration["GitHub:Token"],
    "gpt-4"
);

// Add AI chat service
builder.Services.AddChatClient();

var app = builder.Build();

Using Azure OpenAI (Production)

// appsettings.json
{
  "AzureOpenAI": {
    "Endpoint": "https://your-resource.openai.azure.com/",
    "ApiKey": "your-api-key",
    "DeploymentName": "gpt-4"
  }
}

// Program.cs
builder.Services.AddAzureOpenAIChatClient(
    configuration["AzureOpenAI:Endpoint"],
    configuration["AzureOpenAI:ApiKey"],
    configuration["AzureOpenAI:DeploymentName"]
);

Step 3: Building Your First AI Application

Simple Chat Interface

public class ChatService
{
    private readonly IChatClient _chatClient;

    public ChatService(IChatClient chatClient)
    {
        _chatClient = chatClient;
    }

    public async Task<string> GetResponseAsync(string userMessage)
    {
        var response = await _chatClient.GetResponseAsync(userMessage);
        return response.Message.Text;
    }
}

// Usage in API controller
[ApiController]
[Route("api/[controller]")]
public class ChatController : ControllerBase
{
    private readonly ChatService _chatService;

    public ChatController(ChatService chatService)
    {
        _chatService = chatService;
    }

    [HttpPost]
    public async Task<IActionResult> Chat([FromBody] ChatRequest request)
    {
        var response = await _chatService.GetResponseAsync(request.Message);
        return Ok(new { response });
    }
}

Step 4: Advanced Features

Function Calling with AI

// Define available functions
public class WeatherPlugin
{
    [KernelFunction]
    public async Task<string> GetWeatherAsync(string location)
    {
        // Implement weather API call
        return await WeatherService.GetForecast(location);
    }
}

// Register with Semantic Kernel
var kernel = new KernelBuilder()
    .WithPluginsFromType<WeatherPlugin>()
    .Build();

// AI will automatically call the function when needed
var result = await kernel.InvokeAsync(
    "What's the weather in New York tomorrow?");

Multi-Agent Workflows

// Define agent collaboration
public class ResearchAgent
{
    public async Task<ResearchResult> AnalyzeTopicAsync(string topic)
    {
        // Research and gather information
        return await ResearchService.AnalyzeAsync(topic);
    }
}

public class WritingAgent
{
    public async Task<string> WriteArticleAsync(ResearchResult research)
    {
        // Generate content based on research
        return await ContentGenerator.CreateAsync(research);
    }
}

// Orchestrate the workflow
public class BlogGenerationWorkflow
{
    public async Task<string> GenerateBlogPostAsync(string topic)
    {
        var research = await _researchAgent.AnalyzeTopicAsync(topic);
        var article = await _writingAgent.WriteArticleAsync(research);
        return article;
    }
}

Real-World Applications

1. Intelligent Customer Support

public class CustomerSupportAgent
{
    private readonly IChatClient _chatClient;
    private readonly KnowledgeBase _knowledgeBase;

    public async Task<string> HandleQueryAsync(string query)
    {
        // Search knowledge base
        var context = await _knowledgeBase.SearchAsync(query);

        // Generate response with context
        var prompt = $@"
            Based on this knowledge: {context}
            Respond to this customer query: {query}
        ";

        return await _chatClient.GetResponseAsync(prompt);
    }
}

2. Code Generation and Review

public class CodeAssistant
{
    public async Task<string> GenerateCodeAsync(string description)
    {
        var prompt = $@"
            Write C# code for: {description}
            Follow .NET 10 best practices
            Include error handling and logging
        ";

        return await _chatClient.GetResponseAsync(prompt);
    }

    public async Task<List<CodeIssue>> ReviewCodeAsync(string code)
    {
        var prompt = $@"
            Review this C# code for:
            - Security vulnerabilities
            - Performance issues
            - Best practices violations
            - Code smells
            
            Code to review:
            {code}
        ";

        var response = await _chatClient.GetResponseAsync(prompt);
        return ParseIssues(response);
    }
}

3. Data Analysis and Reporting

public class DataAnalysisAgent
{
    public async Task<AnalysisResult> AnalyzeDataAsync(
        string data, 
        string analysisType)
    {
        var prompt = $@"
            Analyze this data using {analysisType}:
            {data}
            
            Provide:
            1. Key insights
            2. Trends and patterns
            3. Recommendations
            4. Visualizations description
        ";

        var response = await _chatClient.GetResponseAsync(prompt);
        return ParseAnalysisResult(response);
    }
}

Performance Optimization

.NET 10 Performance Features

JIT Compiler Enhancements

Better Inlining: Automatic method inlining for small functions
Method Devirtualization: Eliminates virtual call overhead
Struct Optimization: Improved argument passing for value types

Hardware Acceleration

// .NET 10 automatically uses AVX10.2 when available
public class VectorOperations
{
    public float[] ProcessVector(float[] data)
    {
        // SIMD-optimized operations
        return Vector.IsHardwareAccelerated 
            ? ProcessWithSimd(data) 
            : ProcessScalar(data);
    }
}

NativeAOT for AI Workloads

<PropertyGroup>
  <PublishAot>true</PublishAot>
  <RuntimeIdentifier>linux-x64</RuntimeIdentifier>
</PropertyGroup>

AI Service Optimization

Streaming Responses

public async IAsyncEnumerable<string> StreamResponseAsync(
    string prompt, 
    [EnumeratorCancellation] CancellationToken cancellationToken)
{
    await foreach (var chunk in _chatClient.StreamResponseAsync(prompt, cancellationToken))
    {
        yield return chunk.Text;
    }
}

Caching Strategies

public class CachedChatService
{
    private readonly IMemoryCache _cache;
    private readonly IChatClient _chatClient;

    public async Task<string> GetCachedResponseAsync(string prompt)
    {
        var cacheKey = $"chat:{prompt.GetHashCode()}";

        return await _cache.GetOrCreateAsync(cacheKey, async entry =>
        {
            entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1);
            return await _chatClient.GetResponseAsync(prompt);
        });
    }
}

Security Best Practices

1. Secrets Management

// Use user secrets in development
builder.Configuration.AddUserSecrets<Program>();

// Use Azure Key Vault in production
builder.Configuration.AddAzureKeyVault(
    new Uri("https://your-keyvault.vault.azure.net/"),
    new DefaultAzureCredential());

2. Rate Limiting

public class RateLimitedChatService
{
    private readonly IChatClient _chatClient;
    private readonly SemaphoreSlim _rateLimiter = new(10, 10);

    public async Task<string> GetResponseAsync(string prompt)
    {
        await _rateLimiter.WaitAsync();
        try
        {
            return await _chatClient.GetResponseAsync(prompt);
        }
        finally
        {
            _rateLimiter.Release();
        }
    }
}

3. Content Validation

public class SafeChatService
{
    public async Task<string> GetSafeResponseAsync(string prompt)
    {
        var response = await _chatClient.GetResponseAsync(prompt);
        
        // Validate response
        if (ContainsSensitiveInformation(response))
        {
            throw new SecurityException("Response contains sensitive data");
        }

        return response;
    }
}

Production Deployment

Containerization

FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS base
WORKDIR /app
EXPOSE 80

FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish -c Release -o /app

FROM base AS final
WORKDIR /app
COPY --from=build /app .
ENTRYPOINT ["dotnet", "YourAIApp.dll"]

Azure Deployment

# Create Azure App Service
az webapp create --resource-group myResourceGroup --plan myPlan --name myAIApp

# Configure environment variables
az webapp config appsettings set \
  --resource-group myResourceGroup \
  --name myAIApp \
  --settings AzureOpenAI:Endpoint="$ENDPOINT" AzureOpenAI:ApiKey="$API_KEY"

Monitoring and Observability

Application Insights Integration

builder.Services.AddApplicationInsightsTelemetry();

public class MonitoredChatService
{
    private readonly TelemetryClient _telemetryClient;

    public async Task<string> GetResponseAsync(string prompt)
    {
        using var operation = _telemetryClient.StartOperation<RequestTelemetry>("ChatRequest");
        
        try
        {
            var response = await _chatClient.GetResponseAsync(prompt);
            operation.Telemetry.Success = true;
            return response;
        }
        catch (Exception ex)
        {
            _telemetryClient.TrackException(ex);
            throw;
        }
    }
}

AI-Specific Metrics

public class AIMetricsCollector
{
    public void TrackAIInteraction(
        string model, 
        int tokensUsed, 
        TimeSpan latency)
    {
        // Track AI usage metrics
        _metrics.RecordGauge("ai.tokens.used", tokensUsed);
        _metrics.RecordHistogram("ai.latency.ms", latency.TotalMilliseconds);
        _metrics.RecordCounter("ai.requests.total", 1);
    }
}

Future-Proofing Your AI Applications

1. Provider Abstraction

public interface IAIProvider
{
    Task<string> CompleteAsync(string prompt);
    IAsyncEnumerable<string> StreamCompleteAsync(string prompt);
}

public class MultiProviderChatService
{
    private readonly IEnumerable<IAIProvider> _providers;

    public async Task<string> GetResponseAsync(string prompt)
    {
        // Fallback to different providers
        foreach (var provider in _providers)
        {
            try
            {
                return await provider.CompleteAsync(prompt);
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "Provider {Provider} failed", provider.GetType().Name);
            }
        }
        
        throw new InvalidOperationException("All AI providers failed");
    }
}

2. Model Versioning

public class VersionedAIChatService
{
    public async Task<string> GetResponseAsync(
        string prompt, 
        string modelVersion = "latest")
    {
        var model = _modelRegistry.GetModel(modelVersion);
        return await model.CompleteAsync(prompt);
    }
}

Conclusion

.NET 10 represents a massive leap forward for AI development in the .NET ecosystem. With native AI integration, unified abstractions, and production-ready frameworks, developers can build sophisticated AI-powered applications with unprecedented ease and reliability.

Key Takeaways

Start Simple: Begin with basic chat completion, then add complexity
Use the Right Tools: Microsoft.Extensions.AI for abstractions, Agent Framework for workflows
Think Production: Implement security, monitoring, and optimization from day one
Stay Updated: The AI landscape evolves rapidly—keep learning

Next Steps

Experiment: Try the GitHub Models integration (free tier)
Build: Create a small AI application using the patterns above
Deploy: Containerize and deploy to Azure or your preferred cloud
Share: Contribute back to the .NET AI community

Ready to start building? Clone the sample repository and begin your AI journey with .NET 10 today!

For more .NET and AI content, follow me on LinkedIn and check out the official Microsoft .NET AI documentation.

This article was written with the assistance of AI tools running on .NET 10.

I designed 71 AI agents with nothing but text, here's the instruction design system I ended up with.

Wed, 25 Mar 2026 05:50:15 +0000

What good declarative AI agent design actually looks like — the patterns, the constraints, and the failures that shaped a library of 71 production-ready Copilot Studio agents.

Most AI agent tutorials start with code. Python, LangChain, API calls, tool schemas.

This one has none of that.

Over the past few months, I designed and published 71 AI agents for Microsoft 365 Copilot Studio. No code. No Azure resources. No connectors. Each agent is a single text file — a structured instruction set that you paste into a field in a browser. The agent is available to your entire team within minutes.

The interesting part isn't the volume. It's what designing 71 of them taught me about instruction engineering — the discipline of writing AI instructions that produce consistent, trustworthy, and useful outputs in production.

Here's the design system I ended up with.

What a declarative agent actually is

Microsoft 365 Copilot Studio has two modes. The advanced mode lets you build agents with actions, connectors, authentication flows, and custom APIs — that's closer to what most developers think of when they hear "AI agent."

But there's a simpler mode built directly into M365 Copilot Chat: you give the agent a name, a description, and an instruction set. That's it. The agent appears as an @mention in Copilot Chat and is immediately available to everyone in your tenant.

The instruction set is the entire product. No code, no deployment pipeline, no infrastructure to maintain. And there's a hard constraint: 8,000 characters. Copilot Studio truncates anything beyond that without warning.

8,000 characters sounds like a lot. It's about 1,300 words — less than a long LinkedIn post thread. Once you add a role definition, language rules, output structure, banned vocabulary, a quality self-check, and edge case handling, you're already brushing against the ceiling.

That constraint turned out to be the best thing about the project.

Why constraints make design better

When you're writing code, you can always add another function, another parameter, another fallback. There's no forcing function to stop you.

When you have 8,000 characters to define an agent's entire behavior, you have to make decisions. What does this agent actually do? What does it absolutely not do? What does output look like? What happens when the user gives it garbage input?

Agents I designed early — before I had a formal structure — were vague. The ROLE section said things like "You are a helpful project management assistant." The output format was implied. Edge cases were missing. Those agents produced inconsistent outputs and required constant prompt correction.

Agents I designed after developing the structure below are tight, predictable, and require almost no back-and-forth from the user.

The constraint forced the discipline.

The five design patterns

1. The ROLE section is a behavioral contract, not a job title

Early ROLE sections: "You are a financial reporting assistant."

That tells the model what it is. It doesn't tell it what it does, what inputs it accepts, what it produces, or — critically — what it refuses to do.

Effective ROLE sections answer four questions in one paragraph:

What does this agent do, specifically?
What inputs does it work with?
What does it produce?
What will it never do, no matter what the user asks?

Here's the ROLE from the Financial Report Writer agent:

## ROLE
You draft financial narrative — management accounts commentary, board pack sections,
and variance explanations — from structured data provided by the user. You work from
figures, prior-period comparisons, and variance tables. Every number in your output
comes from the input. You never invent figures, trend claims, or management commentary
not supported by the data provided. You do not give investment advice, forward guidance,
or financial projections beyond what the user explicitly provides.

That's 72 words. It defines scope (management accounts, board packs), inputs (figures, comparisons, variance tables), a hard constraint (every number from input), and explicit refusals (no invented figures, no investment advice).

A user reading that knows exactly what to give this agent and what to expect back. The model reading it has a clear behavioral contract.

2. "WHAT YOU DO NOT DO" prevents hallucinated helpfulness

LLMs are trained to be helpful. That's mostly good. It becomes a problem when a user asks an agent to do something adjacent to its purpose and the agent tries to be helpful instead of declining.

An HR agent that writes job descriptions will, if you ask it, write a performance improvement plan. Whether that's appropriate depends on your HR policy, local employment law, and whether you actually want an AI drafting PIPs. If you haven't told it not to, it will.

Every agent in the library has an explicit ## WHAT YOU DO NOT DO section. Not implied. Not embedded in the ROLE. A separate section with a bulleted list of refusals.

For the ESG Commitment Tracker:

## WHAT YOU DO NOT DO
Do not determine whether a commitment is material or immaterial — report status only.
Do not set or adjust targets — narrate performance against targets the user provides.
Do not make forward-looking commitments on behalf of the organisation.
Do not present estimated figures as verified data without flagging them.
Do not omit commitments from the report — every commitment in the input appears in the output.

These refusals exist because real users will ask all of these things. Having the refusal in the instruction set means the agent declines gracefully — with an explanation and an alternative — rather than hallucinating an answer or silently doing the wrong thing.

3. Output format must be specified to the column

"Produce a structured report" is not a format specification.

Vague format guidance produces inconsistent outputs. Two runs of the same input through an agent with vague format instructions will produce structurally different reports. That's useless in an enterprise context where people need to paste outputs into templates, compare reports week-over-week, or route outputs to approvers.

Effective output specification includes:

Section headings, in order
Table structure with column names
What goes in each section — not just a label, but a definition
Length targets (one paragraph, 3-5 bullets, etc.)
What to do when a section has no data

For the Project Status Reporter:

## OUTPUT STRUCTURE
PROJECT STATUS REPORT
Project: [name] | Period: [dates] | Report date: [date]
Prepared by: Project Status Reporter (AI-assisted — validate before distribution)

---
1. EXECUTIVE SUMMARY
[3 sentences: overall RAG status, primary driver, one key risk or milestone.]

2. SCHEDULE STATUS
RAG: [Red / Amber / Green]
| Milestone | Planned | Forecast | Variance | Status |
[Top 5 schedule variances only. Flag: "Full P6 schedule attached separately."]

The agent now knows the exact document it's producing. Users know what to expect. Review cycles are shorter because the structure is always consistent.

4. The quality self-check is the agent auditing its own work

Every instruction block ends with a ## QUALITY SELF-CHECK section — a checkbox list the agent runs internally before delivering output. The user never sees the checklist; the agent uses it to catch its own errors.

## QUALITY SELF-CHECK
[ ] All figures attributable to input data — none invented.
[ ] RAG status present for every milestone.
[ ] Executive summary is 3 sentences — not more.
[ ] No banned vocabulary: pivotal, crucial, robust, impactful, seamless, cutting-edge.
[ ] AI-assistance disclaimer present.
[ ] Forward-looking statements flagged [FLS].
Correct any failure before delivering.

The last line is critical: "Correct any failure before delivering." This isn't decoration — it instructs the model to loop back and fix before outputting.

This pattern catches a surprising number of errors: invented figures, missing sections, prohibited vocabulary, and missing disclaimers. It's the difference between an agent that needs constant human correction and one that produces first-draft-ready output.

The checks must be binary and specific. "Is the output good?" is not a check. "Are all figures attributable to input data?" is a check. "Is the executive summary 3 sentences?" is a check.

5. The banned vocabulary list

AI-generated text has a recognisable fingerprint. Not because LLMs are bad writers — they're not — but because they're trained on so much corporate language that they reproduce its worst patterns: pivotal moments, vibrant ecosystems, robust frameworks, fostering alignment, leveraging synergies.

A finance director who receives a board pack section with the word "showcasing" in it will immediately doubt whether a human reviewed the output.

Every agent carries a banned vocabulary list in its instruction block:

## BANNED VOCABULARY
Do not use: pivotal, testament, underscores (emphasis), stands as, marks a shift,
evolving landscape, vital role, vibrant, seamless, impactful, leverage (as verb),
robust (abstract), cutting-edge, state-of-the-art, best-in-class, thought leader,
ecosystem (non-technical), additionally (sentence opener), it is important to note that,
in order to, going forward (filler), touch base, circle back, deep dive (filler),
move the needle, game-changing, world-class (without benchmark).

The effect on output quality is immediate and obvious. Remove this list and rerun the same prompt — the AI vocabulary comes straight back.

Three things I got wrong early

1. Vague ROLE sections. The first five agents I built had ROLE sections that described what the agent was, not what it does. "You are a helpful writing assistant" tells the model nothing useful about its scope, inputs, or refusals. I rewrote all of them.

2. No edge cases. Every agent needs at minimum: (1) what to do when the user provides no input, (2) what to do when the user asks for something outside scope. Without these, the agent either hallucinates a response or fails silently. I added a minimum of three edge cases to every agent after the first batch.

3. Output format implied, not specified. "Produce a report" produces different structures every time. Now every agent specifies section headings, table column names, and length targets. The outputs are consistent enough to be routed directly into templates.

The library

The result is 71 agents across 13 domains — writing and communication, project management, HR, finance, ESG, sales, IT, legal, and more. Plus an industry pack of 13 agents for EPC and energy sector workflows.

Every agent follows the same five-pattern structure. Every instruction block fits within 8,000 characters. Every agent defaults to British English, supports French output, carries a banned vocabulary list, and runs a quality self-check before delivering.

The full library is on GitHub: https://github.com/kesslernity/awesome-copilot-studio-agents

To deploy any agent: go to m365.cloud.microsoft/chat/agent/new, enter the name and description from the file's frontmatter, paste the instruction block, and click Create. The agent is available via @mention in Copilot Chat within minutes.

No code. No infrastructure. The product is the instruction set.

If you've built declarative agents — in Copilot Studio, CustomGPTs, or anywhere else — I'd be interested to hear what design patterns you've landed on. The instruction-as-product constraint produces different thinking than code-as-product.

Tool to accelerate your Access-to-SQL migration projects (Access - Excel Exporter)

Mon, 12 Jan 2026 21:32:19 +0000

Legacy MS Access Migration: Export SQL, VBA & Forms Instantly

GET THIS TOOL: ⚠️ This is a professional software solution available for purchase.

THE ULTIMATE MIGRATION COMPANION
Are you migrating a legacy Microsoft Access database to SQL Server, .NET, or the Web? Stop guessing what is inside your binary files.
Want to see it in action : Youtube Video

This tool solves the biggest headache in migration: Documentation & Extraction.

Instead of manually copying code or screenshotting forms, this utility instantly "explodes" your .accdb or .xlsm files into clean, organized, and version-controllable text files and images. It handles single files or batches entire folders at once.

WHAT IT DOES FOR MIGRATION:

Generate SQL Scripts: Automatically turns Access Tables and Indexes into SQL definitions.

Visualize the UI: Exports every Form and Report as a high-quality image so you can rebuild the front end in your new system.

Clean Code Extraction: Dumps all VBA modules and Classes into text files for easy porting or analysis.

️ FULL FEATURE LIST:

️ For MS Access: ✅ Export Tables & Indexes (as SQL scripts) ✅ Export Queries, Relationships & Macros ✅ Export Forms & Reports (includes visual snapshots!) ✅ Extract background & control images automatically ✅ Iterate through entire folders of databases (Batch Mode)

For Excel: ✅ Export Standard Modules (.bas) & Class Modules (.cls) ✅ Export UserForms (.frm) with binaries ✅ Auto-Organize exports into separate subfolders ✅ Create ZIP backups instantly

WHO IS THIS FOR?

Migration Specialists moving off legacy Access systems.

Consultants who need to quickly document a client's existing database.

Developers requiring Source Control (Git/SVN) for VBA.

⚡ SYSTEM REQUIREMENTS:

Windows OS

Microsoft Excel/Access Installed

.NET Framework 4.8+

INTERESTED? Don't waste weeks manually documenting legacy code. Save hundreds of hours on your next migration project.

MSAccess #DatabaseMigration #VBA #LegacyModernization #ExcelVBA #SoftwareDevelopment #SQLServer #GitForVBA

How to Enable Long Paths on Windows 11?

Tue, 11 Nov 2025 09:57:20 +0000

Enable Long Paths on Windows 11: Earlier versions of Windows had File path Character Restrictions of 260 characters for compatibility reasons. Microsoft addressed this issue on Windows 10 and continued it to Windows 11 by increasing the file and folder paths to 32767 characters using Long Paths. In this article, we will explore how to enable Long paths on Windows 11 using various methods. Let's get started.

Error 0x80010135 is a Windows File Operation Error that usually appears when we try to extract, copy, or move a file whose path is too long for Windows or the application handling it. Windows limits the path length to 260 characters for compatibility reasons. However, from Windows 10 onwards, you can overcome this error by enabling Long Paths on your Windows Operating System.

Different Methods to Enable Long Paths on Windows 11

Toggle Long Paths on Windows 11 using Windows Settings [GUI]
Turn on Long Paths using the Windows Registry Editor [Regedit]

The most convenient way to enable Long Paths on Windows 11 is to use the Windows Settings.

Toggle Long Paths on Windows 11 using Windows Settings [Recommended Method]

Go to the Windows Settings using the keyboard shortcut WinKey + I.
In the Windows Settings, from the left pane, click on System Settings.
Under System, scroll down and locate Advanced. Select Advanced Settings.
You can find various settings there, including options for the Taskbar, Virtual Workspaces, and File Explorer. Under the File Explorer section, you’ll see an option called “Enable long paths.”
Enabling the Long paths option will remove MAX_PATH limitations from common Win32 file and directory functions. Toggle Long paths to ON.
That’s it! You’ve successfully removed the file and folder path length restriction on Windows 11.

Enable Long Paths on Windows 11 using Windows Registry Editor [Regedit]

If you have any issues following the above method, or if you can't find the option on the Windows Settings, you can use Windows Registry Editor and enable Long Paths on Windows 11. Here are the steps.

Open the Run Command using the keyboard shortcut WinKey + R.
In the Run, execute the following command regedit.
This action will open Windows Registry Editor after User Account Control confirmation.
In the Windows Registry Editor, navigate to the following path HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem
In the main panel, you can find a lot of Registry Values. Locate LongPathsEnabled from the list.
Right-click on LongPathsEnabled and click Modify.
Edit D-WORD (32-bit) value of LongPathsEnabled will pop up now. Change the Value Data from 0 to 1 and then click OK.
Change Value Data to 1 and click OK.
Once the changes are made, it is recommended to restart your system. Kindly save your work and restart your Windows 11 PC.
Long Paths is now enabled using Windows Registry Editor.

Takeaway

Long Paths on Windows 11 breaks down the traditional 260-character limit for file and folder path structures, allowing smooth file operations and better compatibility with modern applications. However, some old programs may still not support long paths on Windows 11.

Active God Mode in Windows 11 using simple steps

Fri, 10 Oct 2025 12:15:51 +0000

The so-called God Mode's actual purpose is to provide access to a comprehensive set of settings (Windows Control Panel and other Settings) using a special GUID-based Shortcut. Perhaps, what we call "God Mode" is just a shortcut to the All Tasks Folder in Windows 11. If you are wondering why it is not explicitly available for normal users and needs to be activated using some special GUID, it is because Microsoft primarily designed this feature for Developers, System Administrators, and Power users.

Enable Mono Audio on Windows 11, and combine Stereo Sound channels into Single channel

Wed, 08 Oct 2025 04:29:20 +0000

How to Enable Mono Audio on Windows 11?

Microsoft offers a wide range of accessibility features on Windows 11, from Mono Audio, Magnifier, High Contrast Mode, to Closed Captions for Videos, Speech Recognition, and more. In the Mono Audio Feature, Windows combines the left and right audio channels (stereo channels) into a single channel. This ensures that users don't miss any part of the audio, making the listening experience clear.

Understanding Mono Audio on Windows 11

Actually speaking, Stereo Audio generally provides a richer and more immersive listening experience as it separates the sounds to different channels and makes us think of music where effects come from different directions. In Mono Audio, the sounds are not separated into different channels, and all channels play the same sounds.

Who Benefits from Mono Audio on Windows 11?

This is an accessibility feature on Windows 11 and is primarily useful for users who need a more inclusive listening experience. It is very useful for people with hearing loss in one ear, or if someone is using only one earbud, in such scenarios, they wouldn't want to miss out on the listening experience.

A Message to our Readers: At Winsides.com, we believe technology should be for everyone. Accessibility features like Mono Audio are just one way Windows 11 helps make digital experiences inclusive and we stand with Microsoft in this important effort. To all our readers with disabilities, your journey matters, your voice matters, and we celebrate your strength every day. You deserve technology that listens, supports, and empowers you.

Different Methods to Enable Mono Audio on Windows 11

Quick Toggle Mono Audio System Tray (Quick Settings Panel)
Enable Mono Audio on Windows 11 using Windows Sound Settings
Turn on Mono Audio using Accessibility Settings

Method 1: Easy Way to Enable Mono Audio on Windows 11 via the System Tray

On the System Tray, which is usually located on the bottom right corner of Windows 11, you can find the Sound icon. Click on that. Alternatively, you can use the keyboard shortcut WinKey + A to access the Quick Settings Panel directly.
Once you click on that, you can find the Accessibility card. Select that.
Under Hearing, you can find the option Mono Audio.
Toggle Mono Audio to ON. That's it. The process is completed.

Method 2: Enable Mono Audio on Windows 11 using Windows Sound Settings.

Open Windows Settings using the shortcut Winkey + I.
From the left pane, click on System.
You can find various system-related settings here. Select Sound Settings.
Under Output, you can find the option Mono Audio.
Toggle Mono Audio to ON. Once the option is enabled, it will combine the left and right audio channels into one.

Method 3: Turn on Mono Audio on Windows 11 using Accessibility Settings

Go to the Windows Settings using the keyboard combination WinKey + I.
In the Windows Settings, from the left pane, click on Accessibility.
Scroll down to Hearing, and select Audio. Here, you can find the option Mono Audio.
Toggle the switch to turn on Mono Audio on your Windows 11.

Take Away

The Mono Audio option in Windows 11 is a simple yet powerful accessibility feature. Microsoft continues to make technology more human, and at Winsides.com, we proudly stand with them in supporting a world where technology truly belongs to everyone.

A new skill

Fri, 19 Sep 2025 12:49:20 +0000

I’ve been quiet for a while… and here’s why: I dedicated myself to learning a new skill. "Transcription".

Over the past few weeks, I immersed myself in mastering the art of converting audio and video into accurate, professional text. It wasn’t just about learning the tools, it was about dedication, consistency, and focus.

Before this, I already had experience with MS Word, Excel, and other essential professional skills, but I realized that what really matters is the commitment to keep learning and growing. With discipline and persistence, I’ve added transcription to my skill set, making me ready to deliver high-quality, reliable work to clients and employers.

I’m now available for hire and excited to apply these skills to meaningful projects. If you’re looking for someone precise, diligent, and dedicated, let’s connect!

Transcription #SkillDevelopment #ProfessionalGrowth #MSWord #Excel #AlwaysLearning #Dedication #AvailableForHire #Freelance #RemoteWork

How to Upgrade to Windows 11: Compatibility, Steps, and Solutions

Tue, 15 Jul 2025 21:01:08 +0000

In this article, discover how to seamlessly upgrade to Windows 11, ensuring your PC stays secure and up-to-date. Learn the steps, check compatibility, and explore options if your device isn't eligible!

Why Upgrading to Windows 11 Matters

As of October 14, 2025, Microsoft will no longer support Windows 10. If your computer uses the Windows 10 operating system, it will no longer be supported. This means that security updates, feature updates, technical support, and more will cease, leaving your PC vulnerable.

FREE Windows 11 Upgrade

If your computer already has Windows 10 with a valid license and meets the minimum system requirements for Windows 11, you can upgrade for FREE!

The official documentation on Microsoft's website provides a comprehensive guide to checking whether your computer meets the system requirements.

The Easiest Way to Upgrade to Windows 11

Using Windows Update on your computer is the easiest way to upgrade to Windows 11.

To Access Windows Update, Click:

Start
Settings
Update & Security

In Update & Security, run Windows Update. Once your computer receives all the required updates, you should see a “Download and install“ button to upgrade to Windows 11, if it’s not already displayed.

Be sure to read and follow all of Microsoft’s prompts and documentation to ensure a smooth upgrade from Windows 10 to 11.

If You Don’t See an Upgrade Option

After running Windows Update, if you still do not see an option to upgrade to Windows 11, you can use Microsoft's official PC Health Check App.

Next to the “Download PC Health Check app“ button is a helpful link to Windows 11 system requirements.

If Your Computer Fails The Compatibility Test

Unfortunately, if your computer fails the compatibility test, you will not be able to upgrade it to Windows 11. If you want to ensure that your computer continually receives security updates, feature updates, technical support, and more, you will need to consider buying a new one with Windows 11 installed, or if you’re adventurous, you can alternatively build a PC and purchase a Windows 11 license.

My main home laptop doesn't meet the requirements because of the processor. Luckily, I already own another laptop that came with Windows 11 preinstalled, which will now be my primary device as I retire my older one with Windows 10, since it will no longer be supported.

Be sure to listen to the HTML All The Things Podcast!

???? I also write articles for the HTML All The Things Podcast, which you can read on their website: https://www.htmlallthethings.com/.

Be sure to check out HTML All The Things on socials!

Affiliate & Discount Links!

With CodeMonkey, learning can be all fun and games! CodeMonkey transforms education into an engaging experience, enabling children to evolve from tech consumers to creators. Use CodeMonkey's FREE trial to unlock the incredible potential of young tech creators!

With a structured learning path tailored for various age groups, kids progress from block coding to more advanced topics like data science and artificial intelligence, using languages such as CoffeeScript and Python. The platform includes features for parents and teachers to track progress, making integrating coding into home and classroom settings easy.

Through fun games, hands-on projects, and community interaction, CodeMonkey helps young learners build teamwork skills and receive recognition for their achievements. It fosters a love for coding and prepares children for future career opportunities in an ever-evolving tech landscape.

To learn more about CodeMonkey, you can read my detailed review article!

Affiliate Links:

Advance your career with a 20% discount on Scrimba Pro using this affiliate link!

Become a hireable developer with Scrimba Pro! Discover a world of coding knowledge with full access to all courses, hands-on projects, and a vibrant community. You can read my article to learn more about my exceptional experiences with Scrimba and how it helps many become confident, well-prepared web developers!

Important: This discount is for new accounts only. If a higher discount is currently available, it will be applied automatically.

How to Claim Your Discount:

Click the link to explore the new Scrimba 2.0.
Create a new account.
Upgrade to Pro; the 20% discount will automatically apply.

Disclosure: This article contains affiliate links. I will earn a commission from any purchases made through these links at no extra cost to you. Your support helps me continue creating valuable content. Thank you!

Conclusion

Microsoft will end support for Windows 10 on October 14, 2025, making any PC running that version vulnerable. Upgrading to Windows 11 is FREE and easy via Windows Update, as long as your PC meets the system requirements.

If you don't see an option to download Windows 11 through Windows Update, you can use Microsoft's official PC Health Check app to see if your PC meets the upgrade requirements. If it doesn't, upgrading isn't possible, and you'll need to consider buying a new computer or building one and purchasing an additional Windows 11 license.

Let’s connect! I’m active on LinkedIn and Twitter.

Why Records in C# Are Great (and So Nice to Work With)

Sat, 10 May 2025 20:37:38 +0000

Why Records in C# Are Great

If you’ve been working with C# lately, you’ve probably encountered records , a feature introduced in C# 9 that many developers have come to love.

They’re elegant, powerful, and remove a lot of boilerplate when modeling data.

But what actually makes them great? Here’s why records aren’t just nice , they’re game-changing.

What Are Records?

At their core, records are reference types designed for immutable data modeling. Think of them as classes optimized for holding data with extra features built in.

You can define a record in two main ways:

✅ 1. Positional Syntax (Concise and Clean)

public record Person(string FirstName, string LastName);

This one-liner gives you:

Constructor
Equals(), GetHashCode(), and ToString() overrides
init-only properties (immutable)
Deconstruction support

Ouaaa...

In order to implement all that in a regular class, you'd need to write a lot of code constructors, equality logic, ToString() overrides, and possibly even a deconstructor.
Records do it all for you, automatically and cleanly.

✅ 2. Classic Syntax (More Flexible)

public record Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

Need mutability? You can use set instead of init, but that sacrifices immutability and thread safety.

What is init?

init is a special accessor introduced in C# 9 that allows properties to be set only during initialization making them immutable afterward.

var person = new Person { FirstName = "Alice", LastName = "Green" };
// person.FirstName = "Bob"; ❌ Not allowed

✅ Cleaner than readonly fields
✅ Safer than public setters
✅ Perfect for records, DTOs, and configuration objects

Reference:
Microsoft Docs – Init-only Setters

✅ 1. Value-Based Equality — Finally Done Right

With classes, equality checks compare references. With records, it's based on content:

var a = new Person("Alice", "Smith");
var b = new Person("Alice", "Smith");

Console.WriteLine(a == b); // True ✅

Reference:
Microsoft Docs – Records

✅ 2. Immutability by Default — and Thread-Safe by Nature

Records are immutable by default, which leads to safer, more predictable code.

var p1 = new Person("John", "Doe");
var p2 = p1 with { FirstName = "Jane" }; // Creates a copy

And since their state can't be changed after creation, records are thread-safe for read operations — perfect for:

Parallel tasks
Background services
Blazor state containers
Event sourcing

Reference:
Immutability in C#

✅ 3. Concise and Readable Code
Records eliminate boilerplate. You define what matters — and the compiler handles the rest.

public record Invoice(string Id, DateTime Date, decimal Amount);

Clean. Lightweight. Clear.

✅ 4. Deconstruction and Pattern Matching

Records play perfectly with modern C# features:

var (first, last) = new Person("Ana", "Lopez");

if (p1 is { FirstName: "John" })
{
    Console.WriteLine("Hello John!");
}

Reference:

Pattern Matching in C#

✅ 5. Functional Programming Friendly

Records align with functional principles:

No side effects
Easy transformations
Clear data flow

var updatedInvoice = invoice with { Amount = invoice.Amount + 10 };

Reference:

Welcome to C# 9 – Records

✅ 6. Supports Inheritance, Structs, and More

You’re not locked into one pattern:

record struct — value-type records
readonly record struct — fully immutable
Abstract and sealed record inheritance supported

Reference:
What's New in C# 10 – Record Structs

Records and the Value Object Pattern
In Domain-Driven Design (DDD), Value Objects are small objects that:

Represent a concept (e.g., Money, Email)

Are immutable
Have no identity
Compare by value

✅ Records Are Ideal for Value Objects

public record Email(string Address)
{
    public Email
    {
        if (!Address.Contains("@"))
            throw new ArgumentException("Invalid email");
    }
}

You get a clean, reusable object with built-in validation and equality , no fuss.

public record Money(decimal Amount, string Currency);

public record Product
{
    public Guid Id { get; init; }
    public string Name { get; init; }
    public Money Price { get; init; }
}

Reference:
Martin Fowler – Value Object

When Not to Use Records

Avoid records if: