Estimated reading time: 13 minutes

Part 1 of 9 in the Entire.io for Power Platform series · Part 2: Installation & Getting Started →

AI coding agents like Claude Code and GitHub Copilot generate Power Platform solutions at speed — but when the session ends, the reasoning behind every plugin stage, Client API pattern, and architecture decision disappears from the git history. Entire.io is a CLI-first system of record that captures those AI coding sessions as permanent, searchable records linked directly to your commits. This article explains why Power Platform developers need this more than most and how Entire fits into the full code-first development stack alongside microsoft/power-platform-skills and microsoft/Dataverse-skills.

The Context Gap in AI-Assisted Power Platform Development

Ask any senior Power Platform developer what the hardest part of maintaining a mature solution is, and the answer is rarely the code itself. Instead, it’s the reasoning behind the code — why a plugin runs in pre-operation instead of post-operation, why a particular Client API pattern was chosen for a form script, why an Azure Function handles a specific edge case the way it does.

Admittedly, this problem has always existed. But AI coding agents have made it dramatically worse.

When Claude Code, GitHub Copilot, Cursor, or Codex helps a developer implement a Dataverse plugin, write a PCF component, or wire up an Azure Function, the resulting code often encodes dozens of decisions the agent made during the session: which files it inspected, what alternatives it evaluated, what constraints it was working around, what the original prompt was. As a result, when the session ends, all of that reasoning evaporates. Specifically, the commit diff shows what changed. Yet nothing shows why.

Consequently, Entire is the system of record built specifically to close that gap. In practice, it’s a CLI-first tool that captures AI coding sessions as permanent, searchable records linked to your Git history. For Power Platform developers working across the full code-first stack — plugins, form scripts, PCF controls, custom APIs, and Azure Functions — it provides the institutional memory that AI-assisted development has been missing.

Why Power Platform Development Needs This More Than Most

Power Platform has a set of characteristics that make the context-loss problem especially acute.

Long-lived solutions. Enterprise Power Platform solutions routinely live in production for five or more years, maintained by rotating teams of developers across multiple wave releases. Code written with an AI agent in 2025 will be modified by a different developer in 2027, in a different platform version, without access to the session that produced the original implementation.

The fusion development model. Microsoft’s fusion development approach — makers and pro-code developers collaborating on the same solution — means work frequently passes between contributors who have different levels of familiarity with the code-first layer. Plugins, form scripts, and PCF controls written by one developer may be extended by another who wasn’t involved in the original sessions.

Platform version sensitivity. Power Platform evolves rapidly across twice-yearly release waves. Implementation decisions are often driven by version-specific behaviors, deprecations, or known bugs that are later fixed. Without session context, future developers have no way to know whether an unusual pattern was intentional or whether it can safely be changed.

Tight coupling to environment state. Dataverse plugins run against a specific entity model, form scripts depend on the specific fields and controls on a form, PCF controls bind to specific data types. The session context that produced a piece of code typically includes the agent reading and reasoning about the environment it was working in. That context is exactly what future maintainers need.

What Entire Captures

Entire introduces the concept of Checkpoints — versioned records of agent-assisted coding sessions, linked permanently to Git commits. Each checkpoint captures:

• The original prompt that initiated the session or a specific turn
• The full agent transcript — every prompt, response, and correction
• The tool calls the agent made — which files it read, what commands it ran, what it searched for
• The file changes produced in the session
• Token usage and session metadata
• Line attribution — how many changed lines were written by the agent versus the human developer

When you commit after an AI-assisted session, Entire appends a trailer to your commit message:

feat: Add territory scoring plugin for opportunity create

Entire-Checkpoint: a3b2c4d5e6f7
Entire-Attribution: 71% agent (43/61 lines)

The checkpoint is stored on the entire/checkpoints/v1 branch in your repository and pushed automatically with your code. Anyone with repository access can review any checkpoint through the Entire.io web interface or the CLI.

The Two Surfaces: CLI and Web

Entire has two complementary surfaces that work together.

The Entire CLI runs locally in your Git repository. It installs lifecycle hooks for Git and for your chosen AI coding agent, captures sessions in the background, and links checkpoints to commits automatically. Key commands include:

Entire.io is the web interface for exploring checkpoint history — browsing sessions, reviewing transcripts, inspecting tool calls, and searching across everything the CLI has captured.

Agent Support Across the Power Platform Developer Toolchain

Entire integrates with all major AI coding agents used by Power Platform developers:

The default agent is Claude Code. To add others: entire agent add copilot-cli.

