Estimated reading time: 9 minutes

Introduction

On April 1, 2026, Microsoft’s Dataverse team shipped something that, quietly, changes the developer experience on Power Platform more than anything since the introduction of the Power Platform CLI.

Specifically, it is called Dataverse Skills — an open-source plugin for coding agents like GitHub Copilot and Claude Code that gives them deep, structured knowledge of how to build and manage Dataverse solutions from end to end.

However, to understand why this matters, you have to first understand the problem it solves.

The Old Way: Tool Juggling as a Developer Tax

Anyone who has built non-trivial Dataverse solutions knows the pattern. Indeed, a typical session looks something like this:

1. First, you open the Power Platform CLI to authenticate and select an environment.
2. Next, you switch to the maker portal to visually inspect an existing table schema.
3. Then, you open the official OData Web API docs to look up the correct request format for creating a lookup column.
4. Subsequently, you write a Python or PowerShell script to bulk-load sample data, get the column logical names wrong on the first attempt, fix them, run it again.
5. Afterwards, you switch back to the CLI to export the solution.
6. Finally, you realise you forgot to add the new table to the solution. You go back.

This constant context-switching — between CLI, browser, API docs, and scripts — is what I call the developer tax on enterprise platforms. Clearly, the knowledge exists. Similarly, the tools exist. However, the orchestration is manual, error-prone, and slow.

Moreover, the cognitive load is especially high for architects who are context-switching across multiple projects and environments simultaneously.

The Traditional Toolchain

The Paradigm Shift: Intent-Driven Development

The shift happening right now in enterprise software is from writing code to directing agents. Instead of stitching together APIs, CLIs, and scripts, developers describe intent and let agents execute.

Furthermore, for enterprise platforms like Dataverse, this creates a specific requirement: they must be operable by agents, not just by humans.

Indeed, this is precisely what Dataverse Skills addresses.

For example, consider the recruiting system example from the official release blog:

"I'm building a recruiting system for Zava Construction. I need tables for 
Positions, Candidates, Interviewers, Interviews, and Feedback — with lookups, 
a many-to-many between Candidates and Positions, and a self-referential 
interview chain. Create everything in a ZavaRecruiting solution, load sample 
data, and show me which candidates are currently interviewing."

From that single natural language prompt, the agent:

1. First, discovers the Dataverse environment and configures the MCP connection
2. Then, creates the solution using PAC CLI
3. Next, builds five tables with choice columns, lookups, and a M:N relationship
4. Subsequently, generates and executes a Python script to bulk-load realistic sample data
5. Finally, queries across tables and returns the business answer

Notably, no skill names are invoked manually. No tool flags. No context switching. Instead, the agent handles the full orchestration.

The Key Insight

The most important design decision in Dataverse Skills is this: the user never invokes a skill directly. You describe your intent, and the agent determines which skills to load, in what order, using which tools.

Skills are the agent’s knowledge. Natural language is the interface.

This is a fundamentally different mental model from traditional CLI-based automation, where you have to know the exact command, flags, and sequence. With Skills, you describe what you want to achieve, and the agent figures out how to achieve it.

What Are Dataverse Skills Exactly?

Dataverse Skills is an open-source GitHub repository (microsoft/Dataverse-skills) that contains a structured collection of Markdown files. Each file is a “skill” — a self-contained unit of knowledge about how to perform a specific Dataverse operation.

The skills are organized into three phases:

Phase 1: Connect

The agent discovers your environments, authenticates via PAC CLI or Azure CLI, registers the Dataverse MCP server, and initializes a consistent project structure. You configure nothing — the agent handles discovery and setup.

Key operations covered:

• pac auth create and environment discovery
• Dataverse MCP server registration (/api/mcp endpoint)
• Project structure initialization

Phase 2: Build

The agent creates solutions, tables, columns, lookups, many-to-many relationships, forms, and views. It knows which tool is right for each operation:

• MCP server for quick reads and metadata operations
• Dataverse Python SDK for bulk operations
• Web API for schema modifications

Every component is automatically added to the active solution.

Phase 3: Operate

The agent loads data, runs analytical queries, bulk-imports from CSV, and profiles data quality using the official Dataverse Python SDK.

Technical Format

Each skill is a Markdown file with YAML frontmatter. This design choice is significant:

---
name: dataverse-create-table
description: Creates a new Dataverse table with the specified schema
allowed-tools: [bash, file, web_fetch]
---

---
name: dataverse-create-table
description: Creates a new Dataverse table with the specified schema
allowed-tools: [bash, file, web_fetch]
---

No compiled code. No proprietary formats. Every skill can be read, understood, modified, and contributed to by any developer. The project is MIT-licensed.

