Estimated reading time: 9 minutes

Microsoft’s Dataverse Skills transforms Power Platform development from manual tool orchestration to AI-driven intent. This Dataverse Skills guide is designed to help users at all levels. This comprehensive guide covers the complete journey: understanding the paradigm shift from scripts to natural language, installing and configuring for GitHub Copilot and Claude Code, mastering custom skill development with YAML frontmatter, and implementing enterprise governance with MCP billing controls and ALM integration. Whether you’re a developer learning intent-driven workflows or an architect evaluating production readiness, this series provides the technical depth and real-world insights you need.

What Is This Series?

In April 2026, Microsoft released Dataverse Skills—an open-source plugin that teaches AI coding agents (GitHub Copilot, Claude Code) how to build and manage Dataverse solutions from natural language prompts.

This isn’t just about faster development. It’s a fundamental shift in how enterprise platforms are designed: platforms must be operable by agents, not just by humans.

This 4-part series is the definitive technical guide to Dataverse Skills adoption—from conceptual understanding through production deployment. Based on real-world implementations across consulting firms, ISVs, and enterprise CoEs, it addresses both the developer experience and the architectural governance questions that determine enterprise adoption.

Who Should Read This Series?

For Power Platform Developers

If you’ve ever felt the “developer tax” of switching between PAC CLI, maker portal, API docs, and custom scripts—this series shows you a faster way. You’ll learn:

• How to build complete Dataverse solutions from single natural language prompts
• The tool selection logic (MCP vs Python SDK vs PAC CLI) that affects your Copilot credit costs
• How to write custom skills that encode your organization’s patterns
• Production-ready authentication, error handling, and debugging techniques

For Solution Architects

If you’re evaluating whether Dataverse Skills fits your enterprise architecture, this series provides:

• The architectural implications of 6-10x faster schema creation
• Security boundaries (allowed-tools, DLP policies, Managed Environments)
• Real-world cost benchmarks ($200-800/month for 20-100 developers)
• ALM integration patterns that preserve your existing CI/CD pipelines
• Custom skill templates for organizational standards

For Enterprise Architects and CoE Leads

If you need to approve (or reject) Dataverse Skills for enterprise use, this series delivers:

• Governance framework for agent access in Managed Environments
• MCP billing models with production cost data
• Prompt injection risks and proven mitigations
• Environment segmentation strategies (dev/test/prod)
• How this fits Microsoft’s 2026 Power Platform roadmap

Series Structure

Part 1: The Paradigm Shift

From Scripts to Intent: How Dataverse Skills Redefines Enterprise Development

What you’ll learn:

The conceptual foundation. Why manual tool orchestration (PAC CLI + maker portal + API docs + scripts) represents a “developer tax” on enterprise platforms. How the shift from writing code to directing agents changes the mental model of development. What Dataverse Skills actually is (open-source Markdown files with YAML frontmatter) and how it works at a high level.

Key takeaways:

• The developer tax: constant context-switching between CLI, browser, docs, and scripts
• Intent-driven development: describe what you want, agents determine how to build it
• The three-phase architecture: Connect → Build → Operate
• Why this matters for enterprise platforms (agent programmability as a strategic platform requirement)
• The broader ecosystem: MCP server, Python SDK, and 2026 Release Wave 1 context

Part 2: Installation and Your First Build

Getting Started with Dataverse Skills: Install, Configure, and Build Your First Agent-Driven Solution

What you’ll learn:

The complete setup process with enterprise-tested patterns. PAC CLI and Azure CLI authentication (including service principal flows for CI/CD). Enabling the Dataverse MCP server in Managed Environments. Installing Dataverse Skills in both Claude Code and GitHub Copilot. Building a complete project tracking system from a single natural language prompt.

Key takeaways:

