# Customer Card Render

> Generate customer-card PowerPoint content YAML from Design Thinking canonical artifacts and build using the shared PowerPoint skill pipeline

- **Type:** Skill
- **Install:** `agentstack add skill-microsoft-hve-core-customer-card-render`
- **Verified:** Pending review
- **Seller:** [microsoft](https://agentstack.voostack.com/s/microsoft)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [microsoft](https://github.com/microsoft)
- **Source:** https://github.com/microsoft/hve-core/tree/main/.github/skills/experimental/customer-card-render

## Install

```sh
agentstack add skill-microsoft-hve-core-customer-card-render
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# 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 collections independently.
* Layout primitives, `Invoke-PptxPipeline.ps1`, theming, and validation behavior are not reimplemented here.

For full PowerPoint pipeline documentation, see [powerpoint/SKILL.md](../powerpoint/SKILL.md).

## Prerequisites

* Python 3.11+
* `uv` package manager — install with one of:

  ```bash
  # macOS / Linux
  curl -LsSf https://astral.sh/uv/install.sh | sh

  # Windows
  powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

  # Via pip (fallback)
  pip install uv
  ```

* The experimental `powerpoint` skill at `.github/skills/experimental/powerpoint/` for the `Invoke-PptxPipeline.ps1` build step

## 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 3-Slide Layout

Each Use Case expands into 3 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, 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 .github/skills/experimental/customer-card-render/scripts/generate_cards.py \
  --canonical-dir .copilot-tracking/dt//canonical \
  --output-dir .copilot-tracking/dt//render/content
```

#### generate_cards.py CLI Reference

| Flag              | Required | Default                        | Description                                       |
|-------------------|----------|--------------------------------|---------------------------------------------------|
| `--canonical-dir` | No       | `/canonical`       | Directory containing canonical DT markdown files  |
| `--output-dir`    | No       | `/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 3 consecutive slides per use case.

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

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

```powershell
./.github/skills/experimental/powerpoint/scripts/Invoke-PptxPipeline.ps1 -Action Build `
  -ContentDir .copilot-tracking/dt//render/content `
  -StylePath .copilot-tracking/dt//render/content/global/style.yaml `
  -OutputPath .copilot-tracking/dt//render/output/customer-cards.pptx
```

The PowerShell orchestrator manages virtual environment setup and dependency installation automatically via `uv sync`. See [powerpoint/SKILL.md](../powerpoint/SKILL.md) for the full `Invoke-PptxPipeline.ps1` parameter reference, template usage, validation, and export options.

## DT Coach Integration

The `dt-canonical-deck` prompt and the `dt-coaching-foundation` skill's `canonical-deck` reference provide 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//canonical/`.

## Running Tests

```bash
cd .github/skills/experimental/customer-card-render
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 `curl -LsSf https://astral.sh/uv/install.sh \| sh` (macOS/Linux) or `pip install uv` |
| 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 path incorrect | Confirm `powerpoint/` skill exists at `.github/skills/experimental/powerpoint/`          |

> Brought to you by microsoft/hve-core

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [microsoft](https://github.com/microsoft)
- **Source:** [microsoft/hve-core](https://github.com/microsoft/hve-core)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: flagged — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-microsoft-hve-core-customer-card-render
- Seller: https://agentstack.voostack.com/s/microsoft
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.