Introduction

Using AI to generate a function or explain an error is now routine. Using it as part of a structured, reusable, and verifiable development process is a different challenge.

This article is a practical guide to that second idea. It explains the main building blocks of agentic development in Claude Code (Skills, subagents, permissions, hooks, and MCP) and shows how they connect to two Power Platform capabilities:

  • Power Apps code apps, which let you build custom web apps with code-first tools and run them on Power Platform.
  • Power Automate cloud flows, which a code app can call as a backend.

The goal is educational. Every technical claim is tied to official documentation, listed in the references at the end, because these tools change quickly and you should always check the current docs before relying on a detail.


From prompts to agentic systems

A common way of using AI follows a simple pattern: write a prompt, read the answer, adjust, repeat.

Software development usually needs more than that. We have to understand requirements, explore existing code, change files, run tools, validate results, review security, test scenarios, and document decisions.

Anthropic describes agentic systems as a family with an important architectural distinction (Anthropic, 2024):

  • Workflows are systems where LLMs and tools are orchestrated through predefined code paths.
  • Agents are systems where the LLM dynamically directs its own process and tool usage.

The same article gives a recommendation worth remembering: find the simplest solution possible and increase complexity only when needed, which might mean not building an agentic system at all (Anthropic, 2024). Sometimes a good prompt is enough. Sometimes a fixed workflow is better. Agents make sense for open-ended problems where the number of steps is hard to predict.

What makes an agent different from a chatbot

A chatbot works around a conversation. A development agent can also act on its environment. Depending on the tools and permissions it has, it can read files, search a repository, edit code, run commands, build a project, and run tests.

The important change is the loop between reasoning, actions, and real feedback. Anthropic notes that during execution it is crucial for agents to gain “ground truth” from the environment at each step, such as tool results or code execution, and that they can pause for human feedback at checkpoints or when blocked (Anthropic, 2024).

Goal
  ↓
Analyze context
  ↓
Choose an action
  ↓
Use a tool
  ↓
Observe the real result
  ↓
Goal achieved?
  ├── No → adjust and repeat
  └── Yes → present result for human review

That loop is powerful, and it is also where the risk comes from. An agent that can act needs permissions, boundaries, verification, and human supervision. The same source warns that autonomy brings higher costs and the potential for compounding errors, and recommends extensive testing in sandboxed environments with appropriate guardrails (Anthropic, 2024).


The building blocks in Claude Code

Claude Code is Anthropic’s agentic tool for software development. Beyond the model itself, it offers several extension mechanisms. They solve different problems, and mixing them up is a frequent source of confusion (Anthropic, n.d.-a; Anthropic, n.d.-b).

ElementMain purpose
PromptA one-time instruction
CLAUDE.mdPersistent context and project conventions
SkillReusable knowledge or procedure, loaded when relevant
SubagentSpecialized work in a separate context with its own tools
HooksCommands that run automatically on lifecycle events
MCP serverGives the agent access to external tools and services
PluginA package that distributes skills, agents, hooks, and MCP servers
Permissions and sandboxingTechnical limits on what the agent can actually do

Two of these deserve a closer look.


Skills: from repeated prompts to reusable procedures

If you keep pasting the same instructions, checklist, or multi-step procedure into a chat, that is a good candidate for a Skill (Anthropic, n.d.-b).

A Skill is a directory with a SKILL.md file. The file has YAML frontmatter that tells Claude when to use it, followed by Markdown instructions. The directory can also hold supporting files such as reference documents and scripts (Anthropic, n.d.-b).

.claude/
└── skills/
    └── my-skill/
        ├── SKILL.md          ← required: overview and instructions
        ├── reference.md      ← detailed docs, loaded only when needed
        └── scripts/
            └── helper.*      ← utility script, executed rather than loaded