Skills: Querying Your Session History in Natural Language

Entire’s Skills library turns your captured session history into something queryable through your AI agent. Rather than manually browsing checkpoints, you can ask:

Search skill — “Find every session where we implemented Dataverse plugin pre-operation handlers” — searches across all captured sessions and returns matching checkpoints with their prompts and implementations.

Explain skill — “Explain why this form script uses async event handlers” — traces the specific code back to the session that produced it using Git history and Entire session data, giving you the reasoning behind the current implementation.

What Happened skill — “Why does this method look like this?” — investigates a specific change by combining Git provenance with the full Entire session context.

Session Handoff skill — “Package context for handoff” — bundles the current session so another developer (and their agent) can continue from exactly where you left off, with full context, rather than starting cold.

Session to Skill skill — “Turn this session into a reusable workflow” — converts a successful agent session into a repeatable Skill for future use.

Pairing Entire with the Power Platform Agent Plugin Ecosystem

Entire is the capture layer in the Power Platform AI development stack. Microsoft publishes two open-source build layers as agent plugins, and they pair naturally with it.

microsoft/power-platform-skills (aka.ms/ppskills) is a plugin marketplace for Claude Code and GitHub Copilot CLI with specialist agents for four Power Platform development tracks:

microsoft/Dataverse-skills is a plugin for Claude Code and GitHub Copilot CLI wrapping the Dataverse MCP server, Python SDK, and PAC CLI into named skills:

The combination: power-platform-skills and Dataverse-skills are what the agent does. Entire captures why it did it — the original prompts, the decisions made, the constraints it was working around. When a developer uses dv-metadata to inspect an entity schema before writing a plugin, or dv-solution to pack and export after development, Entire captures both sessions and links them to the commit. The code review and the six-months-later debugging conversation both start from a complete picture of what the agent knew and reasoned about, not just the diff.

# Dataverse Skills — GitHub Copilot CLI
/plugin install dataverse@awesome-copilot

# Dataverse Skills — Claude Code
/plugin install dataverse@claude-plugins-official

# Power Platform Skills — Claude Code or Copilot CLI
curl -fsSL https://raw.githubusercontent.com/microsoft/power-platform-skills/main/scripts/install.js | node

# Dataverse Skills — GitHub Copilot CLI
/plugin install dataverse@awesome-copilot

# Dataverse Skills — Claude Code
/plugin install dataverse@claude-plugins-official

# Power Platform Skills — Claude Code or Copilot CLI
curl -fsSL https://raw.githubusercontent.com/microsoft/power-platform-skills/main/scripts/install.js | node

Without Entire vs. With Entire: The Core Comparison

To make the value concrete, here’s how the same situations play out in each case.

Scenario 1: Debugging a plugin six months later

Without Entire: A developer encounters unusual behavior in a pre-operation plugin. The commit message says fix: Update opportunity scoring logic. The diff shows changes to three methods. The developer spends two hours reverse-engineering the intent, eventually tracking down the original developer on another project for context they may only partially recall.

With Entire: The developer runs entire checkpoint explain <commit-sha>. The full session appears: the original prompt, the agent’s reasoning about why pre-operation was chosen over post-operation, the files it inspected, the edge case it was addressing. Investigation takes fifteen minutes.

Scenario 2: Developer handoff mid-sprint

Without Entire: A developer on leave mid-sprint, their PCF control work incomplete. The receiving developer re-explains the full context to their AI agent — the entity model, the field types, the design decisions made so far — before they can make progress. This reconstruction takes a full morning.

With Entire: The leaving developer runs the Session Handoff skill. The receiving developer’s agent gets the packaged context: what was built, what decisions were made, what remains. They’re productive within minutes.

Scenario 3: Code review of agent-assisted code

Without Entire: A reviewer sees a 60-line plugin diff. 71% of it was agent-written. They have no context about what the agent was asked to do, what alternatives it considered, or whether the implementation correctly addresses the original requirement. Review is slow and uncertain.

With Entire: The reviewer opens the checkpoint in Entire.io. They read the original prompt, follow the transcript, see exactly what the agent was instructed to do and how it reasoned through the implementation. Review is informed and efficient.

Security and Data Model: What Power Platform Teams Need to Know

Data stays in your repository. Checkpoint data is stored on the entire/checkpoints/v1 branch in your Git repository — not on Entire’s servers. Access is controlled by your repository permissions. Private repositories keep checkpoint data private.

