Skip to main content
skill CX Codex

page-decomposition — Claude Code skill: section analysis for page

A helper skill for the page-import pipeline: it splits a single section into content sequences and describes them neutrally, without block names.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add adobe/skills --skill page-decomposition -a claude-code
Open on GitHub

What page-decomposition does

The skill sits inside the page-import pipeline for AEM Edge Delivery Services. It takes one section and breaks its content into sequences: where prose ends and a grid begins, where one repeating pattern gives way to another. Each sequence gets a plain-language description — two images side by side, a grid of 8 items with icons — and no block names. Authoring decisions come later, on purpose.

Input is the section's boundaries, a screenshot and cleaned HTML. Output is a structure with the section number and a list of sequences, each numbered and described. Breaking points get recorded too: a shift in content type, prose turning into a structured pattern, one pattern replacing another.

You don't call it yourself. It runs as step 2b inside identify-page-structure, which walks sections one at a time; invoking it directly isn't the intended path. If you expected ready-made block markup out of it, that's a different step.

What it helps with

  • split a section into content sequences before authoring
  • spot breaking points between prose and structured patterns
  • describe section content neutrally without block names
  • prepare a foundation for block decisions at the next step
  • analyze one section in isolation from the rest of the page

Example prompts for the agent

  • decompose section 2 into content sequences and describe them neutrally
  • where does the prose end and the grid start in this section?
  • run page-decomposition on section 3 with this screenshot and HTML

How to install page-decomposition

1Skills CLI (Vercel)

npx skills add adobe/skills --skill page-decomposition -a claude-code

2Manually: put the files in place

~/.claude/skills/page-decomposition/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/page-decomposition/

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

Questions about page-decomposition

How do I install page-decomposition in Claude?

Use the skills installer: npx skills add adobe/skills --skill page-decomposition -a claude-code. The skill file then lives at ~/.claude/skills/page-decomposition/SKILL.md.

What does page-decomposition do?

It analyzes a single section and splits its content into sequences, describing each one neutrally without assigning block names. It also marks the breaking points between sequences.

Can I invoke page-decomposition directly?

No. It is meant to be called by identify-page-structure for each section separately, not run on its own.

Source text

SKILL.md · Apache-2.0
---
name: page-decomposition
description: "Use this when the page-import pipeline needs to analyze the content sequences within a single section and describe them neutrally for AEM Edge Delivery Services. Covers identifying breaking points between default content and blocks, one section at a time. Do not invoke directly — called by page-import per section."
license: Apache-2.0
metadata:
  version: "1.0.0"
---

# Page Decomposition

Analyze content sequences within a section and provide neutral descriptions without assigning block names.

## When to Use This Skill

This skill is called by **identify-page-structure** for EACH section to:
- Identify content sequences within that section
- Provide neutral descriptions (NO block names yet)
- Identify breaking points between sequences
- Enable authoring-focused decisions later

**IMPORTANT:** This skill analyzes ONE section at a time, not the whole page.

## Input Required

From the calling skill (identify-page-structure), you need:
- Section visual description and boundaries
- Screenshot showing the section
- Cleaned HTML content for the section

## Related Skills

- **page-import** - Top-level orchestrator
- **identify-page-structure** - Invokes this skill for each section (Step 2b)
- **block-inventory** - Provides available blocks AFTER decomposition
- **content-modeling** - Makes authoring decisions AFTER decomposition
- **content-driven-development** - References section structure in html-structure.md

## Key Concepts

**Content Hierarchy:**
```
DOCUMENT
├── SECTION (top-level, analyzed by identify-page-structure Step 2a)
│   ├── Content Sequence 1 ← THIS SKILL IDENTIFIES THESE
│   ├── Content Sequence 2 ← THIS SKILL IDENTIFIES THESE
│   └── ...
└── SECTION
    └── Content Sequence 1
```

