Customer Card Render
MicrosoftOfficialPublished by Microsoft
- Skill
- Content generator
- Documents and content
- MIT
- Low risk
- Has scripts
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
The customer-card-render skill automates the transformation of canonical Design Thinking markdown files into template-driven content.yaml files. It acts as a mapping layer that extracts specific sections from artifacts like vision statements, problem statements, scenarios, personas, and use cases, organizing them into structured slide content. This tool is designed to be renderer-neutral, producing reviewable YAML files that can be consumed by downstream presentation authoring tools. It does not handle the visual rendering or styling of the final presentation, focusing instead on data extraction and content organization.
What it does
- Parses canonical Design Thinking markdown files for structured content.
- Maps extracted sections to predefined content.yaml templates.
- Supports multiple artifact types including Vision, Problem, Scenario, Persona, and Use Case.
- Splits complex Use Case artifacts into a structured 4-slide layout.
- Normalizes text content to ensure consistent formatting in generated YAML.
- Provides a CLI for batch processing of project-specific artifacts.
When to use it
- When you need to convert raw Design Thinking markdown documentation into structured slide content.
- When preparing content for automated presentation generation workflows.
- When you require a consistent, template-driven structure for customer-facing cards.
- When integrating with Design Thinking coaching agents to automate slide content creation.
Advantages
- Decouples content mapping logic from presentation rendering tools.
- Ensures consistent slide structure across different Design Thinking artifacts.
- Produces renderer-neutral, reviewable YAML artifacts.
- Automates the tedious task of manual slide content population.
Usage examples
- “Generate slide content for the current project's Design Thinking artifacts.”
- The script processes the markdown files in the canonical directory and outputs structured content.yaml files to the designated output folder.
Install
Download the skill as a ZIP:
https://autogineer.com/agent-skills/microsoft/customer-card-render/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip customer-card-render.zip -d .agents/skills
Documentation by Microsoft
Customer Card Render Skill
Converts canonical Design Thinking markdown artifacts into template-driven content.yaml slide definitions.
Overview
This skill handles the Design Thinking-specific mapping layer: extracting sections from canonical markdown artifacts and filling template-driven content.yaml files. It does not build, theme, export, or validate a presentation file. The separate hve-slides skill owns HTML presentation authoring and rendering.
Keeping this layer separate means:
Customer-card mapping logic stays independent from any presentation tooling.
The skill can be included in packages independently.
The generated YAML stays a reviewable, renderer-neutral artifact.
Prerequisites
Python 3.11+
uvpackage manager, installed with a package manager that verifies the download against a published hash:# Windows winget install --id astral-sh.uv -e # macOS / Linux (Homebrew) brew install uvTo install from a release archive instead, download it from the uv releases page and check it against its
.sha256file before extracting.
Directory Structure
.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.pySupported 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).
Generate Slide YAML
Generate slide YAML from canonical markdown
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/contentResolve <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.
The generated content.yaml files are this skill's final output. For an explicitly requested HTML presentation, hand reviewed YAML to hve-slides authoring. For a levelled demo, use hve-demo-material and its references/slide-content.md adapter contract. Resolve skills by name, preserve canonical order, source labels and unknown-knowledge markers, and never claim a presentation exists until rendered and validated. This mapping skill does not synthesize narration or dispatch a deck subagent.
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 generate customer-card YAML at method exit points. The generation command 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
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.
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 |
Files
- ATTRIBUTION.mdAdded by AutoGineer849 B
- LICENSELicence file added by AutoGineer1.1 KiB
- SECURITY.md13.1 KiB
- SKILL.md7.7 KiB
- pyproject.toml837 B
- references/mapping-spec.md5.7 KiB
- scripts/generate_cards.pyScript15.0 KiB
- templates/global-style.yaml292 B
- templates/persona.content.yaml2.4 KiB
- templates/problem.content.yaml1.1 KiB
- templates/scenario.content.yaml2.0 KiB
- templates/use-case-slide1.content.yaml1.8 KiB
- templates/use-case-slide2.content.yaml2.8 KiB
- templates/use-case-slide3.content.yaml2.4 KiB
- templates/use-case-slide4.content.yaml1.6 KiB
- templates/vision.content.yaml1.6 KiB
- tests/corpus/.gitkeep0 B
- tests/fuzz_harness.pyScript1.0 KiB
- tests/test_generate_cards.pyScript12.8 KiB
- uv.lock57.5 KiB
references/mapping-spec.md
description: "Canonical markdown section-to-field mapping for customer-card generation"
<!-- markdownlint-disable-file -->
Customer Card Mapping Spec
This spec defines only canonical section extraction and field mapping.
Layout, sizing, theming, rendering, export, and validation behavior are out of scope; this skill emits renderer-neutral content.yaml.
Canonical Source Structure
canonical/
├── vision-statement.md
├── problem-statement.md
├── scenarios/
│ └── *.md
├── use-cases/
│ └── *.md
└── personas/
└── *.mdMetadata Mapping
Support both metadata naming variants:
Artifact typeorSource artifact typeSource pathorSource file pathLast updated(fallback to current date)
Text Normalization Behavior
The generator normalizes section content before rendering:
Hard-wrapped prose lines are unwrapped into single-line paragraphs.
Paragraph boundaries are preserved.
Markdown list item boundaries are preserved.
This avoids visual line wrapping artifacts caused by canonical markdown hard wraps while preserving intentional list formatting.
Field Mapping by Card Type
Vision Statement
Required sections:
Title: frontmatter
title, else first heading## Vision Statement(primary vision)### Why This Matters(secondary rationale)
Generator Implementation: _vision_sections() extracts both sections into individual placeholders: V_VISION_STATEMENT, V_WHY_THIS_MATTERS.
Template Design: Two textboxes on a single slide with dedicated headers ("Vision Statement" and "Why This Matters"). Each section displays separately with appropriate sizing.
Problem Statement
Required sections:
Title: frontmatter
title, else first heading## Problem Statement(the problem to solve)
Generator Implementation: _problem_sections() extracts the Problem Statement section into placeholder: P_PROBLEM_STATEMENT.
Template Design: Single textbox on a slide. Well-suited to accommodate typical problem statements without overflow.
Scenario
Required sections in order:
### Description### Scenario Narrative### How Might We
Generator Implementation: _scenario_sections() extracts all three sections into individual placeholders: SC_DESCRIPTION, SC_SCENARIO_NARRATIVE, SC_HOW_MIGHT_WE.
Template Design: Three section-title textboxes plus three dedicated content textboxes on a single slide. "Description", "Scenario Narrative", and "How Might We" use the same visual section-title styling pattern as Use Case field sections.
Use Case
Use Case artifacts are split across 4 slides. Each slide has dedicated sections with no aggregation or truncation.
Slide 1: Use Case Overview
Required sections:
### Use Case Description### Use Case Overview### Business Value### Primary User
Generator Implementation: _use_case_slide1() extracts these sections into the slide1 template placeholders: UC_DESCRIPTION, UC_OVERVIEW, UC_BUSINESS_VALUE, UC_PRIMARY_USER.
Slide 2: Use Case Execution
Required sections:
### Secondary User### Preconditions### Steps### Data Requirements
Generator Implementation: _use_case_slide2() extracts these sections into the slide2 template placeholders: UC_SECONDARY_USER, UC_PRECONDITIONS, UC_STEPS, UC_DATA_REQUIREMENTS.
The slide 2 template also uses UC_PRIMARY_USER to display the primary user alongside
secondary user for continuity across use-case parts.
Slide 3: Use Case Quality & Context
Required sections:
### Equipment Requirements### Operating Environment### Success Criteria### Pain Points
Generator Implementation: _use_case_slide3() extracts these sections into the slide3 template placeholders: UC_EQUIPMENT_REQUIREMENTS, UC_OPERATING_ENVIRONMENT, UC_SUCCESS_CRITERIA, UC_PAIN_POINTS.
Slide 4: Use Case Extensions & Evidence
Required sections:
### Extensions### Evidence
Generator Implementation: _use_case_slide4() extracts these sections into the slide4 template placeholders: UC_EXTENSIONS, UC_EVIDENCE.
Template Design: Two textboxes on a slide with dedicated headers. Extensions receives more vertical space (2.8") to accommodate typical extension content, while Evidence uses a smaller section (0.7").
Note: All Use Case slides appear consecutively in the final deck (e.g., Use Case "Project Alpha" generates slides 5, 6, 7, 8).
Persona
Required sections:
### Description### User Goal### User Needs### User Mindset
Generator Implementation: _persona_sections() extracts all four sections into individual placeholders: PE_DESCRIPTION, PE_USER_GOAL, PE_USER_NEEDS, PE_USER_MINDSET.
Template Design: Four textboxes on a single slide, each with a dedicated header and section content. Sections stack vertically without aggregation or truncation.
Narrative Ordering
Output ordering follows DT discovery progression with Use Cases expanded into 4 slides:
Vision Statement (slide 1)
Problem Statement (slide 2)
Scenarios (alphabetical, one slide each)
Use Cases (alphabetical, 4 slides each per Use Case)
Personas (alphabetical, one slide each)
Example with 2 scenarios, 1 use case, 1 persona:
Slide 1: Vision Statement
Slide 2: Problem Statement
Slide 3: Scenario "Customer onboarding"
Slide 4: Scenario "Post-launch support"
Slide 5-8: Use Case "Enterprise deployment" (4 slides)
Slide 9: Persona "Infrastructure engineer"
Missing Data Contract
If canonical sections use <insufficient knowledge>, preserve it verbatim in generated slide fields. The generator must not invent replacement content.
Requirements and compatibility
Written for: GitHub Copilot
Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta
“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.
Needs: Needs a command-line tool, Needs Python
The author says: Requires Python 3.11+ and uv
Security
What our scanner noticed· Low risk
- Scripts that your agent may run
This skill includes scripts that your agent may run. Read them before you use it.
A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.
Attribution and licence
- Published by
- Microsoft
- Publisher
- Microsoft (Official)
- Source
- microsoft/hve-core · .github/skills/experimental/customer-card-render · commit f425e94
- Licence
- MIT License (redistribution allowed)
- LICENSE (added by AutoGineer from LICENSE)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
AutoGineer is not affiliated with or endorsed by Microsoft or Microsoft.
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download customer-card-render.zip