Skip to main content
skill CX Codex

customer-card-render — Claude Code skill for Design Thinking PowerPoint cards

customer-card-render turns canonical Design Thinking markdown artifacts into PowerPoint slide YAML. The shared powerpoint skill pipeline then assembles the final deck.

MIT ★ 1,627 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add microsoft/hve-core --skill customer-card-render -a claude-code
Open on GitHub

What customer-card-render does

The skill reads Design Thinking artifacts — Vision Statement, Problem Statement, Scenario, Use Case, Persona — and maps their sections into template-driven content.yaml files. The generate_cards.py script scans markdown files under .copilot-tracking/dt/<project-slug>/canonical, detects each artifact type from its frontmatter, and pulls out the required fields.

A Use Case becomes 4 slides in a row: description, overview, business value and primary user first; then secondary user, preconditions, steps, data requirements; then equipment, environment, success criteria, pain points; finally extensions and evidence. Cards follow the artifact type order, with alphabetical sorting by title inside each type.

This skill does not render PPTX itself. The build runs through Invoke-PptxPipeline.ps1 from the powerpoint skill — you activate that skill by name and hand it three paths: content directory, style path, output path. If powerpoint is missing, the build step stops with a warning.

Prerequisites are Python 3.11+, the uv package manager, and the experimental powerpoint skill. Install uv through a package manager that checks the download hash.

What it helps with

  • Generate slide YAML from canonical markdown artifacts
  • Expand a Use Case into 4 consecutive slides
  • Keep card mapping separate from PowerPoint rendering
  • Produce content.yaml files for the powerpoint pipeline
  • Order cards by type and title

Example prompts for the agent

  • Generate card YAML from .copilot-tracking/dt/<project-slug>/canonical into .copilot-tracking/dt/<project-slug>/render/content
  • Run generate_cards.py with --canonical-dir on the artifact directory, then build the PPTX through the powerpoint skill

How to install customer-card-render

1Skills CLI (Vercel)

npx skills add microsoft/hve-core --skill customer-card-render -a claude-code

2Manually: put the files in place

~/.claude/skills/customer-card-render/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/customer-card-render/

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

Questions about customer-card-render

How do I install customer-card-render in Claude Code?

Run npx skills add microsoft/hve-core --skill customer-card-render -a claude-code. The skill lands in ~/.claude/skills/customer-card-render/SKILL.md.

What does customer-card-render do?

It reads canonical Design Thinking markdown files and produces content.yaml for the powerpoint skill. Rendering, theming and export belong to powerpoint itself.

What does it need to work?

Python 3.11+, uv, and the experimental powerpoint skill. Without powerpoint the deck cannot be built — the skill warns and stops.

Source text

SKILL.md · MIT
---
name: customer-card-render
description: 'Generate customer-card PowerPoint content YAML from Design Thinking canonical artifacts and build using the shared PowerPoint skill pipeline'
license: MIT
compatibility: 'Requires Python 3.11+, uv, and the experimental powerpoint skill'
metadata:
  authors: "microsoft/hve-core"
  spec_version: "1.0"
  last_updated: "2026-10-02"
---

# Customer Card Render Skill

Converts canonical Design Thinking markdown artifacts into PowerPoint skill `content.yaml` slide definitions and builds the final deck through the shared PowerPoint build pipeline.

## Overview

This skill is a sibling to the experimental powerpoint skill. It handles the Design Thinking-specific mapping layer: extracting sections from canonical markdown artifacts and filling template-driven `content.yaml` files. The PowerPoint skill then owns layout rendering, theming, export, and validation.

Keeping these concerns separate means:

* Customer-card mapping logic stays independent from general PowerPoint capabilities.
* The skill can be included in packages independently.
* Layout primitives, `Invoke-PptxPipeline.ps1`, theming, and validation behavior are not reimplemented here.

For full PowerPoint pipeline documentation, activate the `powerpoint` skill by name. When it does not resolve, warn the user that the pipeline documentation and build behavior are unavailable and stop rather than reimplementing them here.

## Prerequisites