A few properties from the official documentation matter in practice (Anthropic, n.d.-b):

  • Loading is progressive. Skill descriptions are in context so Claude knows what is available, but the full content loads only when the Skill is invoked. Long reference material costs almost nothing until it is needed.
  • Keep SKILL.md focused. The documentation recommends keeping it under 500 lines and moving details into separate files.
  • The description is what triggers it. Claude uses it to decide when to apply the Skill, so it should say what the Skill does and when to use it.
  • Invocation can be restricted. disable-model-invocation: true prevents Claude from running a Skill on its own. The docs recommend it for workflows with side effects, such as deployments.
  • Scope varies. Personal skills live in ~/.claude/skills/, project skills in .claude/skills/ (commit them so the team shares them), and plugins can distribute them more widely.
  • Skills follow an open standard. Claude Code skills follow the Agent Skills standard and extend it with features such as invocation control and subagent execution.

A Skill does not replace engineering

A Skill creates consistency. It reminds the agent what to review, which procedure to follow, and which references to consult. It does not guarantee a correct result. The model can still misread a requirement or produce defective code, so architecture review, code review, and testing remain necessary.

The documentation also draws a useful line: if a rule must hold every time, put it in a hook rather than relying on Claude to keep following written guidance (Anthropic, n.d.-b).


Subagents: separating responsibilities

A subagent is a specialized assistant that runs in its own context window, with its own system prompt, tool access, and permissions. It returns only a summary to the main conversation (Anthropic, n.d.-a).

Subagents are Markdown files with YAML frontmatter. Only name and description are required. Other useful fields include tools (an allowlist), disallowedTools, model, skills (to preload Skills), permissionMode, and hooks (Anthropic, n.d.-a).

---
name: code-reviewer
description: Reviews code for quality and best practices
tools: Read, Glob, Grep
model: sonnet
---

You are a code reviewer. When invoked, analyze the code and provide
specific, actionable feedback on quality, security, and best practices.

The official guidance on when to use them is clear (Anthropic, n.d.-a):

  • Use subagents when a task produces verbose output you do not need in the main context, when you want to enforce specific tool restrictions, or when the work is self-contained and can return a summary.
  • Stay in the main conversation when the task needs frequent back-and-forth, when several phases share a lot of context, or for quick targeted changes.

Some details are worth knowing:

  • A subagent starts with a fresh context. It does not see your conversation history, only its own system prompt, the task message, and project context such as CLAUDE.md.
  • Each subagent sends its own requests, which count toward the same usage limits as the main conversation.
  • Descriptions should be specific so Claude delegates to the right one. Keep the combined descriptions short, because they consume context.

Skills and subagents are not the same thing

SkillSubagent
What it isReusable instructions and knowledgeA specialized worker
Where it runsUsually in the main conversation contextIn a separate, isolated context
Typical useConventions, checklists, step-by-step recipesReviews, test runs, research, high-volume output
Combining themA Skill can run in a subagent (context: fork)A subagent can preload Skills with the skills field

Both combinations exist, and they are inverses of each other. With context: fork, you write the task in the Skill and choose an agent type to run it. With the skills field, the subagent controls the prompt and loads the Skill content as reference material (Anthropic, n.d.-b).


Where Power Platform fits in

So far, nothing here is specific to Microsoft technology. Power Platform enters as the target that the agent builds for.

Power Apps code apps

Microsoft describes code apps as a way to bring Power Apps capabilities into custom web apps built in a code-first IDE such as Visual Studio Code. You develop locally and run the same app in Power Platform (Microsoft, n.d.-a). Key features include:

  • Microsoft Entra authentication and authorization;
  • access to Power Platform data sources and 1,500+ connectors, callable directly from JavaScript;
  • hosting of line-of-business web apps inside Power Platform;
  • adherence to your organization’s managed platform policies, such as app sharing limits, Conditional Access, and Data Loss Prevention;
  • simplified deployment and application lifecycle management.

Architecturally, a code app is a single-page application (SPA). Three pieces cooperate (Microsoft, n.d.-b):

