The stack Microsoft is building under your feet

Microsoft is replacing the .pbix-based Power BI development workflow with a text-first stack: TMDL for human-readable model files, PBIP for folder-based project structure, Git for version control, and AI agents via the Power BI MCP server. This issue explains what each layer does, how they connect, and why Power BI developers who understand this stack now will have less catching up to do as it becomes the default

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.

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.

Microsoft is retiring the old Excel and CSV import experience in the Power BI service. Legacy semantic models stop refreshing on July 31st; the experience stops opening entirely on August 31st. On its own, a minor migration task — check whether you're affected, recreate the semantic model if so, move on. As a signal: informal file-based workflows are quietly being deprecated in favor of something more structured.⁵

Microsoft released an MCP server that lets AI agents connect directly to a Power BI semantic model — read its structure, add descriptions, write measures. Tabular Editor documented this in detail. It's experimental territory, but it's the infrastructure the AI section of this issue describes now becoming real. Worth knowing it exists before you need it.⁴

The Fabric CLI — command-line access to workspace management, lakehouse operations, and scriptable deployments — moved from preview to GA. One-command workspace deployments, Power BI scenario support, and pre-installed in Fabric Notebooks. If PBIP and Git are the model-level workflow, the Fabric CLI is the workspace-level equivalent. The developer stack now has a proper command-line interface.⁶

Tabular Model Definition Language (TMDL) overview — The authoritative reference for the format this issue introduces. Read the object model section once to understand how tables, relationships, and roles are represented. (Microsoft Learn)

AI agents that work with Power BI semantic model MCP servers — The Tabular Editor team's documentation of what the MCP server can actually do. Concrete, practitioner-level. The right starting point if you want to try this. (Tabular Editor Blog)

The stack isn't hypothetical. It's already shipping. The developers who understand it early will have less catching up to do later.