In this article 7 sections
Can an AI agent design a proper data platform in Microsoft Fabric if you only tell it what you want and stay out of the technical decisions? I gave Claude Code a spoken brief for a metadata-driven medallion platform on two sources, and it came back with an architecture document and a phased build plan I didn’t write a single line of.
This is part two of my Fabric AI platform series, where Claude has to build a data platform from scratch without me touching the code or the decisions. In part one I set up a clean macOS virtual machine with Claude Code, Python, Git, the Fabric CLI, the Azure CLI and a whole bunch of Fabric and Power BI skills. This time Claude gets the brief, but nothing gets built yet: this is the architecture and planning phase.
The brief
The end result I’m after: Claude designs and builds a Fabric data platform from start to finish, without me writing any code and without me interfering with what it does. So I ask for end results, not technicalities, and I try not to steer. I’ll admit I was a little bit scared of what Claude would be able to do here.
I opened the fabric-ai-platform repository in the terminal, started Claude Code and dictated the brief from my script. The platform reads from two sources. AdventureWorksLT on an Azure SQL database has customers, products and sales orders, and Moneybird, a Dutch accounting package with a REST API, has matching customers and invoices. I want to analyse sales and invoices together in Power BI, on a landing zone, bronze, silver and gold, with a semantic model on top.
Anything repeated has to be metadata driven. I don’t want to see a repeat-yourself pattern in pipelines, notebooks, queries or anything else Claude builds. It should use Fabric tooling as much as possible and keep manual UI work to a minimum. Everything goes into one new workspace called TFG AI Experiment, in the tenant it logged into before, so no separate bronze, silver or gold workspaces.
Moneybird needed a warning. The token Claude already has is for my actual live account, so it keeps its hands off that one. It gets a test account later and has to come up with a safe way to store those credentials. I deliberately didn’t steer it there. The last part of the brief was a plan to keep the Fabric items in the repo and sync them both ways with the workspace. Claude is free to use the Fabric CLI later, just not now.
I didn’t type a thing. I don’t really like typing; these days I’d rather talk to my computer. Wispr Flow didn’t see the terminal as somewhere it could paste into, so I copied my transcript from Wispr Flow and pasted it in. I wrote up how I use it in stop typing your AI prompts. One dictation slip did make it into the prompt: I said “semantic model” and Wispr Flow wrote “cementing wall”. Remember that one.
Claude’s first pass
After a little over six minutes Claude came back with docs/architecture.md (the design, with a decision log of the alternatives it rejected and why), docs/plan.md (open questions, early experiments it calls spikes, and eight build phases) and a “First mission” section in the README. It hadn’t touched Fabric, Azure or Moneybird. Everything was still on paper, which is exactly what I asked for.

Lakehouses and metadata
Claude suggests one lakehouse per layer (landing, bronze, silver and gold) plus a separate control lakehouse for the metadata, run log, watermarks and data-quality results. That makes five lakehouses. I would have gone with one, but it’s not that I know everything, so let’s see where it goes.
Every source and table is described in YAML in the repository. I like that, and I’ve never done it this way. I usually put metadata in JSON files in the lakehouse, or in a notebook that writes it to a table I loop over, like in metadata-driven processing with notebooks. With YAML in a repo you can deploy your metadata, and I’m curious where Claude takes that.
One engine per layer
Each layer has exactly one engine, in a tested Python package, and the notebooks only call it. So Claude is writing its own Python package. One generic pipeline loops over all SQL tables with a single Copy activity, and one REST notebook handles every Moneybird endpoint. Each gold table is one SQL select, with surrogate keys, unknown rows, SCD1 and SCD2 history and the merge handled generically, so there are no per-table notebooks.
In DAX, a calculation group handles time intelligence so measures aren’t copied per period. And the final proof: adding a new source table must take only a YAML change. Yes, very much yes.
Engines and credentials
Azure SQL comes in through a Copy activity, and everything else runs in Python notebooks (DuckDB, Polars, delta-rs) instead of Spark, because the data is tiny and the capacity is an F2. That’s really smart.
The Moneybird token lives in Azure Key Vault, and Azure SQL uses the workspace identity, so it needs no password. A live-account guard stops the ingestion unless the token can see only the allow-listed test administration. Claude also recommends I create the Moneybird token myself and put it in Key Vault straight from my terminal, so the credentials never pass through the chat or end up in the conversation history. That’s really good, and the smart thing to do.
Git sync in both directions
The workspace syncs with main on the /fabric folder. Local changes go through a pull request and then tools/sync.py pull; changes made in the Fabric UI go back to the repo with tools/sync.py push. Both call the Fabric Git REST API, so there’s no clicking, and the script stops if both sides have changed.
Six clarifying questions
Claude also asked six questions it needed answered before the build phases. None of them blocked the design. They’re good questions, and it came up with them on its own.