PieceRole
@microsoft/power-apps client libraryAPIs your code calls, plus generated models and services for each connector you add
power.config.jsonMetadata file generated by the library, used by the CLI and the library for connections and publishing
Power Apps CLI and Power Apps hostThe CLI publishes the compiled app; at runtime the host handles user authentication and app loading

The development cycle

According to the official quickstart (Microsoft, n.d.-c), the cycle looks like this:

# 1. Start from the Vite template
npx degit github:microsoft/PowerAppsCodeApps/templates/vite my-app
cd my-app

# 2. Install the CLI and dependencies, then initialize the app
npm install --global @microsoft/power-apps-cli
npm install --global @microsoft/power-apps
npm install
pa app init --display-name "My App" --environment-id <environment-id>

# 3. Run locally
pa app run

# 4. Build and publish to Power Apps
npm run build
pa app push

The prerequisites listed in the overview are an IDE, Node.js (LTS), Git, and the Power Apps CLI. A Power Platform admin must also enable code apps on the environment, and end users need a Power Apps Premium license or one of the alternatives Microsoft lists, such as pay-as-you-go or an App Pass (Microsoft, n.d.-a).

Know the limitations

Documentation also lists constraints you should check before choosing code apps. At the time of writing, Microsoft states that code apps (Microsoft, n.d.-a):

  • do not support Power Platform Git integration;
  • do not yet support Secure Implicit Connections;
  • do not use Storage SAS IP restriction, so IP-based restrictions should rely on Conditional Access instead;
  • are not supported in Power Apps for Windows;
  • do not support the Power BI PowerBIIntegration function or SharePoint forms integration.

This list can change, so confirm it on the current page.

Code apps and canvas apps are different tools

Canvas appsCode apps
Visual low-code experienceCode-first experience
Power Apps StudioAn IDE such as Visual Studio Code
Power FxJavaScript / TypeScript
Power Apps controlsWeb components and frameworks
Fast development for common business scenariosGreater control over UI and architecture
Less traditional coding requiredRequires web development skills

Neither replaces the other. The decision should start from the requirements, the team that will maintain the solution, the level of customization needed, and the available capabilities. If you want a broader comparison of app types, see Canvas vs Model-driven.


Power Automate flows as the backend of a code app

A code app can call Power Automate cloud flows, which is a clean way to keep business logic and integrations in a governed, low-code layer while the front end stays in code.

According to the documentation (Microsoft, n.d.-d):

  • Only solution-aware instant flows that use the Power Apps trigger are supported. Scheduled flows, automated flows, and instant flows with other triggers are not.
  • The person who adds the flow must have access to the flow and its underlying connections.
  • End users need sufficient Dataverse permissions to invoke it, such as the App Opener security role or an equivalent.
  • After the flow definition changes, you must add the flow again to refresh the generated files.

The CLI workflow is:

pa app list-flows                         # list solution-aware flows
pa app add flow --flow-id <flow-id>       # generate typed models and services

The CLI downloads the flow’s OpenAPI definition, generates strongly typed TypeScript models and services, and records the flow and its connection references in power.config.json. Calling it then looks like any other typed service (Microsoft, n.d.-d):

import { ApprovalWorkflowService } from "./services/ApprovalWorkflowService";

const result = await ApprovalWorkflowService.Run({
  requester: "Alex",
  amount: 1500,
});

if (result.success) {
  console.log("Flow triggered. Response:", result.data);
} else {
  console.error("Flow failed:", result.error);
}

Thinking in contracts helps here. The flow defines its inputs and outputs, the CLI generates types from them, and the front end depends on those types instead of on flow internals. That separation is also easier for an AI agent to reason about and verify.


Ready-made Skills for Power Platform

You do not have to start from a blank page. Microsoft maintains an open-source (MIT) marketplace called Power Platform Skills with plugins for GitHub Copilot and Claude Code (Microsoft, n.d.-e). Among them:

