Skip to content
/

power-bi-agentic-development

power-bi-agentic-dev · data-goblin/power-bi-agentic-development · ★ 619 · last commit 2026-05-14

Makes Claude Code a competent Power BI/Fabric developer by providing 25 domain skills, 8 validator agents, and PostToolUse hooks that enforce TMDL/PBIR/DAX format correctness automatically.

Best whenPower BI's open file formats (TMDL, PBIR) enable agentic development only when the agent has domain-specific validators that run automatically on every file …
Skip ifHardcoded hex colors in Deneb visuals (use pbiColor() instead), External URL data sources in Deneb specs
vs seeds
spec-kit's general code-quality hooks with domain-specific Power BI…
Primitive shape 38 total
Commands 2 Skills 25 Subagents 8 Hooks 2 MCP tools 1
00

Summary

power-bi-agentic-dev — Summary

power-bi-agentic-development is an Anthropic-format Claude Code plugin marketplace specifically for Power BI and Microsoft Fabric development. It ships 7 plugins (fabric-admin, fabric-cli, pbi-desktop, pbip, reports, semantic-models, tabular-editor) containing 25+ skills, 7 agents, and domain-specific PostToolUse hooks that auto-validate TMDL syntax, PBIR structure, DAX references, and referential integrity after every Edit/Write/Bash operation. The marketplace design allows granular installation — each plugin is independently installable via claude plugin install <name>@power-bi-agentic-development. Hooks use PowerShell scripts for Windows-native Power BI tooling (TOM/ADOMD.NET), and agents like semantic-model-auditor and deneb-reviewer run as reviewer subagents that validate before user-facing output. With 619 stars and weekly release cadence at version 26.20, it is the most mature Power BI agentic tooling in the corpus.

Differs from seeds: Structurally most similar to spec-kit (commands + skills mirroring per domain), but goes further with domain-specific PostToolUse hooks that auto-validate Power BI artifact formats — a pattern not present in any seed. The marketplace-within-marketplace plugin nesting (root is a catalog; each subfolder is an independently installable plugin) is architecturally novel.

01

Overview

power-bi-agentic-dev — Overview

Origin

Created by data-goblin, a Power BI/Fabric practitioner. Active development since at least v0.2.0, with weekly release cadence. Current version: 26.20. Licensed under GPL-3.0.

Philosophy

"The best source for agentic development resources for Power BI in one marketplace. Teach agents like Claude Code or GitHub Copilot to do literally anything in Power BI."

"Agentic development is when you use agents to help you build, manage, and optimize artifacts and software. This includes semantic models, reports, and the things around them, like workspaces, deployment pipelines, and also processes."

The project treats Power BI's open file formats (PBIP/TMDL/PBIR) as the foundation for agentic development — the agent edits text files that Power BI Desktop reads, rather than driving a GUI. Domain-specific hooks act as a CI-like layer: every TMDL edit triggers a syntax validator, every DAX change triggers a DAX validator, every model save triggers referential integrity checks.

Marketplace Architecture

The root is an Anthropic-format marketplace (/.claude-plugin/marketplace.json), not a plugin itself. Each subdirectory under plugins/ is a fully independent plugin with its own .claude-plugin/plugin.json, skills, agents, hooks, and optional MCP server references.

Cross-Tool Compatibility

Also supports GitHub Copilot CLI, which uses the same marketplace.json manifest.

Release Cadence

Weekly releases documented in release-notes/. The project explicitly warns: "Under active development with a weekly release cadence; regular renaming or restructuring."

02

Architecture

power-bi-agentic-dev — Architecture

Distribution

Anthropic-format plugin marketplace. Install via Claude Code:

claude plugin marketplace add data-goblin/power-bi-agentic-development

Then install specific plugins:

claude plugin install tabular-editor@power-bi-agentic-development
claude plugin install pbi-desktop@power-bi-agentic-development
claude plugin install semantic-models@power-bi-agentic-development
claude plugin install reports@power-bi-agentic-development
claude plugin install pbip@power-bi-agentic-development
claude plugin install fabric-cli@power-bi-agentic-development

Also works with GitHub Copilot CLI (same marketplace.json format).

Directory Tree (top-level)

