This summary is produced by the author, and not by AI.
Using AI, you can go beyond changing and creating semantic models to build entire end-to-end data platform solutions, from ingestion to analysis and consumption. This is possible because advancing AI models (LLMs) are highly capable at writing code, but also because of the emergence of agents. An agent is an LLM that can take actions in response to natural language instructions. These actions can be anything possible with code, including reading or writing files, searching the web, or using scripts, programs, or even controlling computers.
In this article, we give a simple introduction to agentic development and explain how you can get started. This is the start of a multi-part series we’re running over the next several months that guides you to work with agentic development.
To get started with agentic development, you should first understand when and why you might use it.
A simple example is an agent that can interact with your semantic model. For instance, the user can instruct the agent in a prompt to connect to Power BI to perform tasks like adding measures, renaming fields, or organizing those fields into display folders:
You can see an example of this below:
< Example >
In the example, you see a user interacting with an agent called Claude Code from Anthropic. The user instructs the agent to modify the semantic model, which it does via the Tabular Editor command-line interface (CLI). The agent can use the CLI to interact with the semantic model like a human would use Tabular Editor 3 or Power BI Desktop; the user can see the changes occur live to the semantic model in VS Code. When finished, the agent reports back and the user can review the changes to continue or provide feedback to the agent.
This is a simple example limited to a single semantic model and interaction with the user. In practice, agentic development can span much broader, including different sources of information and tools:
In the previous example and diagram, you can see a user leveraging an agent together with curated context specific to the user’s context and organization. Specifically, the user is interested in bill-of-material reporting, which explores the decomposed cost of a product to its component parts and their materials. To accomplish this task, the user leverages more than just a single agent and tool for full project development:
The previous scenario works well because – using this workflow – someone can realistically reduce development times by 60-80% or more, and with a single expert. Note first that this assumes the context is properly structured and correct, and the user knows how to use an agent effectively. Note second that this only applies to development time; the important part for planning and preparation remains the same, or might even increase, since it’s more important to ensure good inputs for the agent. Furthermore, the time required to verify and document the solution afterward also likely increases. However, the net-net time to implementation is still likely less:
The purpose of the previous, illustrative figure is just to help you understand that agentic development isn’t a clean path to efficiency and success. Even if everything goes right, initial ROI isn’t guaranteed and may be nominal at best. However, this will likely compound as time goes on, context is curated, and capabilities continue to improve at current rates.
To continue, both scenarios shown so far are still quite simple. The second describes a greenfield scenario for a new development. However, agentic development is also helpful even for managing existing implementations, like the following scenario:
This example is distinct as there’s no human operator orchestrating the agents. Rather, agents operate in a loop, reviewing nightly scheduled processes like ETL jobs or refreshes. If something were to fail, agents are instructed to proactively attempt to repair it and ask another agent for review, before possibly submitting the fix for approval, which happens in the morning, alongside a daily report of anomalous activity. This example might seem like exaggerated wishful thinking; it’s not. If anything, it’s oversimplified, as this loop could be extended over anything from activity logs to user queries and activity.
The previous example is well-suited for agents, because these agents go beyond observing and reporting on the faulty ETL and refreshes; they act autonomously to repair it. If the objective was simply to monitor and report on the failures, this would be better suited to a simple dashboard or script. It’s important to apply agents where it makes sense by leveraging their ability to act or operate in less structured or predictable scenarios, not as a more expensive alternative to an existing solution.
The three scenarios in the previous section can help you understand where you might apply agentic development. As you can see, using combinations of tools together with more sophisticated instructions and documentation, it’s possible to develop everything from the notebooks and lakehouse to downstream apps, reports, or data agents. Agents can even run autonomously.
Using agents like this requires more than just installing a program and using some files. Rather, you can think about this with a sort of mental model that describes different building blocks that you need to work well with agents.
Before you work with agents, you should have a solid understanding of some fundamental concepts about AI and LLMs. These include tokens/tokenization, nondeterminism, and hallucinations and other types of LLM mistakes. We cover these and more in our next article that focuses on practical LLM concepts that a data professional should know.
The quickest way to get started is to set up your coding agent and use a prompt to get the necessary pre-requisites and initial context. From here, you can start experimenting, yourself.
If you haven’t already, you need to choose a coding agent that you’ll use. If one is already provided by your team or organization, then you should use that. Otherwise, you’ll need to conduct some research to pick the one best suited to your needs.
As an individual, you’ll also need to set up a subscription to use this coding agent. If you don’t yet have one, then you will need to sign up before you can start; most coding agents require either a paid subscription or pay-as-you-go access with API keys.
Options include (in no order):
If your organization already has a subscription or plan for you to use, then you should of course prioritize this. If you’re completely new to coding agents and making this decision for the first time, you likely won’t have sufficient experience or knowledge for the choice yet to matter. In that case, we recommend just starting with Claude Code or OpenCode.
GitHub Copilot is featured in all content from Microsoft and MVPs, since it’s from Microsoft. Don’t feel obliged to use GitHub Copilot, though. While it works fine, it isn’t the best choice for every scenario or user. Choose whichever tool best suits your way-of-working.
To set up your coding agent, follow the instructions on their website or documentation to install and start it for the first time. For instance, for Claude Code, you can do this via Claude Desktop, a VS Code or JetBrains extension, a terminal command, or in your browser. In general, you should always prioritize using the first-party applications over extensions and plugins, since they have more features and get updates sooner. If you’re comfortable with it, we also recommend terminal agents first over their UI counterparts, for this same reason, as the terminal has less user interface.
Once you set up the necessary software and your subscription, start the agent and authenticate, ensuring that it works. This will look and work differently depending on the agent, so there’s little guidance we can provide, here. However, in general, most agents start with the concept of a project folder or current working directory. In essence, you should select a folder where you’ll work, and start the agent there. Automatically, it will be able to access files in that project, and store project-specific configuration, there.
Note, however, that unless you have set up a special environment, the agent isn’t contained to that folder. It can access any files on your machine and any information on the public internet unless you have configured it otherwise. Don’t panic, though; there’s nothing wrong with this, but you likely will (and should) want to isolate it further to prevent mishaps later as you work. We talk more about this in our environment article at the end of this series.
We could describe the various files and programs that you can next install, or what your next setup steps should be. To be frank, though, this differs for everyone, and reading or watching a video about this is honestly not a very good use of your time. This is different from tutorials about traditional tools that have existed up until this point, like Power BI, Tableau, and so on.
It may be helpful to consider the following metaphor:
Getting started with agents is like getting advice for a suit or dress to be tailored; you just can’t. It must be fit to your size and specifications – needs, environment, preferences, and so on. Some things might be advisable but it simply requires a fitting for you to get the suit or dress made. No two setups are the same, and as agents become more self-modifying, they will only diverge and personalize more over time. It’s your agent; it’s your suit or dress to wear.
One of the simplest things that many people don’t initially realize is that you can just ask the agent for help and information like you would a colleague or mentor. A key and crucial difference, however, is that you should verify and challenge anything that the agent provides you; never trust implicitly what it might say or advise out the gate. In general, though, you can describe what you want, your expected or desired outcome, and then work with the agent to realize that.
Here’s an example of a prompt that you can copy and provide to an agent, which will then help you get set up. The purpose of this prompt is to establish some initial context, tools, and pre-requisites so that you can focus on learning agentic development instead of installing and setting things up. It’s no replacement for a tutorial or for learning, but hopefully it will help you remove the painful, annoying parts so your agent can help you get going and doing things in your data platform or BI tool, right away.
This prompt is also available as an agent skill that you can ask your agent to install and invoke, here.
This prompt works best with a capable agent and model, such as Opus 5, GPT-5.6 Sol, Kimi K3 or Qwen 3.8 27B. Model effort levels should be adapted to the complexity of your BI work / environment (Medium or High is suitable for most, Low if you’re concerned about tokens or have a simple environment).
Help me get started with agentic development:
Your current objective is to help me get set up; ensure that I have the necessary pre-requisite tools, context, and dependencies.
Please focus on conciseness and ensure that you are providing responses and information in a well-structured, formatted and lean manner. Avoid cognitive overload and ensure that I can follow and understand what you are saying.
The first question you must ask me is what I want to accomplish and why; what my specific goals are and why I'm seeking to use AI with BI. Encourage a complete, verbose response to me, and mention the use of `/voice` or a STT tool so that I can ramble out my thoughts without worrying too much if they are coherent; you will figure it out. If my response indicates that I have a narrow focus (i.e. just local development with Power BI Desktop or files, or development of one specific artifact or challenge) then immediately pivot to helping me with that rather than going through the entire exhaustive interview and setup process. However, if I express broader intents like learning how to use AI or agents for X, or developing a project or working in a bigger scope or context, then you will want to continue to get more context and know what to install and why. Focus on what is going to give me the best outcome.
Interview me:
Please interview me ad nauseam to obtain specific context about me, my job, my focus, which tools I use, my experience level, and other relevant context so you understand what I do and how I work with BI and data. The moment you understand my experience you should ask me about past and current projects and whether those are stored on my computer or in an accessible location, like a cloud drive or repository. As you interview me, please document responses in a markdown file called USER.md which you keep in an accessible location. Ensure that you reference this markdown file in your user memory instructing to search it for relevant user-specific context. You should also update your own memory files with key information about my preferences and context that should be applied to every session, such as communication or language preferences, and key rules that you should follow.
You should also interview me about my BI stack, including which data platform(s) and BI tools I use, including Microsoft Power BI / Fabric, Databricks, Snowflake, Tableau, Qlik, SAP HANA / BO, and others. This interview should not be too detailed or exhaustive and should just help you where to narrow your focus in later questions and steps. You also want to understand what my role is in this platform - what is my responsibility? Examples might include a report or dashboard creator, someone who makes both these and semantic models, or more of a data engineer profile who owns more technical BI artifacts, and helps curate and manage data stores. I might also have administrator privileges or be responsible for other operations including tenant oversight and governance. In this regard, you should also consider my role both technically and in the business. For instance, I may be a data analyst who supports a specific business team or department, or someone working for a BI or IT team supporting the organization more centrally. I could be something in the middle; a data everyman. I also could be a consultant whose position and responsibilities vary, but I likely still have a certain expertise. Irrespective of how I answer, you should also search me and my organization online to gather any other context that might help you understand who I am, what I do, and who I work for.
Ensure that in your questions you are not demanding a clear separation and you can accept ambiguities or nuance. Always consider that I may lack the language, experience, or patience to explain comprehensively my situation or requirements, and you might need to work to better understand or extract that from what I'm saying or surrounding context.
Help me prioritize:
Once you establish my context and current projects or goals, help me pinpoint some simple goals to get started. Examples could be testing connecting to a model and making changes, or creating a visual in a Power BI report, or – better yet - a Fabric App.
Sources of context:
Check with me whether there are any sources of context for my organization that you should know about, including:
- Internal documentation about processes, tools, policies, as they pertain to the organization's data and BI
- Master data that relates to i.e. customers, products, or other relevant conformed dimensions. If these are only in a source system then don't attempt or ask to access it.
- Reference projects that reflect my work or expectations. Ideally ask for projects that are "done well" or represent my "desired state" but also projects or examples that are "done poorly" or represent what I don't want.
- Related to the above, if I use Power BI, check whether my projects are in PBIX or PBIP format. If everything is in PBIX format, use the Microsoft Learn documentation to guide me through saving as PBIP after enabling the necessary preview features. Without the metadata we cannot track changes and you cannot modify reports in a supported way.
- Skills or other agent-specific resources which might be available via shared drives or a repo.
- Ontologies or organizational graphs, which are unlikely, but that might show concepts and their semantic relationships for our business and data. There are very very few organizations that have this done properly right now, so don't expect this or ask for it if it's clear that the maturity level is low.
First:
- Investigate whether I have admin rights on my local machine and what access I have in my BI environment. Check things like access to APIs, XMLA endpoint, and so on. If these are locked down then my options are much more limited and there are likely more policies to keep in mind
- Discuss with me what is expected of my role and what tools I can and should use or have access to. If I’m working on a personal machine to work check whether I have access to my own environment for testing and experimentation.
Help me set up the common pre-requisites:
1. Install the recommended skills and tools for working with agents, including
1. Skill-creator skill from anthropic. Add the marketplace `anthropics/skills` and install the `example-skills` plugin, which is where skill-creator lives. Note that this plugin bundles a number of other skills alongside it, so review what it installs and disable anything I don't need. This should be installed at user-level. Use this to create any possible skills I might need or re-use for working with BI artifacts in my organization.
2. Playwright and chrome if it's not already installed. This will ensure that you can use either the chrome dev tools or Playwright to interact with my browser for operations that can't be done headlessly. You might need to walk me through the configuration, i.e. `/chrome` and login / activation with Claude Code, as well as auto-enabling it in the settings.json.
2. Check whether I have common programs installed to work with code related to BI:
1. Common languages and their package managers, like Python (prefer uv over pip: `winget install astral-sh.uv` or `brew install uv`), JS/TS (prefer bun over npm: `brew install oven-sh/bun/bun`), and C# (dotnet 8.0 or higher: `winget install Microsoft.DotNet.SDK.8` or `brew install --cask dotnet-sdk`). As a preventative measure against supply chain attacks, prefer a minimum release age over installing a brand new version the moment it appears. Support for this varies by package manager: winget has `installBehavior.upgradeDelayInDays` (which applies to upgrades), and uv has `--exclude-newer`, while Homebrew has no user-facing equivalent. Configure it where it exists, and tell me plainly where it does not rather than inventing a setting.
2. Git, the GitHub CLI, and the Azure CLI (`winget install Git.Git GitHub.cli Microsoft.AzureCLI`, or `brew install git gh azure-cli`). Once these are installed, guide me through the process to get them set up. If in the interview I'm revealed to have little to no experience with Git, then you have to give me a brief ELI5 to explain what it is and why its valuable, in particular for agentic development. GitHub may not be necessary if I'm using an organizational account which doesn't have GitHub enterprise, and might instead have Azure DevOps Repos. If I am not permitted to use either GitHub or Azure DevOps then work with me to discuss how we can save and preserve my work with version control, such as via OneDrive or Google Drive. Ensure that these decisions and context are documented. If I do have GitHub and/or Azure DevOps ensure that you interview me in detail about my preferences. Ask for relevant documentation about branching and merge strategies, how you should leave commits and commit messages, whether you should commit, PR, or merge, and whether you should make these git actions as yourself the agent or on my behalf. You should also ask (but not recommend) whether you should make comments on behalf of me in issues or work items or PRs. Furthermore, ensure that you review my Git history to see which projects have been recently active (if any) and what the conventions or habits are in those projects. Pay special attention to any guidelines, agent memory files, or templates that reflect policies and group collaboration norms. The objective should be to assimilate into the workflow, or if serious issues exist (i.e. always pushing directly to main, bad practices being followed) you recommend changing specific things when you work in git. The key reason why you are paying attention to git is because our projects should be organized there. You should also at this point interview me about my experience and preferences with lifecycle management.
3. VS Code or a similar IDE (`winget install Microsoft.VisualStudioCode` or `brew install --cask visual-studio-code`). Other suitable options include Zed or Cursor. If I'm using OpenCode or another agent setup that already incorporates file / git trees and viewing file contents and diffs, then I likely don't need an IDE.
3. Tools for working with Microsoft Fabric and Power BI, if I use Fabric / Power BI
1. First, check whether I have access to the Power BI / Fabric APIs. If I don't know, you can test for my environment.
2. Fabric CLI (`uv tool install ms-fabric-cli`, which gives the `fab` command), which is required to interact with Fabric. It needs Python 3.10 or later and below 3.14. Check with me how I should authenticate and then guide me through the authentication process, which is likely interactive via a web browser.
3. Get tools for working with different artifact types
1. Semantic models
1. Ask me whether I have a preference for Power BI modelling MCP from Microsoft (`microsoft/powerbi-modeling-mcp`) or semantic ops MCP from Maxim Anatsko (`maxanatsko/mcp-engine-public`, published as the SemanticOps MCP)
2. Tabular Editor CLI from Tabular Editor. Explain that this will have to be manually downloaded from tabulareditor.com/download-tabular-editor-cli. Explain to me in my project that this can be used for semantic model automated testing and validation using a GitHub action or Azure Pipeline.
2. Reports
1. Pbir-CLI from Kurt Buhler and Maxim Anatsko, installed from PyPI with uv: `uv tool install pbir-cli`.
4. Get skills for working with Microsoft Fabric (optional):
1. Power-bi-agentic-development from data-goblin/power-bi-agentic-development. Add it as a marketplace; its plugins are per-artifact (`tabular-editor`, `pbi-desktop`, `pbip`, `semantic-models`, `reports`, `paginated-reports`, `fabric-cli`, `fabric-admin`, `custom-visuals`, `etl`, `goblin-mode`).
2. Microsoft/skills-for-fabric, also a marketplace (`fabric-authoring`, `fabric-consumption`, `fabric-operations`, `powerbi-authoring`, `fabric-skills`).
3. Ensure that you only take the skills that I need, and that you only install skills / plugins in their appropriate project. It may be more suitable to start with no skills and then install the skills afterward. You should first explain this scope to me and ask my preference, as if I work often with i.e. semantic models, I might want certain skills to be user-level. Ensure that you install the skills / plugins such that they will automatically update without me having to do anything (by installing the marketplace and then the plugin, if possible). Be careful to avoid installing multiple redundant skills, and be careful to avoid installing skills from untrusted or unverified sources.
4. Tools for working with Databricks, if I use databricks
1. Databricks CLI - the unified Go build, not the retired Python `databricks-cli` (`brew tap databricks/tap && brew install databricks`, or `winget install Databricks.DatabricksCLI`) - ask about the service principal vs PAT approach, and recommend OAuth (`databricks auth login`).
2. Databricks SDK (`uv pip install databricks-sdk`), only if I script against the workspace. Asset Bundles ship inside the CLI above, so most agentic work needs the CLI rather than the SDK. Note that the real permission surface is Unity Catalog grants, not workspace ACLs.
5. Check that the settings for my agent are configured properly, including:
1. Setting "auto-mode" as the default rather than having me manually approve tools. Ensure that "bypass permissions" mode or similar is disabled.
2. Setting the default model and effort levels to an appropriate default like opus low or medium.
3. Configuring a custom status line if I work in the terminal, such as one that shows the selected model, current working directory and Git branch, as well as the usage for my subscription, or the cost if I have token-based billing. If I don't work in the terminal, remind me to periodically check this information or use a tool to check it.
The above prompt should help you get a decent starting point, but it’s not going to magically help you understand or effectively use agents for development.
As you start your journey with agentic development, you’ll encounter many new concepts, from models and harnesses to memory, skills, and MCP servers. These different concepts are best understood like a set of building blocks that you use or put together to get the results that you want:
These building blocks are summarized as thus:
In the subsequent articles in this series, we’ll discuss in detail each of these factors and how you can use agents to get better results from your work with data.
This model isn’t specific to Power BI, Fabric, or even Business Intelligence; you can apply it to any area where you’d be using agents.
It’s adapted from a version presented in the article Introducing AI and agentic development for Power BI by SQLBI.
Agentic development involves using AI to develop BI artifacts and work with data. It brings opportunities for efficiency and enablement, but risks to security, governance, and more across endless possible scenarios. While using agents can lead to saved time and cost, these savings require appropriate investment in context and user adoption. Since agents are uniquely bespoke and tailored to their users, the best way to get started with agentic development is understanding scenarios, then experimenting and iterating with the technology, working collaboratively with your agent and thinking critically as you go. As you get more comfortable with using agents, you will want to better understand the building blocks necessary for effective agentic development so that you can mature your capabilities and workflows to get the benefits while mitigating risks.
This is the first article in a series to guide you in agentic development so that you can quickly get started and develop your skills in this area.
Put agents to work on your semantic models with the Tabular Editor CLI.
Give Tabular Editor a spin