• Prerequisites checklist (Managed Environment requirement, PAC CLI, Node.js, Python)
• PAC CLI authentication patterns (interactive and service principal)
• MCP server enablement in Power Platform Admin Center
• Claude Code installation (direct MCP connection and proxy modes)
• GitHub Copilot installation (VS Code and CLI)
• Real-world build walkthrough: project tracking system with 5 tables, relationships, sample data, and queries
• Common errors and troubleshooting (authentication failures, MCP connection issues)

Part 3: Architecture and Custom Skills

Under the Hood: How Dataverse Skills Work and How to Write Your Own

What you’ll learn:

The engineering decisions that make Dataverse Skills work. Skill file anatomy (Microsoft’s YAML frontmatter format and organizational extensions). How agents select and chain skills based on requires declarations. The three-tool strategy (MCP Server, Python SDK, PAC CLI) and when each is optimal. Writing custom skills that encode your organization’s patterns.

Key takeaways:

• Skill file format: YAML frontmatter (name, description, allowed-tools, safety, requires, priority) + Markdown body
• Agent skill selection logic (relevance matching, dependency graphs, tool restrictions)
• The decision matrix: MCP for fast queries, Python SDK for bulk ops, PAC CLI for ALM
• Cost implications: MCP calls consume Copilot credits, SDK and CLI don’t
• Production examples: Daniel Kerridge’s dataverse-plugins and dataverse-web-resources skills
• Custom skill templates (base format and extended format with security boundaries)
• Testing and debugging custom skills

Part 4: Enterprise Governance and Production

Dataverse Skills for Enterprise Architects: Governance, ALM, MCP Billing, and Production Readiness

What you’ll learn:

The business and governance questions that determine enterprise adoption. Managed Environment security architecture and DLP policy integration. Real-world MCP billing costs with production benchmarks. ALM integration patterns (agent builds, CI/CD deploys). Security considerations (prompt injection risks, secrets management). How this fits Microsoft’s 2026 roadmap.

Key takeaways:

• Architectural implications: 6-10x faster schema creation, attribution challenges, consistency advantages
• Governance: Managed Environments as the control boundary, MCP client allowlists, environment segmentation
• MCP billing: Copilot credit consumption model, license exemptions, real costs ($200-800/month for 20-100 developers)
• ALM integration: agent-built solutions in existing CI/CD pipelines, version management for frequent changes
• Security: prompt injection mitigations, allowed-tools as defense, service principal patterns
• Business Skills vs Developer Skills: clearing the confusion
• 2026 roadmap context: agent programmability, governance for agents, GitHub integration

Common Questions Answered Across the Series

“How much does this cost?”

Answered in Part 4, Section: MCP Billing

MCP calls consume Copilot credits at the “Text and generative AI tools (basic)” rate. Industry benchmark from early adopters: $200-800/month for teams of 20-100 developers during active development cycles. This is typically 5-15% of total Copilot credit consumption.

License exemptions: Dynamics 365 Premium and Microsoft 365 Copilot USL users don’t incur additional charges for Dataverse access.

Cost control strategy: Reserve MCP for interactive development. For bulk operations and CI/CD, use Python SDK (free, direct Web API calls).

“Is this production-ready?”

Answered in Part 4, Section: Production Readiness and Part 2, Section: Common Errors

The underlying components are production-ready:

• PAC CLI: GA since 2020
• Dataverse Web API: GA
• Dataverse Python SDK: Public preview (v0.1.0b7), GA targeted for 2026 H2

Dataverse Skills as a plugin: Released April 2026, MIT licensed. Early production deployments exist across consulting firms and ISVs.

Recommended approach: Pilot with a single team on a greenfield project. Measure velocity and quality against your baseline. Expand after establishing governance patterns.

“Does this replace our existing ALM pipeline?”

Answered in Part 4, Section: ALM Integration

No. Dataverse Skills accelerates the development phase. The output is the same as manual development: unmanaged solutions that move through your existing export/import pipeline.

The workflow:

