Nobody writes assembly anymore.

We write C# or X++, a compiler turns it into MSIL, and the runtime turns that into processor instructions. Several abstractions away, registers get managed and memory gets allocated, and almost none of us think about any of it. We trust the compiler. We haven’t validated its output in years. ‼️

Trust is what made each jump possible. Every time programming moved up a layer, the layer below became something you stopped looking at. Machine code gave way to assembly. Assembly gave way to C. C gave way to managed languages and garbage collection. At each step the work got more abstract and humans moved further from the hardware.

AI is the next step up. Your prompt is the new source code, and the AI is the compiler that turns it into working software. Similar to how C# or X++ it produces is the new MSIL: an intermediate artifact on the way to something that runs.

The part that’s uncomfortable

If the prompt is the source code, then the generated code is something we will eventually stop reading, the same way we stopped reading assembly. We are not there yet. But the direction is set. We are heading toward dark code, software running in production where no human reviewed the lines.

That sounds reckless until you remember you already ship code no human reviewed at the MSIL level. You trusted the compiler to get it right. The only question is when we extend that trust one layer up.

The determinism objection

The usual pushback is determinism. A compiler is deterministic. Same input, same output, every time. AI is not. Ask it twice and you get two answers. So how can it be a compiler?  The part that turned non-deterministic is the act of writing the code. The code itself runs the same as ever. The AI generates X++ that executes identically on every run, an artifact as deterministic as anything a human wrote by hand. We traded a deterministic author for a probabilistic one, and the output still compiles down the old, reliable way.
The open question is whether we will trust a probabilistic author the way we trusted a deterministic compiler for forty years.  But we’ve also trusted the developer with three years of experience.  In both cases, a code review is recommended today.

Where developers go next

When we stopped managing registers, we did not lose our jobs! We became architects of higher-level systems. The work moved up the abstraction ladder and we moved with it. The skill that mattered changed from “can you manage memory” to “can you design a system.”  Not only that, but the ability to write software faster meant we were writing more software, not less.

It is about to change again, from “can you write the code” to “can you specify the intent and judge the output.” That second skill is harder than it looks, and it is the one worth building now.

What this means for D365 work

For Dynamics 365 consultants this is real and it is close. The skills exist today. AI can build a Dataverse data model (Dataverse skills). It can write X++, JavaScript, HTML, and CSS. You can build agents in Copilot Studio and Azure AI Foundry without writing the plumbing by hand.

The consultant who knows how to direct these tools will deliver in a day what used to take a week. The one who doesn’t will be competing against the ones who can.

Start now. Not next quarter. Open Copilot Studio and build an agent. Point an AI at a Dataverse model and watch what it produces. Get comfortable directing the work instead of typing all of it. Future job postings will list Cowork and agentic coding the way they once listed Excel, and that shift is arriving faster than the last one did.

The compiler already took the work you used to do by hand. AI is the next compiler.