Why This Matters for Enterprise Platforms

Dataverse Skills represents a broader architectural principle that Microsoft is applying across the Power Platform: platforms must expose their capabilities as agent-consumable knowledge, not just human-consumable UIs.

Indeed, this is why the release is accompanied by three other major developments:

1. The Dataverse MCP Server

The Model Context Protocol (MCP) server built into Dataverse provides standardized, agent-accessible endpoints for reading and writing Dataverse data. As one of its primary tools for the Connect and Build phases, the Skills plugin leverages this server extensively.

Access to the MCP server is available at:

https://{your-org}.crm.dynamics.com/api/mcp

It exposes tools like list_tables, describe_table, read_query, create_record, and update_record that agents can call directly.

2. The Dataverse Python SDK

The PowerPlatform-Dataverse-Client Python package (currently v0.1.0b7, in public preview since Microsoft Ignite 2025) provides a high-level, Pythonic interface for Dataverse operations. The Skills plugin uses this heavily for the Operate phase.

from PowerPlatform.Dataverse.client import DataverseClient
from azure.identity import AzureCliCredential

client = DataverseClient("https://yourorg.crm.dynamics.com", AzureCliCredential())

# Bulk create with native Dataverse CreateMultiple
client.records.create("new_candidate", [
    {"new_firstname": "Anna", "new_lastname": "Mueller", "new_status": 1},
    {"new_firstname": "Thomas", "new_lastname": "Berger", "new_status": 1},
])

from PowerPlatform.Dataverse.client import DataverseClient
from azure.identity import AzureCliCredential

client = DataverseClient("https://yourorg.crm.dynamics.com", AzureCliCredential())

# Bulk create with native Dataverse CreateMultiple
client.records.create("new_candidate", [
    {"new_firstname": "Anna", "new_lastname": "Mueller", "new_status": 1},
    {"new_firstname": "Thomas", "new_lastname": "Berger", "new_status": 1},
])

3. Power Platform 2026 Release Wave 1

The 2026 Release Wave 1 (April–September 2026) explicitly includes enhancements to agent programmability with Dataverse APIs, MCP servers, and the Python SDK. Dataverse Skills is the developer-facing entry point into this broader platform direction.

The Broader Ecosystem This Unlocks

At this point, it is worth distinguishing Dataverse Skills (the developer plugin) from Business Skills (a separate, but related concept in Copilot Studio).

Business Skills are reusable, natural-language-described process instructions stored as Dataverse table records. They can be created by makers in Copilot Studio and used by agents to execute business processes — like logging a call transcript or looking up order status.

Nevertheless, the two concepts are complementary:

• Dataverse Skills (developer plugin): teaches coding agents how to build and manage Dataverse solutions
• Business Skills (Copilot Studio): teaches agents how to execute business processes stored in Dataverse

Ultimately, as a developer or architect, you will likely work with both.

What This Means for You as a Developer or Architect

For Developers

• Onboarding acceleration: New developers on a project can describe what they want to build and have the agent scaffold the correct Dataverse schema, without needing to memorize PAC CLI command sequences.
• Prototyping speed: Furthermore, a full data model with sample data can be stood up in minutes from a single prompt.
• Reduced documentation dependency: Additionally, the knowledge is embedded in the agent, not in a wiki you have to maintain.

Architectural Impact

• Consistent patterns: The skills encode best practices (publisher prefixes, solution structure, ALM hygiene) that propagate automatically across projects.
• Governance by default: Moreover, because the agent uses the same tools and patterns every time, architectural standards are easier to enforce.
• Focus shift: Most importantly, you move from explaining how to do things to defining what should be done and why — which is where architectural value actually lies.

Team-Wide Benefits

• Tool standardization: One plugin investment covers both GitHub Copilot and Claude Code users. Teams that haven’t standardized on a single coding agent get consistent Dataverse capabilities regardless.

References & Further Reading

Official Announcements

• Dataverse Skills: Your Coding Agent Now Speaks Dataverse — Power Platform Developer Blog
• Dataverse MCP Server — Power Platform Blog
• Introducing the Dataverse SDK for Python — Power Platform Blog

GitHub Repositories

• microsoft/Dataverse-skills — The plugin source
• microsoft/PowerPlatform-DataverseClient-Python — Python SDK source

Microsoft Learn Documentation

• Connect to Dataverse with MCP
• Configure the Dataverse MCP server
• Dataverse SDK for Python overview
• Create and use Business Skills
• Power Platform CLI reference
• Power Platform 2026 Release Wave 1

Package Registry

• PowerPlatform-Dataverse-Client on PyPI

Next in this series → Part 2: Getting Started with Dataverse Skills: Install, Configure, and Build Your First Agent-Driven Solution