1. Agent builds schema in dev environment
2. Developer reviews and commits unpacked solution to source control
3. CI/CD pipeline deploys to test and production (unchanged)

The agent doesn’t touch test or production environments. Automated pipelines do.

“What about security and governance?”

Answered in Part 4, Section: Governance and Security Considerations

Governance boundaries:

• Managed Environments required (DLP enforcement, IP firewall, usage reporting)
• MCP client allowlists (disable unused agents)
• User identity model (no separate “agent identity” that bypasses RBAC)

Security mitigations:

• allowed-tools field restricts agent capabilities (defense against prompt injection)
• Service principals for CI/CD (read-only where possible)
• Dataverse audit logging (tracks all schema changes)
• Azure Key Vault for secrets (never in skill files)

Environment segmentation:

• Dev: agents enabled, permissive DLP
• Test: automated validation only, production-equivalent DLP
• Production: agents disabled, strictest DLP

“Can I write my own skills for our organization’s patterns?”

Answered in Part 3, Section: Writing Your Own Custom Skills

Yes. This is the primary extensibility model.

Use cases:

• Publisher prefix conventions
• Mandatory audit columns (created by, modified by)
• Solution structure standards
• Custom ALM workflows
• Integration with external systems (Azure DevOps, Jira)

Format: Markdown files with YAML frontmatter. No compilation. Version-controlled in your repository.

Distribution: Add to .claude-plugin/marketplace.json (Claude Code) or .github/plugins/ (GitHub Copilot).

“How do I debug when the agent makes the wrong decision?”

Answered in Part 3, Section: Testing and Validating Custom Skills

Debugging checklist:

1. Check skill’s description field for user’s trigger phrases
2. Add explicit tool guidance in step instructions
3. Review allowed-tools restrictions
4. Increase priority if competing with built-in skills
5. Verify skill registration in marketplace.json

Common issues:

• Agent uses MCP when it should use Python SDK → add “Use Python SDK for bulk operations (100+ records)” to skill steps
• Agent doesn’t invoke your custom skill → add more trigger phrases to description field
• Agent skips required prerequisites → check requires field declarations

Real-World Production Example

Throughout the series, we feature Daniel Kerridge’s claude-code-power-platform-skills repository—production-ready skills for Dataverse plugin development and web resources.

Why this example matters:

Daniel’s dataverse-plugins skill demonstrates how to encode complex domain knowledge:

• Critical rules section: “Plugins run in a sandbox. 2-minute timeout for sync. Never use static variables.”
• Quick reference tables: Interface, timeout limits, assembly size constraints
• Resource files: Breaking knowledge into focused sub-documents

These are mistakes junior developers make once (painfully). When encoded in the skill file, the agent never makes them.

That’s organizational knowledge as code.

Repository: github.com/DanielKerridge/claude-code-power-platform-skills

The Three-Tool Decision Matrix

A core concept explained in Part 3 that affects your costs and architecture:

Why this matters:

• MCP calls = Copilot credits consumed
• Python SDK calls = Free (direct Web API)
• PAC CLI calls = Free (local tooling)

Typical dev session (5-table solution): 25-50 MCP calls. At scale (50-person team, 10 sessions/week): 12,500-25,000 MCP calls/month → $200-800/month.

Encoding this in skills teaches agents to choose the cost-optimal tool for each operation.

Key Architectural Patterns

Environment Segmentation Strategy

Development Environment (Sandbox, Managed)
├── MCP clients enabled: GitHub Copilot, Dataverse CLI
├── DLP policy: Permissive (allows most connectors)
├── Dataverse Skills: Fully enabled
└── Agent activity: Unrestricted for registered developers

Test/QA Environment (Sandbox, Managed)
├── MCP clients enabled: Dataverse CLI only (CI/CD service principal)
├── DLP policy: Production-equivalent
├── Dataverse Skills: Read-only operations only
└── Agent activity: Automated validation only (no interactive prompts)