Built-in secret detection. Five detection passes run at write time: entropy scoring, 260+ Betterleaks pattern rules (covering Azure, GitHub, Stripe, and others), credentialed URI detection, database connection string detection, and credential variable detection. Secrets are replaced with REDACTED before anything reaches the checkpoint branch.

Custom redaction rules. Power Platform projects frequently involve environment GUIDs, connection reference schema names, service principal credentials, and client secrets. These can be added as custom redaction patterns in .entire/settings.json:

{
  "redaction": {
    "custom_redactions": {
      "env_guid": "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}",
      "sp_secret": "(?i)(client.?secret|app.?secret)[\"']?\\s*[:=]\\s*[\"']?[A-Za-z0-9+/=]{20,}"
    }
  }
}

{
  "redaction": {
    "custom_redactions": {
      "env_guid": "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}",
      "sp_secret": "(?i)(client.?secret|app.?secret)[\"']?\\s*[:=]\\s*[\"']?[A-Za-z0-9+/=]{20,}"
    }
  }
}

Checkpoint remote for enterprise governance. For teams where checkpoint data (session transcripts) should be separated from the solution repository, Entire supports pushing the checkpoint branch to a separate private repository:

entire enable --checkpoint-remote github:myorg/platform-session-records

entire enable --checkpoint-remote github:myorg/platform-session-records

Where This Series Goes

This article is the foundation. The remaining articles in this series go deep on specific Power Platform development scenarios, the web interface for teams, the Skills query layer, and enterprise security:

• Part 2 — Installation & Getting Started: Step-by-step setup for Power Platform repositories, team configuration, and first checkpoint.
• Part 3 — JavaScript/TypeScript: Form Scripts & Web Resources: How Entire transforms the development and maintenance of client-side scripting.
• Part 4 — Dataverse Plugins & Custom APIs: Entire in Dataverse plugin development, step registration, and Custom API workflows.
• Part 5 — PCF Control Development: How Entire fits the iterative lifecycle of Power Apps Component Framework development.
• Part 6 — Azure Function Development: Using Entire in Azure Function development wired to Power Platform connectors and custom APIs.
• Part 7 — The Entire.io Web Interface: How architects, tech leads, and reviewers explore checkpoints and sessions without touching the CLI.
• Part 8 — Entire Skills: Natural language access to your AI coding history — Search, Explain, What Happened, Session Handoff, and Session to Skill.
• Part 9 — Security & Enterprise Governance: Data residency, secret redaction, checkpoint remote, commit signing, and an enterprise ALM governance pattern.

Each article includes concrete before/after comparisons so you can evaluate the value for your specific context.

Further Reading

Official Microsoft Documentation

• Power Platform Application Lifecycle Management (ALM) guide — Microsoft Learn
• Dataverse plug-in development overview — Microsoft Learn
• Power Apps Component Framework overview — Microsoft Learn
• Custom APIs in Dataverse — Microsoft Learn
• Client API reference for model-driven apps — Microsoft Learn
• Fusion development with Power Platform — Microsoft Learn
• Power Platform release plan — Microsoft Learn

AI Coding Agent Documentation

• Claude Code overview — Anthropic
• GitHub Copilot in the CLI — GitHub Docs
• Cursor documentation — Cursor
• Gemini CLI — Google / GitHub
• Codex CLI — OpenAI / GitHub

Power Platform Agent Plugins

• microsoft/power-platform-skills (aka.ms/ppskills) — Official Microsoft agent plugin for Power Pages, Model Apps, Code Apps, and Canvas Apps; works with Claude Code and GitHub Copilot CLI
• microsoft/Dataverse-skills — Official Microsoft agent plugin for Dataverse query, data, metadata, solution lifecycle, admin, and security operations

Related Articles on aidevme.com

• GitHub Copilot Agentic Memory: What It Is and How It Works — How AI agents persist context across sessions; the stateless-AI problem Entire solves at the repository level
• GitHub Copilot CLI Developer Guide: Install, Skills & Workflows — Deep dive into one of the agents Entire integrates with natively
• The Risk Decision Matrix for GitHub Copilot CLI Autopilot Mode in Power Platform — Governance framework for agentic work that Entire’s checkpoint records directly support
• GitHub Copilot Workspace Context: The Complete Developer Guide — How workspace context shapes agent output; complements Entire’s session capture
• Claude Skills: The Complete Developer Guide — Building reusable agent workflows that map directly to Entire’s Skills layer
• agents.md Best Practices: The Complete Developer Playbook — Instruction files that pair with Entire checkpoints for complete agent governance