.
├── .claude-plugin/marketplace.json     # Marketplace catalog
├── plugins/
│   ├── fabric-admin/                   # Fabric tenant administration
│   │   ├── .claude-plugin/plugin.json
│   │   └── skills/audit-tenant-settings/
│   ├── fabric-cli/                     # Microsoft Fabric CLI
│   │   ├── .mcp.json                   # Bundled MCP server reference
│   │   ├── commands/
│   │   └── skills/fabric-cli/
│   ├── pbi-desktop/                    # Power BI Desktop connectivity
│   │   ├── agents/query-listener.agent.md
│   │   ├── hooks/{hooks.json,*.ps1,*.sh}
│   │   └── skills/connect-pbid/
│   ├── pbip/                           # PBIP file format
│   │   ├── agents/pbip-validator.agent.md
│   │   ├── hooks/hooks.json
│   │   └── skills/{pbip,pbir-format,tmdl}/
│   ├── reports/                        # Report development
│   │   ├── agents/{deneb,python,r,svg}-reviewer.agent.md
│   │   └── skills/{create-pbi-report,deneb-visuals,...}/
│   ├── semantic-models/                # Semantic model development
│   │   ├── agents/semantic-model-auditor.agent.md
│   │   └── skills/{dax,lineage-analysis,power-query,refresh,...}/
│   └── tabular-editor/                 # Tabular Editor 2/3
│       ├── agents/bpa-expression-helper.agent.md
│       └── skills/{bpa-rules,c-sharp-scripting,te-docs,te2-cli}/
└── useful-stuff/                       # Non-plugin utilities
    ├── agent-settings/settings.json
    ├── hooks/{block-destructive-commands,block-npm,block-pip,block-secrets-exposure}/
    └── status-lines/

Required Runtime

  • Claude Code (primary)
  • GitHub Copilot CLI (secondary)
  • PowerShell (Windows, for pbi-desktop hooks)
  • Power BI Desktop (for pbi-desktop connectivity)
  • Python (for fabric-admin scripts)
  • Tabular Editor 2/3 (for tabular-editor plugin)
03

Components

power-bi-agentic-dev — Components

Skills (25)

Plugin Skill Purpose
fabric-admin audit-tenant-settings Audits Fabric tenant settings with Python scripts; generates PDF audit report
fabric-cli fabric-cli Microsoft Fabric CLI operations; workspace/lakehouse/notebook management
pbi-desktop connect-pbid Connects to Power BI Desktop via TOM/ADOMD.NET; DAX execution, performance profiling
pbip pbip PBIP project structure, cross-cutting renames, PBIX extraction/conversion
pbip pbir-format PBIR JSON file editing for report visuals
pbip tmdl TMDL (Tabular Model Definition Language) editing
reports create-pbi-report Creates Power BI reports from scratch
reports deneb-visuals Vega/Vega-Lite custom visuals in Power BI
reports modifying-theme-json Power BI report theme JSON editing
reports pbi-report-design Report design principles and layout
reports pbir-cli pbir CLI tool for PBIR operations
reports python-visuals Python visuals in Power BI
reports r-visuals R visuals in Power BI
reports review-report Report quality review
reports svg-visuals SVG custom visuals in Power BI
semantic-models dax DAX performance optimization; FE/SE architecture, tiered optimization framework
semantic-models lineage-analysis Column-level lineage and impact analysis
semantic-models power-query Power Query M formula editing
semantic-models refresh-semantic-model Model refresh operations
semantic-models review-semantic-model Model auditing: DAX anti-patterns, naming, best practices
semantic-models standardize-naming-conventions Naming convention enforcement
tabular-editor bpa-rules Best Practice Analyzer rules in Tabular Editor
tabular-editor c-sharp-scripting C# scripting in Tabular Editor; 100+ example scripts
tabular-editor te-docs Tabular Editor documentation skill
tabular-editor te2-cli Tabular Editor 2 CLI operations

Agents (7)

Plugin Agent Purpose
pbi-desktop query-listener Listens to DAX query events in Power BI Desktop
pbip pbip-validator Validates PBIP project structure after edits
reports deneb-reviewer Validates Vega/Vega-Lite specs before user presentation
reports python-reviewer Reviews Python visual code
reports r-reviewer Reviews R visual code
reports svg-reviewer Reviews SVG visual markup
semantic-models semantic-model-auditor Audits semantic model quality
tabular-editor bpa-expression-helper Helps author BPA rule expressions

Hooks

pbi-desktop hooks.json

Events: PreToolUse (matcher: Bash), PostToolUse (matcher: Bash)

  • Pre: Validate DAX before PowerShell executions (validate-dax, validate-measure)
  • Post: refresh-cache, check-compat, check-ri (referential integrity after SaveChanges)

pbip hooks.json

