Zsolt Zombik

Posted on Apr 3

From Scripts to Intent: How AI Agents Are Changing Power Platform Development

#powerplatform #dataverseskills

The Developer Tax We've All Been Paying

If you've built anything on Power Platform, you know the workflow:

Open terminal → pac auth create
Switch to browser → navigate maker portal
Inspect table schema
Jump to docs → find correct API syntax
Write PowerShell script
Run it (column name typo)
Fix it, run again
Export solution (forgot to add the table)
Go back, repeat

This constant context-switching between CLI, browser, docs, and scripts? That's what I call the developer tax on enterprise platforms.

On April 1, 2026, Microsoft's Dataverse team shipped something that fundamentally changes this equation: Dataverse Skills.

(Shout-out to Suyash Kshirsagar from Microsoft for the excellent announcement post)

What If You Could Just... Say What You Want?

Instead of orchestrating six different tools, what if you could describe your intent in natural language?

"I'm building a recruiting system for Zava Construction 
with tables for Positions, Candidates, and Interviewers. 
Positions link to multiple Candidates, and Candidates 
can have multiple Interviewers."

With Dataverse Skills installed, GitHub Copilot or Claude Code:

✅ Creates a new solution with publisher prefix

✅ Generates tables with proper columns and data types

✅ Configures relationships (1:N, N:N)

✅ Loads sample data that matches your domain

✅ Validates the schema

✅ Exports a deployable solution package

All from a single prompt. Zero context-switching.

How It Actually Works

Dataverse Skills is an open-source plugin that gives coding agents structured knowledge of Power Platform development patterns.

Under the hood, it uses the Model Context Protocol (MCP) to expose Dataverse capabilities through a standardized interface that AI agents can invoke.

The Architecture:

┌─────────────────────────────────────┐
│   You (Natural Language Intent)    │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│  AI Agent (GitHub Copilot/Claude)  │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│      Dataverse Skills Plugin       │
│  (Translates intent → actions)     │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│   Dataverse MCP Server + PAC CLI   │
│    (Executes operations)           │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│     Your Dataverse Environment     │
└─────────────────────────────────────┘

Three Core Phases:

CONNECT - Authenticate, discover environments, register with MCP server
BUILD - Create tables, columns, relationships, solutions, forms
OPERATE - Load data, run queries, perform bulk operations

What This Means for Different Roles

👨‍💻 For Developers

Onboarding acceleration: Junior devs can be productive on day one instead of spending weeks learning PAC CLI syntax. They describe what they need; the agent scaffolds it correctly.

Prototyping speed: A full data model with sample data can be stood up in minutes from a single prompt, not hours of maker portal clicking and script debugging.

Knowledge embedded: Best practices are encoded in the agent. No more searching wikis for "how to set up a publisher prefix correctly."

🏗️ For Solution Architects

Consistency by default: The plugin encodes best practices (publisher prefixes, solution structure, ALM hygiene) that propagate automatically across projects.

Governance without friction: Because the agent uses the same tools and patterns every time, architectural standards become self-enforcing rather than requiring constant code reviews.

Focus shift: You move from explaining how to do things to defining what should be done and why — which is where architectural value actually lies.

👥 For Teams

Tool standardization: One plugin investment works for both GitHub Copilot and Claude Code users. Teams get consistent Dataverse capabilities regardless of which AI assistant they've adopted.

Portable knowledge: Architectural patterns become portable across different coding agents rather than locked into a single vendor's ecosystem.

The Broader Shift: Intent-Driven Development

This isn't just about Dataverse. It's about a fundamental shift in how we interact with enterprise platforms.

Traditional approach:

Developer → Manual tool orchestration → Platform

Intent-driven approach:

Developer → Natural language intent → AI agent → Automated orchestration → Platform

The agent becomes the orchestration layer that handles the busywork of tool integration, API syntax, and workflow coordination.

Other examples of this pattern:

Business Skills - Natural language → Copilot Studio conversational apps
Infrastructure-as-Code agents - "Deploy a highly available web app on Azure" → Terraform/Bicep generation
Database agents - "Add an audit log table to track all customer changes" → Schema migrations + triggers

The common thread? You describe the intent; the agent handles the implementation.

Getting Started (15 Minutes)

Install the plugin:

   # For GitHub Copilot
   gh copilot install dataverse-skills

   # For Claude Code  
   claude plugin install dataverse-skills

Authenticate:

   pac auth create --environment yourenv.crm.dynamics.com

Try a prompt:

   "Create a simple inventory tracking system with 
   Products, Categories, and Suppliers tables"

Watch the agent build it - Solution created, tables generated, relationships configured, sample data loaded.

That's it. You're building with natural language.

Real Talk: What This Changes (And What It Doesn't)

What it changes:

✅ Junior developers productive immediately (not after weeks of training)
✅ Prototyping 10x faster (minutes instead of hours)
✅ Best practices enforced automatically
✅ Architects focus on strategy, not syntax

What it doesn't replace:

❌ Understanding business requirements
❌ Architectural decision-making
❌ Security and compliance judgment
❌ Complex integration patterns

Think of it like Copilot for code completion—it handles the boilerplate and common patterns, freeing you to focus on the hard problems that actually require human expertise.

The Ecosystem Play

Dataverse Skills is part of Microsoft's broader MCP ecosystem:

Dataverse MCP Server - The foundation that exposes Dataverse operations
Business Skills - Link natural language to Copilot Studio apps
Azure Skills (coming) - Cloud infrastructure as intent
Third-party MCP servers - Community-built integrations

This creates a composable AI developer experience where different skills can work together through a common protocol.

Imagine:

"Create a recruiting system in Dataverse, 
deploy a web portal to Azure App Service,
and build a Copilot Studio conversational interface 
for candidates to check application status"

Three different skills, one unified intent, end-to-end automation.

My Take: This Is Just the Beginning

I've spent years building on Power Platform—from PCF controls to complex Dataverse solutions to ALM automation.

Every time, the orchestration overhead was the hidden cost. Not the learning curve of the platform itself, but the cognitive load of juggling tools, memorizing syntax, and context-switching constantly.

Dataverse Skills doesn't eliminate complexity—it abstracts the orchestration layer.

And that changes the economics of enterprise platform development in ways we're just starting to understand.

Questions? Thoughts?

Have you tried Dataverse Skills yet? What's been your experience with AI-assisted development on Power Platform?

Drop a comment—I'd love to hear what's working (or not working) for your team. 👇

About the Author

I write at AIDevMe.com about Power Platform development, AI-assisted coding, and enterprise automation. If you found this helpful, follow me for more content on building better with less friction.

Originally published at aidevme.com on April 3, 2026.

DEV Community