Production Environment (Production, Managed)
├── MCP clients enabled: None (or read-only with specific approval)
├── DLP policy: Strictest
├── Dataverse Skills: Disabled
└── Agent activity: Prohibited

The key principle: Agents build and validate in development, automated pipelines deploy to test and production.

Custom Skill Template

Base format (required fields only):

---
name: {publisher}-{action}-{subject}
description: >
  One or two sentences describing what this skill does and when to use it.
  Use when: "quoted trigger phrases".
  Do not use when: {anti-patterns that should use other skills}.
---

# Skill: {Title}

## Purpose
What does this skill do? When should an agent invoke it?

## Pre-conditions
1. What must be true before this skill can run?
2. What environment state is assumed?

## Steps

### Step 1: Validate inputs
What to check first. Include error conditions.

### Step 2: Main operation
The actual work. Include tool calls, code examples, API payloads.

### Step 3: Verify and report
How to confirm success. What to report to the user.

## Error handling
| Error | Cause | Resolution |
|-------|-------|------------|
| Error description | Why it happens | How to fix it |

---
name: {publisher}-{action}-{subject}
description: >
  One or two sentences describing what this skill does and when to use it.
  Use when: "quoted trigger phrases".
  Do not use when: {anti-patterns that should use other skills}.
---

# Skill: {Title}

## Purpose
What does this skill do? When should an agent invoke it?

## Pre-conditions
1. What must be true before this skill can run?
2. What environment state is assumed?

## Steps

### Step 1: Validate inputs
What to check first. Include error conditions.

### Step 2: Main operation
The actual work. Include tool calls, code examples, API payloads.

### Step 3: Verify and report
How to confirm success. What to report to the user.

## Error handling
| Error | Cause | Resolution |
|-------|-------|------------|
| Error description | Why it happens | How to fix it |

Extended format (with security boundaries):

Add these optional fields:

version: 1.0.0
phase: connect | build | operate | custom
allowed-tools:
  - bash
  - python
  - file
  # NO web_fetch unless absolutely required (data exfiltration risk)
safety:
  - List explicit safety rules here
  - Be specific about what must be checked before proceeding
requires:
  - dataverse-connect  # Almost always required
  - list-other-prerequisites
priority: normal  # or high to override built-in skills

version: 1.0.0
phase: connect | build | operate | custom
allowed-tools:
  - bash
  - python
  - file
  # NO web_fetch unless absolutely required (data exfiltration risk)
safety:
  - List explicit safety rules here
  - Be specific about what must be checked before proceeding
requires:
  - dataverse-connect  # Almost always required
  - list-other-prerequisites
priority: normal  # or high to override built-in skills

Microsoft’s 2026 Power Platform Roadmap Context

Dataverse Skills is one piece of a larger strategic direction covered in Part 4:

2026 Release Wave 1 (April–September 2026) Key Investments:

1. Agent programmability: Enhancements to Dataverse APIs, MCP servers, and Python SDK
2. Governance for agents: New admin controls, real-time risk assessment, PAYG credit caps
3. GitHub integration: Maturing ALM practices with full audit trails (deploy from Git)
4. New Power Apps vibe coding experience: Team-of-agents approach at vibe.powerapps.com

The directional commitment: As AI agents become core to how software is built, platforms need to be usable through intent, not just interfaces.

For architects: Investing in understanding the agent programming model (Skills format, MCP tools, Python SDK patterns) is not a niche skill. It’s becoming foundational to the Power Platform architect role.

How to Use This Dataverse Skills Guide: Recommended Reading Paths

If you’re a developer new to Dataverse Skills:

1. First, start with Part 1 to understand the paradigm shift and why this approach matters
2. Next, jump to Part 2 for hands-on installation and your first build
3. Then, skim Part 3 while specifically focusing on “The Three-Tool Strategy” and “Decision Matrix” sections
4. Finally, bookmark Part 4 for later when you need to explain this approach to architects

