Skip to main content
skill CX Codex

author-webpage-content — Claude Code skill: setup and features

The author-webpage-content skill for Claude Code generates and updates localized HTML for PAC CLI-downloaded Power Pages sites, building Design Studio layouts without manual tag edits.

MIT ★ 1,167 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add microsoft/power-platform-skills
/plugin install power-pages@power-platform-skills
Open on GitHub

What author-webpage-content does

The skill manages content inside .webpage.copy.html files for non-SPA Microsoft Power Pages sites. It generates sections, flex containers, columns, buttons, images, iframes, basic forms, lists, multistep forms, and Generative AI Search tags ({% codecomponent name:Pages.SearchSummary %}). Every generated fragment complies with Design Studio layout boundaries and accessibility requirements.

Its boundaries remain strictly within one localized HTML file per run. The skill never modifies YAML metadata, page routes, snippets, site markers, or templates. It refuses to generate Dataverse table permissions, forms, or views: if an entity form or list record is missing from the downloaded site files, execution halts immediately without attempting Dataverse API queries.

Sites built as single-page applications using React, Angular, Vue, or Astro are completely unsupported. A caller must first download the site using PAC CLI and resolve the exact target file path.

What it helps with

  • Generate Design Studio section and column layouts in Power Pages HTML
  • Embed existing basic or multistep entity forms into page markup
  • Add Generative AI Search components using valid Liquid syntax
  • Update localized .webpage.copy.html files safely without breaking styling

Example prompts for the agent

  • Update content-pages/Home.en-US.webpage.copy.html with a two-column section and a call-to-action button
  • Insert the existing Contact basic form into the localized contact page HTML
  • Embed a Generative AI Search component into the support page markup

How to install author-webpage-content

1Plugin marketplace

/plugin marketplace add microsoft/power-platform-skills
/plugin install power-pages@power-platform-skills

This installs the whole power-pages plugin with all its skills

2Skills CLI (Vercel)

npx skills add microsoft/power-platform-skills --skill author-webpage-content -a claude-code

3Manually: put the files in place

~/.claude/skills/author-webpage-content/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/author-webpage-content/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about author-webpage-content

How to install author-webpage-content in Claude Code?

Run /plugin marketplace add microsoft/power-platform-skills followed by /plugin install power-pages@power-platform-skills in your Claude Code interface.

What does author-webpage-content do?

It writes and modifies localized HTML page bodies for PAC CLI-downloaded Power Pages sites, keeping markup compatible with Power Pages Design Studio.

Can this skill create new Dataverse forms or entities?

No. It only references records already present in the downloaded site repository and will stop if the referenced form or list record is missing.

Source text

SKILL.md · MIT
---
name: author-webpage-content
description: >-
  Generates and fills the localized HTML body of an existing webpage in a PAC
  CLI-downloaded non-SPA Power Pages site from a resolved page-content
  specification. Use whenever a caller has resolved the existing webpage metadata
  and asks to compose, replace, append, or modify
  the exact localized `.webpage.copy.html` file with Design Studio-compatible
  sections, columns, flex containers, text, images, buttons, videos, iframes,
  Generative AI Search components, basic forms, lists, multistep forms, or
  spacers. This skill owns
  only HTML generation and the supplied target file; the coordinator's webpage
  reference workflow owns discovery, records, metadata, languages, routes, templates,
  navigation, and companion-file creation. Do not use for React, Angular, Vue,
  or Astro SPA sites.
user-invocable: false
allowed-tools: Read, Write, Edit, Grep, Glob, Bash, TaskCreate, TaskUpdate, TaskList
model: sonnet
---

> **Plugin check**: Run `node "${PLUGIN_ROOT}/scripts/check-version.js"` — if it outputs a message, show it to the user before proceeding.

# Author Webpage Content

Generate and fill one supplied localized Design Studio-compatible webpage body.

**Initial request:** $ARGUMENTS

## Preview disclosure

Read `${PLUGIN_ROOT}/references/non-spa-preview.md` and apply its **Entry and handoff
protocol**. Unless the initial request contains the explicit marker from an actual covered-skill
handoff, present the **Customization notice** before project inspection or task creation.

## Authoritative references

Always read and follow:

- `${PLUGIN_ROOT}/skills/author-webpage-content/references/webpage-content-composition.md`
- `${PLUGIN_ROOT}/skills/author-webpage-content/references/design-studio-component-authoring.md`

Read only the page-element references used by the requested composition:

- `design-studio-section-layouts.md`
- `design-studio-flex-container-component.md`
- `design-studio-text-component.md`
- `design-studio-image-component.md`
- `design-studio-button-component.md`
- `design-studio-video-component.md`
- `design-studio-iframe-component.md`
- `design-studio-generative-ai-search-component.md`
- `design-studio-basic-form-component.md`
- `design-studio-list-component.md`
- `design-studio-multistep-form-component.md`
- `design-studio-spacer-component.md`