Events: PostToolUse (matchers: Edit, Write, Bash)

  • Post Edit/Write on .Report/**: validate-pbir.sh
  • Post Edit/Write on *.tmdl: validate-tmdl.sh
  • Post Edit/Write on definition.pbir: validate-report-binding.sh
  • Post Bash on TMDL serialize: validate-tmdl.sh

Commands (2 — fabric-cli plugin)

  • audit-context.md — Context for fabric audit operations
  • migrating-fabric-trial-capacities.md — Guidance for capacity migration

Scripts

  • plugins/fabric-admin/skills/audit-tenant-settings/scripts/audit-tenant-settings.py
  • plugins/fabric-admin/skills/audit-tenant-settings/scripts/generate_audit_pdf.py
  • plugins/pbi-desktop/hooks/pbi-hooks.sh — DAX/cache/RI validation
  • plugins/pbi-desktop/hooks/snapshot-model.ps1
  • plugins/pbi-desktop/hooks/check-referential-integrity.ps1
  • plugins/fabric-cli/skills/fabric-cli/scripts/*.py (8 Python scripts for workspace/lakehouse operations)

MCP Servers (fabric-cli)

plugins/fabric-cli/.mcp.json — references Microsoft Fabric CLI MCP server

05

Prompts

power-bi-agentic-dev — Prompt Excerpts

Excerpt 1: dax SKILL.md — Trigger keywords and progressive disclosure structure

Technique: Rich description with keyword triggers + layered reference files (workflow-first, deep details second).

---
name: dax
version: 26.20
description: DAX performance optimization for semantic models. Automatically invoke when the user asks to "optimize DAX", "fix slow DAX", "DAX performance", "tune a measure", "debug a measure", "DAX anti-patterns", or mentions slow queries, server timings, or DAX authoring.
---

For systematic DAX query performance optimization, read the workflow reference first:

**[`references/dax-performance-optimization.md`]** — Tiered framework (4 tiers), phased workflow, decision guide, and error handling.

Detailed reference files (progressive disclosure — consult as directed by the workflow):
- **[`references/engine-internals.md`]** — FE/SE architecture, xmSQL, compression/segments, SE fusion, trace diagnostics
- **[`references/dax-patterns.md`]** — Tier 1 DAX patterns (DAX001–DAX021) + Tier 2 query structure (QRY001–QRY004)
- **[`references/model-optimization.md`]** — Tier 3 model patterns (MDL001–MDL010) + Tier 4 Direct Lake (DL001–DL002)

Excerpt 2: pbip SKILL.md — Critical guidance list

Technique: Iron-law enumeration with CRITICAL markers; domain-specific UTF-8 BOM and CRLF rules.

- **PBIX is a black box; PBIP is transparent.** PBIX is a single binary that cannot be diffed or edited externally. PBIP splits the same content into text files. Convert between them with File > Save As in PBI Desktop.
- **UTF-8 without BOM.** All files must be saved as UTF-8 without BOM. A BOM prefix causes parse errors in some tools.
- **Git line endings:** PBI Desktop writes CRLF. Configure `core.autocrlf` or `* text=auto` in `.gitattributes` to normalize.
- **260-char Windows path limit.** Use short root paths. Deep nesting of page/visual GUIDs can exceed this limit.
- **PBI Desktop does not detect external changes.** Close and reopen PBI Desktop after editing files externally.
- **Rename cascades are cross-cutting.** Renaming a table, measure, or column requires updating references in TMDL files, visual JSONs, report extensions, culture files, DAX queries, and diagram layouts.

Excerpt 3: deneb-reviewer agent — Validation checklist

Technique: Structured checklist with numbered items for deterministic review coverage.

**Validation Checklist:**

1. **Schema**: `$schema` points to valid Vega or Vega-Lite schema URL
2. **Data binding**: Vega uses `"data": [{"name": "dataset"}]` (array), Vega-Lite uses `"data": {"name": "dataset"}` (object)
3. **Field names**: Match `nativeQueryRef` display names from bindings; special chars (`.[]"`) become `_`, spaces preserved
4. **Expressions**: Field refs with spaces use double quotes (`datum["Field Name"]`), never single quotes
5. **Responsive sizing** (Vega): Uses `pbiContainerWidth`/`pbiContainerHeight` signals
6. **No external data**: No URL-based data sources (blocked by AppSource certification)

Excerpt 4: pbi-desktop hooks.json — Pre-validation hook

Technique: Conditional hook execution matching tool input patterns.

{
  "type": "command",
  "command": "bash \"${CLAUDE_PLUGIN_ROOT}/hooks/pbi-hooks.sh\" validate-dax",
  "timeout": 10,
  "if": "Bash(*tom_nuget*)"
}
09

Uniqueness

power-bi-agentic-dev — Uniqueness

Differs from Seeds

No seed covers Power BI or data analytics tooling. Structurally, the plugin nesting pattern (marketplace → plugins → skills/agents/hooks per plugin) is closer to claude-flow's MCP-bundled toolserver approach, but implemented purely in markdown + shell scripts rather than code. The PostToolUse hooks that auto-validate TMDL and PBIR syntax on every file edit are functionally similar to spec-kit's per-command hooks, but domain-specific: they validate Power BI file format constraints (UTF-8 BOM, Windows path limits, TMDL syntax) rather than general code quality. The reviewer agent pattern (4 domain-specific reviewer agents for reports) parallels BMAD-METHOD's persona approach but the agents are stateless reviewers rather than stateful personas.

Positioning

The only actively maintained Claude Code plugin dedicated to Power BI/Fabric. Fills the gap between generic coding agents (which know nothing about TMDL, DAX, or PBIR formats) and manual Power BI development. The 100+ Tabular Editor C# example scripts make it useful even without the agent features — as a reference library.

Observable Failure Modes

  1. Windows-only hooks: The pbi-desktop hooks use PowerShell; on macOS/Linux they silently fail or require pwsh.
  2. Version drift: Weekly releases mean skills can be renamed or restructured; users must regularly update.
  3. TOM/ADOMD.NET dependency: connect-pbid and pbi-desktop hooks require .NET runtime and NuGet packages on the local machine.
  4. Private preview dependency: pbip-demo-agentic-mcp's powerbi-modeling-mcp is in private preview — a separate repo in this batch that depends on the same tooling.
  5. GPL-3.0 license: Restricts commercial embedding; unusual for a Claude Code plugin.

Explicit Antipatterns

  • Using hex colors instead of pbiColor() in Deneb visuals
  • External URL data sources in Deneb specs (blocked by AppSource certification)
  • Importing/downloading thick PBIX for diffing (binary, not diffable)
  • Explicit resource naming when optional in CDK (cross-reference to AWS skills pattern)
04

Workflow

power-bi-agentic-dev — Workflow

General Model

There is no single top-level workflow. Each plugin defines domain-specific workflows. The hooks provide automated validation after every write operation.

pbi-desktop Plugin Workflow

  1. Connect — Use connect-pbid skill to establish TOM/ADOMD.NET connection to Power BI Desktop
  2. Develop — Write DAX expressions or modify model via PowerShell scripts
  3. Pre-validatePreToolUse Bash hook validates DAX syntax and measure references before execution
  4. Post-validatePostToolUse Bash hook refreshes metadata cache, checks compatibility level, runs referential integrity after SaveChanges

PBIP Plugin Workflow

  1. Structure — Use pbip skill for project structure guidance
  2. Edit TMDL — Edit semantic model definition files
  3. Auto-validatePostToolUse Edit/Write hook immediately runs validate-tmdl.sh on any .tmdl file change
  4. Edit Report — Modify PBIR JSON files
  5. Auto-validatePostToolUse validates PBIR structure and report binding after every .Report/** edit

Reports Plugin Workflow (with Reviewer Agents)

  1. Create/edit visual — Use deneb-visuals, svg-visuals, etc. skills to create visuals
  2. Agent reviewdeneb-reviewer, svg-reviewer, etc. agents validate spec before user-facing output
  3. Present to user — Only after agent review passes

Phase-to-Artifact Map

Phase Artifact
Tenant audit PDF audit report
TMDL edit Validated TMDL files
DAX optimization Performance-analyzed measures
Report creation PBIR JSON files + theme JSON
BPA analysis Best Practice Analyzer rule violations

Approval Gates

No explicit human approval gates in workflows; reviewer agents act as automated gates before user presentation.

06

Memory Context

power-bi-agentic-dev — Memory & Context

State Storage

No persistent memory mechanism. State lives in the Power BI project files on disk (TMDL, PBIR JSON, etc.).

Context Injection

Each skill's references/ folder provides deep domain context loaded on-demand:

  • dax/references/ — 4 tiered optimization reference files (engine-internals, dax-patterns, model-optimization)
  • pbip/references/ — PBIP file structure, encoding rules
  • connect-pbid/references/ — Performance profiling, EVALUATEANDLOG debugging, DAX expressions
  • c-sharp-scripting/object-types/ — 15 C# object type reference files (measures, columns, tables, relationships, etc.)
  • c-sharp-scripting/examples/ — 100+ example C# scripts organized by category

The DAX skill explicitly uses progressive disclosure — the workflow reference file is read first, and deeper references are loaded "as directed by the workflow", preventing context overload.

Cross-Session Handoff

None. The PBIP project files on disk serve as the natural handoff artifact.

Compaction Handling

Not explicitly handled.

Version Metadata

Skills include version: 26.20 in frontmatter — this enables version-aware behavior and tracks which skill version was used in a session.

07

Orchestration

power-bi-agentic-dev — Orchestration

Multi-Agent Pattern

Hierarchical — main agent dispatches domain-specific reviewer subagents before user-facing output:

  • deneb-reviewer, python-reviewer, r-reviewer, svg-reviewer (reports plugin)
  • semantic-model-auditor (semantic-models plugin)
  • pbip-validator (pbip plugin)
  • bpa-expression-helper (tabular-editor plugin)
  • query-listener (pbi-desktop plugin)

Each reviewer agent uses tools: ["Read", "Grep", "Glob"] — read-only validators.

Execution Mode

Event-driven — hooks fire automatically on every Edit/Write/Bash tool use matching domain-specific patterns. The main workflow is interactive.

Isolation Mechanism

None. All operations run in the project working directory.

Multi-Model

Not specified in skill or agent frontmatter beyond model: sonnet on reviewer agents. Main agent inherits session model.

Auto-Validators (via PostToolUse hooks)

Trigger Validator Scope
Edit/Write on *.tmdl validate-tmdl.sh TMDL syntax
Edit/Write on **.Report/** validate-pbir.sh PBIR structure
Edit/Write on **/definition.pbir validate-report-binding.sh Report-model binding
Bash *tom_nuget* validate-dax (PowerShell) DAX references
Bash *Measures.Add* validate-measure Measure metadata
Bash * -File *.ps1* after run refresh-cache, check-compat Metadata cache, compat level
Bash *SaveChanges* check-ri (60s) Referential integrity