**What is a "content sequence"?**
A vertical flow of related content that will eventually become:
- Default content (headings, paragraphs, lists, inline images), OR
- A block (structured, repeating, or interactive component)

**Breaking points between sequences:**
- Visual/semantic shift in content type
- Change from prose → structured pattern
- Change from one pattern → different pattern

**Philosophy:**
- Describe WHAT you see, not WHAT it should be
- "Two images side-by-side" not "Columns block"
- "Grid of 8 items with icons" not "Cards block"
- Stay neutral - authoring decisions come later

## Decomposition Workflow

**Context:** identify-page-structure has already identified section boundaries (Step 2a). This skill is invoked FOR ONE SECTION to analyze its internal content sequences.

---

### Step 1: Examine the Section

Look at the screenshot and HTML for THIS section only.

**What to observe:**
- Vertical flow of content from top to bottom
- Where content changes type or pattern
- Visual groupings or breaks

**Ignore:**
- Other sections (out of scope)
- Section styling (already identified by page-import)
- Block names (stay neutral)

**Output:** Mental model of content flow within this section

---

### Step 2: Identify Breaking Points

Find where content shifts from one type/pattern to another.

**Breaking point indicators:**
- Prose text → Structured grid
- Heading/paragraph → Side-by-side images
- One repeating pattern → Different repeating pattern
- Structured content → Prose text

**Example within a section:**
```
Content flows top to bottom:
- Large heading
- Paragraph
- Two buttons
[BREAK] ← Visual/semantic shift
- Two images displayed side-by-side
```

**Output:** List of breaking points

---

### Step 3: Define Content Sequences

Between each breaking point is a content sequence.

**For each sequence, describe:**
- What elements it contains (heading, paragraph, images, etc.)
- How they're arranged (stacked, side-by-side, in a grid)
- Quantity (one heading, two images, grid of 8 items)

**Use neutral language:**
- ✅ "Two images displayed side-by-side"
- ❌ "Columns block with two images"
- ✅ "Grid of 8 items, each with icon and short text"
- ❌ "Cards block"
- ✅ "Large centered heading, paragraph, two buttons stacked vertically"
- ❌ "Hero block"

**Output:** Neutral descriptions for each sequence

---

### Step 4: Return Structured Output

Provide content sequences for this section in structured format.

**Output format:**
```javascript
{
  sectionNumber: 1,  // From identify-page-structure
  sequences: [
    {
      sequenceNumber: 1,
      description: "Large centered heading, paragraph, two buttons stacked vertically"
    },
    {
      sequenceNumber: 2,
      description: "Two images displayed side-by-side"
    }
  ]
}
```

**This enables:**
- Clear understanding of section's internal structure
- Neutral foundation for authoring decisions
- Separation of description from implementation

---

## Section Metadata Format

**Table format:**
```markdown
+------------------------------+
| Section Metadata             |
+------------------+-----------+
| style            | light     |
+------------------+-----------+
```

**Placement:** At the start of each section, before content

**Usage:** Applied by generate-import-html skill when generating final HTML

---

## Examples

### Example 1: Hero Section

**Input:** "Section 1 (light background): Large prominent content at top of page"

**Visual observation:**
- Large centered heading
- Paragraph text below it
- Two call-to-action buttons
[BREAK - visual shift]
- Two large images displayed next to each other

**Output:**
```javascript
{
  sectionNumber: 1,
  sequences: [
    {
      sequenceNumber: 1,
      description: "Large centered heading, paragraph, two call-to-action buttons stacked vertically"
    },
    {
      sequenceNumber: 2,
      description: "Two large images displayed side-by-side"
    }
  ]
}
```

---

### Example 2: Features Section

**Input:** "Section 2 (light background): Grid of feature items"

**Visual observation:**
- Centered heading
[BREAK - shift to structured pattern]
- Grid of 8 items
- Each item has: small icon, short text description
[BREAK - shift back to simple elements]
- Two centered buttons