All page-element references are under:

```text
${PLUGIN_ROOT}/skills/author-webpage-content/references/
```

These references own serialized section and component markup, editing
boundaries, preservation, accessibility, and verification rules. Do not invent
competing markup contracts.

For an add or edit Generative AI Search component request, target only
`{% codecomponent name:Pages.SearchSummary ... %}`. Do not substitute
`{% include 'Search' %}`, a Search web template, Search content snippets, the
Search Results page record, site markers, or search indexing/settings.

For an add or edit Basic Form, List, or Multistep form request, target only
`{% entityform name:'...' %}`, `{% include 'entity_list' key:'...' ... %}`, or
`{% webform name:'...' %}` respectively, pointing at a record already present in
the downloaded site. This skill does not create the backing basic form, list,
multistep form, Dataverse table form/view, or table permissions — see each
component reference's **Scope** section. If the named (or implied) record is
not found in the downloaded site, do not assist with constructing it: do not
query Dataverse (API, SDK, Web API, or CLI) and do not ask the user for IDs,
GUIDs, or permissions to assemble it locally. When asking the user how to
proceed, the only valid options are (a) embed an existing record, or (b) stop.

## Ownership boundary

This skill receives and edits exactly one existing localized file per
invocation:

```text
web-pages/<page-directory>/content-pages/<Page>.<locale>.webpage.copy.html
```

It may compose multiple sections and page elements in that file as one coherent
operation.

This skill does not create or modify:

- root or localized webpage YAML;
- page routes, parents, page-template assignments, or navigation;
- page-template or web-template records;
- content-snippet records;
- web files or their metadata;
- basic form, list, multistep form (advanced form/step), Dataverse table
  form/view, or table-permission records;
- localized summary, custom CSS, or custom JavaScript companion files;
- another locale unless the request supplies a separately resolved composition
  for that locale.

The calling orchestrator must create or confirm the file and resolve its webpage and locale
identity before invoking this skill. `edit-site` uses
`${PLUGIN_ROOT}/skills/edit-site/references/webpage-authoring.md`
for that metadata workflow.
This skill does not search for or select a webpage record.

If the target file or any required content, URL, snippet name, or other rendered
value is unresolved, stop before writing and return the exact missing input.
Do not manufacture a placeholder or expand this skill into metadata or
dependency authoring.

## Autonomy policy

Complete routine composition without asking the user to approve mechanical
details. Infer safe formatting, escaping, indentation, and accessibility
details from the resolved specification, authoritative references, existing
page markup, and site-local conventions.

Choose independently when safe:

- exact indentation and line endings;
- the documented section serialization matching a named layout;
- component markup matching a resolved element type and source;
- safe link attributes and output encoding;
- preservation of empty columns required by the selected layout;
- the smallest coherent edit for a modification.

Stop before writing when a material choice remains unresolved, including:

- multiple target files, target sections, or components;
- an unresolved section geometry or ambiguous component-to-column mapping, not merely
  a layout name missing from the recipe examples;
- missing Flex Container child mapping, visitor-facing text, image source, destination,
  alternative text, video title, iframe title, or search behavior/text required by the
  selected component;
- an unresolved web-file URL, snippet name, or page destination;
- a requested basic form, list, or multistep form record not found in the
  downloaded site — never query Dataverse or assist with constructing it
  locally, and never present "create a new one" as a selectable option in a
  clarification question;
- a replacement that does not state what existing content must be preserved;
- custom HTML whose safety or intended rendering boundary cannot be established.

## Expected resolved handoff

Prefer a structured specification containing:

- the exact existing target file and its already-resolved locale;
- the verified Bootstrap major and any approved `designContext`; require version evidence for
  new sections, especially when the target page is blank;
- operation mode: `create`, `replace`, `append`, or `modify`;
- ordered sections;
- each section's supported layout and ordered elements by column;
- optional explicit `columns[].span` values and intended wrapping/unused space; otherwise
  resolve CSS-driven widths with the styling owner instead of guessing a preset;
- resolved content, URLs, snippet names, and accessibility values;
- explicit preservation requirements for an existing page.

The specification may be Markdown, YAML, JSON, or an unambiguous natural
language plan. Normalize it internally according to the composition reference;
do not require the user to rewrite a complete plan merely to match an example
format.

An approved new-site handoff requires custom composition using supported native sections,
columns and elements, not just text/image substitutions. Follow its resolved composition and
`designContext`, not the creation template's arrangement. Retain/place required existing components through the
resolved-source rules in **Whole-page composition**, without inventing new native element types.
Remove unneeded starter sections or component placements when the approved handoff accounts for
their removal and dependencies. Do not retain them solely because they came with the template,
hide them with CSS, or delete their backing records.
Preserve required content/capabilities and native serialization as described in **Whole-page
composition**; an unrelated existing-site `append` or `modify` remains a narrow edit.