Prompt Chaining

Not explicit — skills reference other skills via cross-references but do not chain output as input.

Consensus Mechanism

None.

08

Ui Cli Surface

power-bi-agentic-dev — UI / CLI Surface

CLI Binary

None shipped by this plugin. Domain CLIs are external prerequisites:

  • Microsoft Fabric CLI (fab)
  • pbir-cli (Python package: uv tool install pbir-cli)
  • Tabular Editor 2 CLI (te2)

Local UI

None. No web dashboard.

IDE Integration

  • Claude Code (primary) — plugin marketplace format
  • GitHub Copilot CLI — same marketplace.json format works without modification
  • Power BI Desktop — not an IDE integration but a live connection target via TOM/ADOMD.NET

Status Lines

useful-stuff/status-lines/ provides shell scripts for a custom terminal status line:

  • 02-host-cwd.sh — host and current directory
  • 03-git.sh — git branch/status
  • 04-model.sh — active Claude model
  • 05-time.sh — time
  • 06-meters.sh — resource meters

These are opt-in terminal enhancements, not plugin components.

Useful-Stuff Hooks (not part of any plugin)

useful-stuff/hooks/ provides 4 standalone hook bundles:

  • block-destructive-commands — blocks rm -rf, drop, truncate, delete
  • block-npm — blocks npm installs
  • block-pip — blocks pip installs
  • block-secrets-exposure — blocks reads of .env, API key files

These are manual copy-in patterns, not auto-installed.

Observability

No audit log. No session recording. PBIP files on disk serve as implicit audit trail.

Related frameworks

same archetype · same primary tool · same memory type

Claude-Flow / Ruflo ★ 55k

Eliminates single-agent context limits and sequential bottlenecks by orchestrating fault-tolerant swarms of specialized AI agents…

Hermes Agent (NousResearch) ★ 168k

Self-improving personal AI agent with closed learning loop, 7 terminal backends, and messaging gateway — not tied to any AI…

OpenCode ★ 165k

Terminal-first AI coding agent with multi-model routing, native desktop app, and a typed .opencode/ configuration system for…

OpenHands ★ 75k

Open-source AI software development platform (open-source Devin alternative) with Docker sandbox isolation, 77.6% SWE-bench…

DeerFlow ★ 70k

Long-horizon superagent that researches, codes, and creates by orchestrating parallel sub-agents with isolated contexts in Docker…

oh-my-openagent (omo) ★ 60k

Multi-provider AI agent orchestration for OpenCode: escape vendor lock-in by routing Sisyphus (Claude/Kimi/GLM) and Hephaestus…