**Output:**
```javascript
{
  sectionNumber: 2,
  sequences: [
    {
      sequenceNumber: 1,
      description: "Single centered heading"
    },
    {
      sequenceNumber: 2,
      description: "Grid of 8 items, each with small icon and short text description"
    },
    {
      sequenceNumber: 3,
      description: "Two centered buttons"
    }
  ]
}
```

---

### Example 3: Article Cards Section

**Input:** "Section 3 (grey background): Blog articles"

**Visual observation:**
- Eyebrow text "Latest Articles"
- Large heading
- Paragraph description
- Browse button
[BREAK - shift to repeating pattern]
- 4 items in grid
- Each item: image, category tag, heading, short description, read link

**Output:**
```javascript
{
  sectionNumber: 3,
  sequences: [
    {
      sequenceNumber: 1,
      description: "Eyebrow text, large heading, paragraph description, browse button - all stacked vertically"
    },
    {
      sequenceNumber: 2,
      description: "Grid of 4 items, each with image, category tag, heading, description, and read link"
    }
  ]
}
```

---

### Example 4: Simple Content Section

**Input:** "Section 4 (light background): Body content"

**Visual observation:**
- Multiple paragraphs of text
- Some inline images within the text
- Headings interspersed (H2, H3)
- No clear breaking points - content flows naturally

**Output:**
```javascript
{
  sectionNumber: 4,
  sequences: [
    {
      sequenceNumber: 1,
      description: "Flowing prose content: multiple paragraphs with inline images and headings (H2, H3)"
    }
  ]
}
```

**Note:** This entire section is one sequence because content flows naturally without structural breaks.

---

## Common Mistakes to Avoid

**Using block names in descriptions:**
❌ "Hero block with heading and buttons"
✓ "Large centered heading, paragraph, two buttons stacked vertically"

**Not identifying breaking points:**
❌ Describing entire section as one sequence when there are clear shifts
✓ Identifying where content type changes and breaking into sequences

**Being too granular:**
❌ Each element as separate sequence: "Heading", "Paragraph", "Button"
✓ Related elements together: "Heading, paragraph, two buttons stacked vertically"

**Mixing analysis levels:**
❌ Analyzing multiple sections at once
✓ Focus on ONE section at a time (per invocation)

**Making authoring decisions:**
❌ "This should be a cards block because..."
✓ "Grid of 4 items with images and text" (neutral description)

© adobe · Apache-2.0 · adobe/skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set46

preview-import Starts a local AEM dev server to verify imported HTML in Edge Delivery Services. Checks block rendering, inspects metadata, and catches 404 errors. CX Codex +1 1,600installs authoring-analysis Decides what counts as default content and what needs a block before import HTML is generated for AEM Edge Delivery Services. Runs as a page-import step. CX Codex +1 1,600installs find-test-content Finds existing pages using a specific block in AEM Edge Delivery Services projects. Reports page URLs, block counts, and active variants for development and testing. CX Codex +1 1,600installs identify-page-structure Splits a scraped webpage into sections and content sequences for AEM Edge Delivery Services import. Runs as a pipeline step, not by hand. CX Codex +1 1,600installs block-collection-and-party Finds reference blocks, plugins, and code patterns for AEM Edge Delivery Services across Block Collection and Block Party. Helps bootstrap EDS component development. CX Codex +1 1,600installs testing-blocks Runs linting, real-browser validation and unit tests on AEM Edge Delivery Services changes. Useful right before you open a pull request. CX Codex +1 1,600installs analyze-and-plan Defines acceptance criteria, authoring rules, and a Definition of Done before coding AEM Edge Delivery Services blocks. Useful for scoping changes and catching edge cases early. CX Codex +1 1,600installs content-modeling Walks you through designing content models for AEM Edge Delivery Services blocks so authors can fill them in without guesswork. CX Codex +1 1,600installs

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor