The stack Microsoft is building under your feet

You have a workflow. It works. You open Desktop, build a model, write some DAX, publish to the service, and move on. Maybe you keep a backup .pbix on a shared drive. Maybe you've been meaning to.

Microsoft is building something underneath that workflow. And it doesn't look like Power BI. It looks like software engineering.

Here's the problem with a .pbix file: it's a binary. You can't read it, you can't search it, and you definitely can't compare two versions of it side by side. If you and a colleague both need to change the same model, the workflow is essentially "talk first, share the file, hope for the best." It's fine — until it isn't.

Tabular Model Definition Language — TMDL — is what happens when Microsoft decides that's not good enough. Save a model in TMDL format and every object in it becomes a plain text file. One file per table. One for relationships. One for roles. Your Sales table's measures live in tables/Sales.tmdl. Your calculated columns are right there in the same file, readable without opening Power BI at all.

It's readable, editable, and — the word that matters here — diffable. Meaning: you can look at two versions of the same file and see exactly what changed between them, line by line.

That's a small thing that turns out to be a big thing.¹

TMDL is the format. The Power BI Project — PBIP — is how you use it. Save your report as a .pbip instead of a .pbix and Desktop writes your model out as a folder of TMDL files instead of a single binary blob.²

That folder can go into Git.

If you haven't used Git before: it's the version control system that software teams use to track every change to their codebase over time. Who changed what. When. Why. It lets you branch off to try something risky without touching the main model, and roll back to any prior state if things go sideways.³

For a Power BI developer, it means this: you change a measure, save, and Git records that change. Before and after, line by line. You can work on your piece of the model while a colleague works on theirs, then merge the two together. You get a real audit trail — not "I think I updated this last Thursday" but a permanent, searchable record.

That's not how most Power BI developers work today. Give it a few years.

Because TMDL is plain text, AI can read it and write it. Microsoft released a Power BI modelling MCP server — a tool that lets AI coding agents like Claude Code or GitHub Copilot connect to a semantic model, explore its structure, and make changes to it directly.⁴ Add descriptions to every measure in the model. Rename a column and catch every downstream reference. Generate a full set of time intelligence measures from scratch.

The agent reads the model. Does the work. Writes the changes back.

This is early. AI agents are imprecise, they burn through context fast, and when something goes wrong it's hard to see exactly what changed. Which is exactly why the section above this one isn't optional. If you want to experiment with AI-assisted development, PBIP and Git aren't a nice-to-have — they're the safety net that makes any of it responsible to try.

But the shape of where this is going is clear. The text-based format isn't just about version control. It's the foundation that makes the AI layer possible at all. You can't hand a binary file to an agent and ask it to help you.

Microsoft is retiring the old Excel and CSV import experience in the Power BI service. Legacy imports stop refreshing on July 31st. By August 31st, they stop opening entirely.⁵ On its own that's a minor migration task — check whether you're affected, recreate the semantic model if so, move on.

As a signal, though, it fits the pattern. Informal file-based workflows are quietly getting deprecated in favor of something more structured. The .pbix-on-a-shared-drive approach isn't being ripped away, but the direction of investment is obvious.

None of this requires action today. PBIP projects are still in preview. Most Power BI developers aren't using Git. AI-assisted development is genuinely experimental territory.

But the stack is taking shape: human-readable model files, version control, AI tooling on top. Microsoft is building it whether or not you're paying attention.

Better to pay attention.

Next issue: what TMDL actually looks like in practice — and how to get a PBIP project set up for the first time.

Sources

If you work with anyone trying to make sense of where Power BI ends and Fabric begins — this is worth a forward.