PluginWhat it covers
Code AppsBuild and deploy code apps connected through connectors (React + Vite + TypeScript)
Power AutomateBuild, edit, run, and debug cloud flows through an MCP server
Canvas AppsAuthor canvas apps through a Canvas Authoring MCP server
Model AppsBuild model-driven apps end to end
DataverseQuery and change records, manage tables, security, and solutions

Installation from inside a Claude Code or GitHub Copilot CLI session follows this pattern (Microsoft, n.d.-e):

/plugin marketplace add microsoft/power-platform-skills
/plugin install code-apps-preview@power-platform-skills
/plugin install power-automate@power-platform-skills

Some practical notes from the repository itself:

  • Plugin names, status (some are labeled preview), and requirements change over time, so read each plugin’s page before installing.
  • Use a free developer environment for learning rather than an environment with live apps or data.
  • Read each permission request before approving it. Auto-approval options give the agent the same access you have on your machine and are only advised in trusted or sandboxed environments.
  • Some plugins send usage telemetry by default, and each has a way to turn it off.

Even if you use these plugins, understanding how a Skill is built helps you read, audit, and adapt them.


Putting it together: a Skill and a reviewer for code apps

Here is a conceptual example of how the pieces could combine for a code app project. It is a sketch, not an official template.

Project layout

.claude/
├── skills/
│   ├── code-app-build/
│   │   ├── SKILL.md
│   │   ├── references/
│   │   │   ├── architecture.md
│   │   │   ├── security.md
│   │   │   └── flows.md
│   │   └── scripts/
│   │       └── verify-project.*
│   └── code-app-deploy/
│       └── SKILL.md            ← manual-only, because it publishes
└── agents/
    ├── code-app-reviewer.md
    └── code-app-tester.md

A build Skill

---
name: code-app-build
description: Build or modify a Power Apps code app (React + TypeScript + Vite). Use when creating a code app, adding a connector or a Power Automate flow, or refactoring its architecture.
---

## Workflow

1. Read the requirements and ask about anything ambiguous.
2. Keep UI components separate from data access. Put connector and flow
   calls behind interfaces so they can be replaced in tests.
3. Add data sources and flows with the Power Apps CLI. Never edit
   generated models or services by hand.
4. Use synthetic data for development and tests.
5. Run `npm run build` and the project's verification script before
   reporting that work is complete.

## References

- Architecture rules: see [references/architecture.md](references/architecture.md)
- Security checklist: see [references/security.md](references/security.md)
- Calling Power Automate flows: see [references/flows.md](references/flows.md)

A manual-only deploy Skill

Publishing changes an environment, so it should not be something Claude decides to do on its own. The documentation recommends disable-model-invocation: true for exactly this kind of workflow (Anthropic, n.d.-b):

---
name: code-app-deploy
description: Publish the code app to the target Power Platform environment
disable-model-invocation: true
---

1. Confirm the target environment ID with the user.
2. Run `npm run build`.
3. Run `pa app push`.
4. Report the resulting URL.

A read-only reviewer subagent

---
name: code-app-reviewer
description: Reviews a Power Apps code app for architecture, security, permissions, and maintainability. Use after significant changes and before any deployment.
tools: Read, Grep, Glob
skills:
  - code-app-build
---

You are a critical reviewer. Do not modify files.

Review the changes for:

- separation between UI, business logic, and integrations;
- handling of sensitive data and secrets;
- permission and role assumptions;
- input validation and error handling;
- anything that conflicts with the preloaded Skill.

Report findings grouped as Critical, Warning, and Suggestion, each with
a file reference and a recommended fix.

Because this subagent has no Edit, Write, or Bash tool, it cannot change files or run commands. A separate tester subagent would need Bash to run the app and the tests, which is a good reason to keep the two roles apart.

Overall flow

Developer (human approval)
        │
        ▼
Main agent (Claude Code)
        │  uses
        ▼
Build Skill (workflow + references + scripts)
        │
        ├──► Reviewer subagent  → findings
        └──► Tester subagent    → results
                    │
                    ▼
        Human review and decision