If you’re a solution architect evaluating adoption:

1. Begin with Part 4 to evaluate governance requirements, costs, and ALM integration strategies
2. Subsequently, read Part 1 to grasp the strategic context and business value proposition
3. After that, skim Part 3 with particular attention to “Custom Skills” and “Real-World Examples” sections
4. Additionally, bookmark Part 2 as a reference for when your team needs setup guidance

If you’re building a custom skill library:

1. Initially, start with Part 3 to learn the skill file format and tool selection logic
2. Then, read Part 4 to understand security boundaries including allowed-tools and safety rules
3. Following this, reference Part 2 for practical testing and debugging patterns
4. Lastly, skim Part 1 to gain broader ecosystem context and understand the underlying philosophy

If you’re a CoE lead planning rollout:

1. First, begin with Part 4, Section: Architectural Recommendations to understand enterprise deployment patterns
2. Next, carefully read Part 4, Section: MCP Billing for accurate budget planning and cost forecasting
3. Then, review Part 2 to fully understand developer onboarding requirements and setup complexity
4. Finally, reference Part 3 for guidance on building organizational skill standards and governance frameworks

Additional Resources

Official Documentation

• Dataverse Skills GitHub Repository
• Dataverse MCP Server Documentation
• Dataverse Python SDK Documentation
• Power Platform 2026 Release Wave 1

Community Resources

• Daniel Kerridge’s Power Platform Skills
• Power Platform Developer Blog: Dataverse Skills Announcement
• Dataverse at Build 2025

Tools and SDKs

• Power Platform CLI (PAC CLI)
• Azure CLI
• PowerPlatform-Dataverse-Client (Python SDK)
• Claude Code CLI
• GitHub Copilot

What’s Next: The Future of Intent-Driven Development

The paradigm shift happening with Dataverse Skills extends far beyond Power Platform. Instead, platforms must be operable by agents, not just by humans.

Importantly, we’re already seeing parallel developments across the enterprise software landscape:

• Azure Skills for cloud infrastructure management
• Power Apps code apps

Across all these platforms, the pattern is consistent: encode platform knowledge as agent-consumable instructions. Subsequently, make the platform programmable through intent.

Consequently, for Power Platform professionals, this means:

1. First, the skill library becomes organizational IP. Not just code—rather, the prompts and skills that encode your patterns.
2. Additionally, developer velocity compounds. As a result, each custom skill makes every subsequent project faster.
3. Moreover, governance shifts from review to validation. Therefore, automated schema checks replace manual code review.
4. Finally, onboarding accelerates. Ultimately, new developers describe intent while agents handle execution.

The organizations that master this transition—building skill libraries, establishing governance patterns, training teams on prompt engineering—consequently gain a sustainable competitive advantage in Power Platform development velocity.

That’s precisely why this series matters. Not just for understanding Dataverse Skills today, but rather for preparing your organization for the broader shift toward intent-driven enterprise development.

Start Reading the Series

Ready to dive in? Choose your entry point:

Part 1: From Scripts to Intent: How Dataverse Skills Redefines Enterprise Development

Part 2: Getting Started with Dataverse Skills: Install, Configure, and Build Your First Agent-Driven Solution

Part 3: Under the Hood: How Dataverse Skills Work and How to Write Your Own

Part 4: Dataverse Skills for Enterprise Architects: Governance, ALM, MCP Billing, and Production Readiness

About This Series

This 4-part Dataverse Skills Deep Dive series was published in April 2026 following Microsoft’s release of Dataverse Skills. It synthesizes production learnings from early adopter organizations, technical analysis of the underlying architecture, and practical implementation patterns tested across consulting firms, ISVs, and enterprise CoEs.

All code examples, architectural patterns, and governance recommendations are based on real-world deployments. Cost benchmarks reflect actual usage data from teams of 20-100 Power Platform developers.