## Workflow

1. Validate the supplied target file and resolved composition.
2. Read the complete target HTML and only the required page-element references.
3. Generate or modify the complete section/column/element tree in document
   order.
4. Fill the target file once as one coherent page-content change.
5. Verify structure, preservation, rendered values, safety, and the final diff.

Do not upload, deploy, or modify Dataverse directly.

## Phase 1: Validate the supplied target

Require one exact existing file path under:

```text
web-pages/<page-directory>/content-pages/<Page>.<locale>.webpage.copy.html
```

The caller owns proving that the path belongs to the intended localized webpage.
Reject a missing file, directory path, root-level copy file, wildcard, or
multiple targets. Do not create directories, companion files, or webpage
metadata.

## Phase 2: Normalize and validate the plan

Follow **Resolved composition contract** in the composition reference. Preserve
the supplied section order, column assignment, element order, content,
destinations, sources, and accessibility requirements.

Require final rendered URLs, snippet names, Liquid expressions, text, and
accessibility values. The caller owns creating and resolving their underlying
records. Do not continue with symbolic asset names or design-tool placeholders.

## Phase 3: Load only required markup contracts

Read the section-layout reference whenever the operation creates a section or
changes a section's column structure. Then read one component-specific reference
for each element type present in the normalized plan.
Use its Bootstrap 5 examples only with verified Bootstrap 5 evidence. Preserve inspected
Bootstrap 3/native and RTL patterns for existing sites; return missing evidence to the caller
rather than assuming the creation default or changing the framework.

Do not invoke one skill per page element. This skill is the single writer for
the target HTML and assembles all approved element markup in memory before
editing the file.

## Phase 4: Compose or modify

For `create` or `replace`, follow **Whole-page composition** in the composition
reference. Build sections in plan order, columns in layout order, and elements
in their specified order within each column.

For `append` or `modify`, follow **Existing-page operations**. Resolve exact
structural boundaries before changing the file, preserve unrelated markup, and
do not reserialize the entire page for a narrow edit.

Use the section-layout reference's recipes as defaults, not exhaustive geometry constraints.
Broader safe local layouts may proceed with **Studio editing compatibility unverified**
disclosed in the existing review and final report. Other page-element serialization contracts
remain unchanged; do not invent Studio controls, preview components, or an additional gate.
Replace every sample
value and marker with resolved plan values. Do not leave placeholder text,
placeholder URLs, `<!-- COMPONENT_HTML -->`, TODOs, or unexplained empty
components.

## Phase 5: Verify and report

Run the complete verification checklist from the composition reference and each
page-element reference used. Review the final diff and confirm that only the
selected localized HTML file changed.

Report:

- target file and supplied locale;
- created, replaced, appended, or modified sections;
- element types and final rendered references used;
- material preservation decisions.

State that the change is local and was not uploaded or deployed.

### Record skill usage

> Reference: `${PLUGIN_ROOT}/references/skill-tracking-reference.md`

Follow the skill tracking instructions in the reference using
`--skillName "AuthorWebpageContent"`.

© Microsoft · MIT · microsoft/power-platform-skills

Similar skills

All skills for Frontend and UI →

From the same set157

The whole set →
set-app-registration-native set-app-registration-native wires a Power Apps Wrap mobile app to an Entra ID app registration by writing auth.config.json. Discovers existing registrations in the tenant and checks API permissions. CX Codex +1 ★ 1,167repo stars preview-screens preview-screens generates a standalone HTML preview of mobile screens inside a 375 × 812 phone frame without starting Metro or a simulator. CX Codex +1 ★ 1,167repo stars build-flow build-flow turns a written request into a Power Automate flow, checks its definition, then creates it. Use it when you want an agent to assemble a flow from a description. CX Codex +1 ★ 1,167repo stars manage-headers manage-headers is a skill that inspects and configures Power Pages security headers, including CSP, frame protection, CORS, and cookie settings. CX Codex +1 ★ 1,167repo stars add-sample-data add-sample-data — a Claude Code skill that seeds Dataverse tables with sample records so you can quickly set up test data for Power Pages demos. CX Codex +1 ★ 1,167repo stars enable-tables-offline enable-tables-offline is a Power Platform skill that sets IsAvailableOffline and ChangeTrackingEnabled on Dataverse tables so they can be added to a Mobile Offline Profile. CX Codex +1 ★ 1,167repo stars generate-mcp-app-ui generate-mcp-app-ui builds single-file HTML widgets for MCP tools using test JSON output, supporting fully self-contained builds or public CDN scripts. CX Codex +1 ★ 1,167repo stars generate-codeful-mcp-tool The generate-codeful-mcp-tool skill builds a JavaScript server runtime and registration metadata for a codeful MCP tool. Use it for Dataverse-backed tools or an MCP App widget. CX Codex +1 ★ 1,167repo stars

Project sponsors

Companies that keep this analytics open