The main agent coordinates, the Skill provides the procedure, the subagents provide specialized and independent perspectives, scripts provide deterministic checks, and a person makes the final call.


Guardrails: a prompt is not a security control

This is the most important lesson in the article.

Telling an agent “never do X” can shape its behavior, but it should not be your only barrier. The Claude Code documentation is explicit: permission rules are enforced by Claude Code, not by the model. Instructions in a prompt or CLAUDE.md shape what Claude tries to do, but they do not change what Claude Code allows (Anthropic, n.d.-c).

Useful mechanisms include:

  • Permission rules. Rules are evaluated in the order deny, then ask, then allow, and the first match wins (Anthropic, n.d.-c).
  • Subagent tool restrictions. A tools allowlist or disallowedTools denylist limits what each subagent can do (Anthropic, n.d.-a).
  • Hooks. A PreToolUse hook can inspect a command before it runs and block it by exiting with code 2 (Anthropic, n.d.-a).
  • Sandboxing. It provides OS-level enforcement for shell commands and still applies if a prompt injection bypasses the model’s decision-making (Anthropic, n.d.-c).
  • Separate environments and least-privilege credentials, which are not specific to Claude Code but matter just as much. This is why Microsoft’s plugin repository recommends developer environments for experimentation (Microsoft, n.d.-e).

A starting point for the Power Platform case might be to require confirmation before anything is published. This configuration is illustrative only. Adapt the rules to the real commands and permissions of your project; they do not replace sandboxing, environment restrictions, or human approval.

{
  "permissions": {
    "allow": ["Bash(npm run *)"],
    "ask": ["Bash(pa app push *)"],
    "deny": ["Bash(git push *)"]
  }
}

Be aware of the limits. The documentation explains that a Bash rule matches the command text Claude writes and “isn’t a security boundary around the program”: the same program invoked in another form, such as through sh -c or by full path, may not match. For guarantees that do not depend on command text, use sandboxing or a hook (Anthropic, n.d.-c).

Also, review third-party Skills before using them. The documentation warns that a project skill can pre-approve tools through allowed-tools, even in a folder you have not trusted, so you should review the allowed-tools of skills checked into a repository before running Claude Code there (Anthropic, n.d.-b).


Probabilistic AI and deterministic controls

A model is good at interpreting code, comparing alternatives, spotting suspicious patterns, and explaining findings. For many other questions, a traditional tool gives an objective answer:

Does the project build?              → run the build.
Do the tests pass?                   → run the test runner.
Are there lint errors?               → run the linter.
Did a file change?                   → ask Git.
Is a required setting present?       → validate it with a script.

There is little value in asking a model to imagine a result that you can verify directly. A useful rule of thumb is: use AI to reason, and deterministic tools to verify whenever possible. Anthropic makes a similar point about coding agents: code is verifiable through automated tests, which lets an agent iterate on results, but human review remains crucial for making sure solutions align with broader system requirements (Anthropic, 2024).


Evaluating your Skills and agents

A Skill that triggers is not necessarily a Skill that works. The Claude Code documentation suggests measuring two things separately: whether Claude invokes the Skill on the prompts it should, and whether the output matches your expectation when it does (Anthropic, n.d.-b).

The recommended method is a baseline comparison:

  1. Collect a few realistic prompts.
  2. Run each one in a fresh session with the Skill available, and again with it turned off.
  3. Compare the results.

A fresh session matters because leftover context from writing the Skill can hide gaps in its instructions. The documentation also describes tools that automate this loop, such as claude plugin eval for Skills distributed in plugins and the skill-creator plugin for iterating on a single Skill (Anthropic, n.d.-b).

For the application itself, rely on the classic tools: unit tests, end-to-end tests, linting, static analysis, and CI/CD. An agent can write and run tests, but a passing agent-run test is evidence, not certification.


Human supervision remains part of the architecture

The aim is not to remove people from the process. It is to place human attention where it adds the most value.