| # | Question | My answer |
|---|---|---|
| 1 | Does the AdventureWorksLT database exist? | Not yet. I’ll create it when we start implementing. |
| 2 | Can it create a resource group and Key Vault? | Yes. |
| 3 | Can it use capacity tfg01 and resume and pause it? | Yes to both. |
| 4 | Does the Moneybird test data match AdventureWorks? | Customers match on customer number. Invoice references and sales order numbers don’t, so only customers reconcile. AdventureWorks is in US dollars and Moneybird in euros; for this test, treat both as euros. |
| 5 | Is the repo public? | I wasn’t 100% sure, so assume it’s not. |
| 6 | Is “cementing wall” the semantic model? | Yes. |
Wispr Flow made a little mistake there, but Claude worked with it. It assumed I meant the semantic model and checked with me, and it was right.
What changed after my answers
Claude updated both documents and summarised what my answers changed.

The biggest change came from question four. Invoices don’t refer to sales orders, so reconciliation is now per customer and per period instead of per order. Claude dropped the order-to-cash fact table it had planned and compares sales and invoices through the shared customer and date dimensions. The report page becomes “Customer reconciliation”: sales vs invoiced vs paid per customer and month.
Customers that don’t match on either side show up on a data-quality page instead of disappearing. The euro assumption is a setting in the AdventureWorks metadata, so real exchange rates later only mean adding a rate source. That left three open questions. Yes, I’ll put the Moneybird token in Key Vault myself. Yes, sync with main on /fabric. And refresh daily, for general management.
The architecture document
It’s a very big document, so I didn’t go through all of it on camera. The requirements cover everything from my brief, down to the single workspace with all items grouped in folders (smart) and separate test and live Moneybird accounts (very, very important). The high-level picture is a Mermaid flowchart, which I can’t read as source, but the item list below it is clear:
| Folder | Items |
|---|---|
00_platform | vl_platform (variable library), env_platform (environment with Claude’s own tfg_platform package), lh_control (metadata and control tables) |
10_storage | lh_landing (files only, raw and immutable), lh_bronze and lh_silver (schema per source), lh_gold (star schema) |
20_pipelines | pl_orchestrator (the end-to-end run), pl_ingest_sql (a generic ForEach with a Copy for any SQL entity) |
30_notebooks | nb_plan, nb_ingest_rest, nb_load_bronze, nb_load_silver, nb_build_models, nb_maintenance, all Python notebooks |
40_serving | sm_sales_invoicing (Direct Lake on lh_gold), rpt_sales_invoicing (the Power BI report) |
nb_maintenance stood out: a metadata-driven notebook for optimize, vacuum and landing retention. I never asked for that one, but apparently Claude is smart enough to know Delta tables need maintenance.
The phased build plan
The plan opens with working agreements. One of them: creating Azure or Fabric resources, running pipelines and anything that touches Moneybird all need my approval. Phase 0 collects my answers and runs six spikes, small throwaway experiments that confirm how Fabric behaves before the design relies on it. Then come eight build phases, each with a concrete test for when it counts as done:
| Phase | Done when |
|---|---|
| 1. Foundation | A notebook change made locally shows up in the workspace, and a change made in the workspace shows up in Git |
| 2. Framework core | The orchestrator runs with an empty scope and logs a run, with unit tests for the planner and query generation |
| 3. AdventureWorks to bronze | A full and an incremental load both succeed, bronze row counts equal the source, and no PasswordHash column exists anywhere in OneLake |
| 4. Moneybird to bronze | Counts match the test administration, a second run fetches only changed records, and a wrong administration ID aborts before any data request |
| 5. Silver | Running it twice changes nothing, and a record deleted in Moneybird gets flagged as deleted |
| 6. Integration and gold | Gold totals reconcile with the sources and an SCD2 change creates a new dimension version |
| 7. Semantic model and report | The report shows sales vs invoiced vs paid per customer and month, matching the reconciliation queries |
| 8. Operate | A daily early-morning run works for a week without intervention, and adding a source table takes a YAML change only |
Phases 3 and 4 can run in parallel once phase 2 is done. That makes sense. I didn’t change anything in the plan; I’m quite happy with what Claude came up with.
Where Claude’s choices differ from mine
Claude hasn’t created anything yet, but the architecture and the plan look really solid. It made two choices I wouldn’t have made on a platform this small, and one I’m keen to see in action.
The first is five lakehouses where I’d probably have gone with one. Claude’s reasoning in the document: layer boundaries stay visible, permissions can be set per layer (report users only need gold, through the model), and Direct Lake binds to lh_gold alone, while schemas still separate the sources inside bronze and silver.
The second is Python notebooks. I would have gone with Spark, but Python might be the smarter choice here, because Python notebooks are really quick and really cheap on small data. And this data is small: according to the document, fewer than 1,000 order lines in AdventureWorksLT and a few hundred Moneybird invoices.
The third is the metadata in YAML, and that’s the one I’m most keen on. I want to see the metadata go from YAML to deployed to running, because that loop has to be closed.
I teach you something about Microsoft Fabric every week, but here Claude is teaching me.
One dictated prompt and a handful of answers got me a design I’m happy with, plus a few ideas I’ll learn from myself. I’ll pass those on as we go. In the next part of the series, Claude starts working through the plan and builds the first pieces of the platform.