* Python 3.11+
* `uv` package manager, installed with a package manager that verifies the download against a published hash:

  ```bash
  # Windows
  winget install --id astral-sh.uv -e

  # macOS / Linux (Homebrew)
  brew install uv
  ```

  To install from a release archive instead, download it from the [uv releases page](https://github.com/astral-sh/uv/releases) and check it against its `.sha256` file before extracting.

* The experimental `powerpoint` skill, activated by name, for the `Invoke-PptxPipeline.ps1` build step. When it does not resolve, warn the user that the build step is unavailable and stop.

## Directory Structure

```text
.github/skills/experimental/customer-card-render/
├── SKILL.md
├── pyproject.toml
├── references/
│   └── mapping-spec.md
├── scripts/
│   └── generate_cards.py
├── templates/
│   ├── global-style.yaml
│   ├── persona.content.yaml
│   ├── problem.content.yaml
│   ├── scenario.content.yaml
│   ├── use-case-slide1.content.yaml
│   ├── use-case-slide2.content.yaml
│   ├── use-case-slide3.content.yaml
│   └── vision.content.yaml
└── tests/
    ├── fuzz_harness.py
    └── test_generate_cards.py
```

## Supported Artifact Types

| Artifact Type     | Slide Layout             |
|-------------------|--------------------------|
| Vision Statement  | Single slide             |
| Problem Statement | Single slide             |
| Scenario          | Single slide             |
| Use Case          | **4 slides** (see below) |
| Persona           | Single slide             |

### Use Case 4-Slide Layout

Each Use Case expands into 4 consecutive slides with distinct sections:

| Slide       | Content                                                                      |
|-------------|------------------------------------------------------------------------------|
| **Slide 1** | Use Case Description, Use Case Overview, Business Value, Primary User        |
| **Slide 2** | Secondary User, Preconditions, Steps, Data Requirements                      |
| **Slide 3** | Equipment Requirements, Operating Environment, Success Criteria, Pain Points |
| **Slide 4** | Extensions, Evidence                                                         |

Cards are ordered by artifact type (Vision → Problem → Scenario → Use Case → Persona), then alphabetically by title within each type. Use Cases appear with all 4 slides consecutive (Slide N, N+1, N+2, N+3).

## Two-Command Flow

### Step 1: Generate slide YAML from canonical markdown

```bash
python "<customer-card-render-skill-root>/scripts/generate_cards.py" \
  --canonical-dir .copilot-tracking/dt/<project-slug>/canonical \
  --output-dir .copilot-tracking/dt/<project-slug>/render/content
```

Resolve `<customer-card-render-skill-root>` from the loaded skill location before running the command.

#### generate_cards.py CLI Reference

| Flag              | Required | Default                        | Description                                       |
|-------------------|----------|--------------------------------|---------------------------------------------------|
| `--canonical-dir` | No       | `<skill-root>/canonical`       | Directory containing canonical DT markdown files  |
| `--output-dir`    | No       | `<skill-root>/scripts/content` | Directory to write generated `content.yaml` files |
| `-v`, `--verbose` | No       | —                              | Enable debug-level logging                        |

The script reads each markdown file in `--canonical-dir`, detects the artifact type from frontmatter, extracts required sections, and generates `content.yaml` files. Vision, Problem, Scenario, and Persona artifacts produce one slide each. Use Case artifacts produce 4 consecutive slides per use case.

For the section-to-field mapping contract and Use Case 4-slide layout details, see [references/mapping-spec.md](references/mapping-spec.md).

### Step 2: Build PPTX using the PowerPoint skill pipeline

Activate the `powerpoint` skill by name and hand it the build, supplying these three inputs:

* Content directory: `.copilot-tracking/dt/<project-slug>/render/content`
* Style path: `.copilot-tracking/dt/<project-slug>/render/content/global/style.yaml`
* Output path: `.copilot-tracking/dt/<project-slug>/render/output/customer-cards.pptx`

The `powerpoint` skill owns the `Invoke-PptxPipeline.ps1` orchestrator, its parameter reference, template usage, validation, and export options, and it manages virtual environment setup and dependency installation automatically via `uv sync`. When that skill is unavailable, warn the user that the build step cannot run and stop rather than invoking the pipeline from a guessed location.

## DT Coach Integration

The `dt-coaching-foundation` skill's `canonical-deck` reference provides opt-in workflow integration for the Design Thinking coaching agent. When a user opts in, the coaching agent offers to build customer cards at method exit points. The two-command flow above runs as part of that workflow with `--canonical-dir` and `--output-dir` resolved from the active DT project slug in `.copilot-tracking/dt/`.

Canonical artifacts are produced by the DT coach and live under `.copilot-tracking/dt/<project-slug>/canonical/`.

## Running Tests

```bash
cd "<customer-card-render-skill-root>"
uv sync --group dev
uv run pytest tests/
```

Tests cover parsing, template selection, YAML emission, and regressions. The `tests/fuzz_harness.py` file is an Atheris polyglot fuzz harness for OSSF Scorecard compliance.

## Content Fidelity Note: Use Case Cards

Use Case cards are split across 3 opinionated slides, each with dedicated sections:

- **Slide 1**: Introduces the use case with Description, Overview, Business Value, and Primary User
- **Slide 2**: Details execution with Secondary User, Preconditions, Steps, and Data Requirements
- **Slide 3**: Captures quality criteria with Equipment Requirements, Operating Environment, Success Criteria, Pain Points, and Evidence

This structure ensures all 16 Use Case sections fit legibly across 4 slides without compression. Each section appears in its own textbox with appropriate styling and heading.

For complete mapping details, see [references/mapping-spec.md](references/mapping-spec.md).

## Troubleshooting

| Issue                           | Cause                                     | Solution                                                                                                                 |
|---------------------------------|-------------------------------------------|--------------------------------------------------------------------------------------------------------------------------|
| `uv` not found                  | uv not installed                          | Run `winget install --id astral-sh.uv -e` (Windows) or `brew install uv` (macOS/Linux)                                   |
| Python not found by uv          | No Python 3.11+ on PATH                   | Run `uv python install 3.11`                                                                                             |
| Template not found              | `--canonical-dir` contains unknown type   | Check frontmatter `type:` field against supported artifact types                                                         |
| Empty output directory          | No canonical markdown files found         | Confirm `--canonical-dir` path and that files have `---` frontmatter                                                     |
| PPTX build fails after generate | PowerPoint skill missing or not activated | Activate the `powerpoint` skill by name. When its content does not arrive, stop and report the build step as unavailable |

© microsoft · MIT · microsoft/hve-core

Similar skills

All skills for Office documents →

From the same set148

The whole set →
feasibility Structures and validates durable data and ML feasibility studies using constrained YAML and UUID-tracked provenance. CX Codex +1 ★ 1,627repo stars GitHub Backlog Executor The GitHub Backlog Executor subagent applies a prepared set of operations to GitHub issues and sub-issues in one confirmed repository. Use it to carry out backlog changes through GitHub. CX Codex +1 ★ 1,627repo stars backlog-plan backlog-plan plans backlog work in Azure DevOps, GitHub, and Jira without modifying remote trackers. Generates local plan files for sprints, triage, and task handoffs. CX Codex +1 ★ 1,627repo stars review-artifacts review-artifacts is a Claude Code rule that stores code review results in a defined folder layout. It applies to files under .copilot-tracking/reviews/code-reviews/. CX Codex +1 ★ 1,627repo stars evaluation-design evaluation-design designs evaluation datasets and metric guides for conversational agents and retrieval-grounded apps. Structures scoping interviews and validates test pairs. CX Codex +1 ★ 1,627repo stars pester This rule guides Claude Code in writing PowerShell tests with Pester. Use it to keep test files, mocks, and cleanup consistent with the repository. CX Codex +1 ★ 1,627repo stars typescript-doc-comments typescript-doc-comments — a Claude Code rule for writing TypeScript documentation comments following the TSDoc standard. Describes function behavior, constraints, and intent that the type signature alone cannot express. CX Codex +1 ★ 1,627repo stars engagement-reporting engagement-reporting generates source-backed weekly project engagement reports and prepares optional Outlook email drafts. CX Codex +1 ★ 1,627repo stars

Project sponsors

Companies that keep this analytics open