An agent can explore twenty files, a script can validate a hundred settings, and a subagent can do a first review. A person still has to decide:

  • Did we understand the requirement correctly?
  • Does this architecture make sense?
  • Do we accept this risk, and does this finding actually apply?
  • Are these permissions appropriate for this data?
  • Is there enough evidence to deploy?
  • What happens if it fails?

AI increases capability. It does not transfer responsibility.


How to start

Avoid beginning with five agents, twenty Skills, and a large architecture. A gradual path works better:

  1. Use a single agent on a task you already understand well, in a developer environment with synthetic data.
  2. Notice which instructions you repeat. If a procedure keeps coming back, turn it into a Skill.
  3. Delegate selectively. If a side task floods your context or needs a different responsibility, such as reviewing, consider a subagent with restricted tools.
  4. Convert checks into code. If something can be validated by a script or a test, do that instead of asking the model for its opinion.
  5. Lock down the dangerous steps. Use permission rules, hooks, and separate environments for anything that publishes, deletes, or touches real data.
  6. Measure. Compare results with and without the Skill, and iterate.

Agentic architecture should emerge from a need, not be a prerequisite for saying you use Agentic AI.


Things to keep in mind

  • These tools evolve quickly. Claude Code releases frequently, and the Power Platform plugins and code app features are updated often. Verify details such as version requirements and limitations in the current documentation.
  • Cost and context are real constraints. Subagents and long Skills consume tokens and usage limits.
  • Licensing and governance still apply. Code apps require the right environment settings and end-user licensing, and they follow your organization’s managed platform policies.
  • Generated does not mean reviewed. Code produced by an agent still needs the same review, testing, and security checks as any other code.

Conclusion

Agentic AI is not only about giving a model more autonomy. It is about designing the relationship between model, context, knowledge, tools, verification, permissions, and human supervision.

Skills turn recurring procedures into reusable knowledge. Subagents separate responsibilities and keep context clean. Hooks, permissions, and sandboxing provide real controls that a prompt cannot. And Power Platform gives that process a concrete target: a code app for the front end and Power Automate flows for governed business logic.

The question worth asking is no longer just “what code can AI generate for me?” but “what engineering process can I build so AI helps me deliver better software?”


References

Anthropic. (2024, December 19). Building effective agents. https://www.anthropic.com/research/building-effective-agentss>

Anthropic. (n.d.-a). Create custom subagents. Claude Code Docs. Retrieved November 6, 2026, from https://code.claude.com/docs/en/sub-agentss>

Anthropic. (n.d.-b). Extend Claude with skills. Claude Code Docs. Retrieved November 6, 2026, from https://code.claude.com/docs/en/skillss>

Anthropic. (n.d.-c). Configure permissions. Claude Code Docs. Retrieved November 6, 2026, from https://code.claude.com/docs/en/permissionss>

Microsoft. (n.d.-a). Power Apps code apps overview. Microsoft Learn. Retrieved November 6, 2026, from https://learn.microsoft.com/en-us/power-apps/developer/code-apps/overvieww>

Microsoft. (n.d.-b). Power Apps code apps architecture. Microsoft Learn. Retrieved November 6, 2026, from https://learn.microsoft.com/en-us/power-apps/developer/code-apps/architecturee>

Microsoft. (n.d.-c). Quickstart: Create a code app using the Power Apps CLI. Microsoft Learn. Retrieved November 6, 2026, from https://learn.microsoft.com/en-us/power-apps/developer/code-apps/how-to/create-an-app-from-scratchh>

Microsoft. (n.d.-d). Add Power Automate flows to a code app. Microsoft Learn. Retrieved November 6, 2026, from https://learn.microsoft.com/en-us/power-apps/developer/code-apps/how-to/add-flowss>

Microsoft. (n.d.-e). Power Platform Skills [Source code repository]. GitHub. Retrieved November 6, 2026, from https://github.com/microsoft/power-platform-skillss>