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
SECURITY.md
title: Customer Card Render Skill Security Model description: STRIDE threat model for the customer-card-render skill organized by assets, adversaries, and trust buckets (untrusted DT markdown parsing, YAML content emission, CLI caller and filesystem) with in-code mitigations and acknowledged enterprise readiness gaps author: microsoft/hve-core ms.date: 2026-10-27 ms.topic: reference estimated_reading_time: 7 keywords:
security
STRIDE
customer-card-render
threat model
<!-- markdownlint-disable-file -->
Customer Card Render Skill Security Model
This document records the STRIDE threat model for the customer-card-render skill (scripts/generate_cards.py). The model is organized by trust bucket: Untrusted DT markdown parsing (B1), YAML content emission (B2), and CLI caller process and filesystem (B3). Each bucket enumerates all six STRIDE categories with the in-code mitigations that address them. Assets and adversaries are enumerated first. Acknowledged enterprise readiness gaps are listed at the end.
The skill is a pure local file transform: it reads canonical Design Thinking markdown artifacts, extracts frontmatter and sections with regular expressions, escapes the text, fills template content.yaml files, and writes them to an output directory. It handles no credentials, opens no network connection, and spawns no subprocess. It does not build or render a presentation file.
See also: repo-wide STRIDE model. This skill participates in the repository-wide threat model at
docs/security/security-model.mdand is registered in its Skill Security Models section.
Executive Summary
The customer-card-render skill converts untrusted Design Thinking markdown into slide content.yaml. Its highest-risk behavior is emitting attacker-influenced prose into YAML: adversarial artifact content could otherwise break out of a YAML scalar. Every dynamic value is routed through yaml_escape, which escapes backslashes, double-quotes, and newlines, and the templates wrap every placeholder in double quotes, so injected content stays confined to its scalar. Frontmatter is parsed by simple string partitioning (not a YAML loader), so no object construction occurs. The skill performs no network, credential, or subprocess activity. Residual risk concentrates in confidential DT prose flowing into the emitted content.
Security Posture Overview
| Dimension | Value |
|---|---|
| Runtime surface | Local Python CLI; regex parse of untrusted DT markdown; YAML emission; no network, no credentials, no subprocess |
| Trust buckets | B1 untrusted markdown parsing, B2 YAML content emission, B3 caller process and filesystem |
| Credentials | None handled or persisted |
| Network egress | None |
| Open residual gaps | 1 (InfoDisc-Low: unclassified DT content) |
Contents
System Description
Trust Boundaries
Assets
Adversaries
Bucket B1: Untrusted DT markdown parsing
Bucket B2: YAML content emission
Bucket B3: CLI caller process and filesystem
Enterprise Readiness Gaps
References
System Description
Components
scripts/generate_cards.py— reads canonical DT markdown, parses frontmatter and sections with regex, escapes text viayaml_escape, fillstemplates/*.content.yaml, and writesslide-NNN/content.yamlunder the output directory.templates/*.content.yaml— quoted-placeholder templates the script populates.
Data Flow
flowchart TD
subgraph HOST["Operator Workstation / Runner (trust zone)"]
MD["Canonical DT markdown<br/>(untrusted prose)"]
TPL["content.yaml templates"]
CLI["generate_cards.py"]
OUT["Rendered content.yaml"]
end
MD -->|"regex parse + yaml_escape"| CLI
TPL -->|"placeholder fill"| CLI
CLI -->|"writes escaped scalars"| OUTTrust Boundaries
Boundary Diagram
┌───────────────────────────────────────────────────────────┐
│ TRUST BOUNDARY: Operator Workstation / Runner │
│ ┌─────────────┐ ┌──────────────┐ ┌────────────────┐ │
│ │ generate_ │ │ DT markdown │ │ content.yaml │ │
│ │ cards.py │ │ + templates │ │ output │ │
│ └─────────────┘ └──────────────┘ └────────────────┘ │
└───────────────────────────────────────────────────────────┘Boundary Descriptions
| Boundary | Assets Protected | Controls Enforced |
|---|---|---|
| Workstation / Runner | Output integrity, host process | yaml_escape of dynamic values; quoted-placeholder templates; string-partition frontmatter (no YAML loader) |
Assets
| Id | Asset | Lifetime | Notes |
|---|---|---|---|
| A1 | Canonical DT markdown | Read-only during render | Untrusted prose; may contain confidential product/customer content |
| A2 | content.yaml templates | Read-only | Ship with the skill; every placeholder is double-quoted |
| A3 | Rendered content.yaml | Persisted | Written under the operator-chosen output directory |
Adversaries
| Id | Adversary | In-scope mitigations |
|---|---|---|
| ADV-a | Hostile or malformed DT markdown (crafted to break out of YAML) | yaml_escape escapes \, ", and newlines; templates quote every placeholder; frontmatter parsed by string partition, not a YAML loader |
| ADV-b | Caller supplying an adversarial output path | Output path is operator-controlled; the script only writes slide-NNN/content.yaml beneath it |
Bucket B1: Untrusted DT markdown parsing
Spoofing
Not applicable. Markdown content carries no identity claim; it is treated as data.
Tampering
The skill never modifies the source artifacts. Frontmatter is parsed by line-wise
str.partition(":")rather than a YAML loader, so no arbitrary object construction occurs; sections are extracted with bounded regular expressions.
Repudiation
Not applicable. No attribution is claimed over input content.
Information Disclosure
Parsing surfaces only the fields the templates consume; nothing beyond the artifact's own content is read or forwarded.
Denial of Service
Section extraction uses anchored, non-catastrophic regular expressions over a single artifact; input size is bounded by the artifact.
Elevation of Privilege
No input path leads to code execution: there is no
eval, no dynamic import, and no subprocess.
Risk Rating
| Threat | Likelihood | Impact | Residual Risk | Status |
|---|---|---|---|---|
| Malicious frontmatter/section triggers unsafe parse | Low | Low | Low | Mitigated (string partition; no YAML loader) |
Bucket B2: YAML content emission
Spoofing
Not applicable.
Tampering
YAML injection is mitigated: every dynamic value is passed through
yaml_escape(escaping\,", and newlines) before insertion, and every template placeholder is wrapped in double quotes (text: "{{...}}"; the sole unquoted field,slide: {{SLIDE_NUMBER}}, is an integer). Injected content therefore stays inside its scalar and cannot introduce new keys or structure.
Repudiation
Not applicable.
Information Disclosure
Confidential prose from the source artifact flows verbatim (escaped) into the emitted
content.yaml. There is no data-classification gate (G-INF-1).
Denial of Service
Output size is proportional to the input artifact; there is no amplification.
Elevation of Privilege
Emission writes text files only; it performs no execution.
Risk Rating
| Threat | Likelihood | Impact | Residual Risk | Status |
|---|---|---|---|---|
| YAML breakout via artifact prose | Low | Med | Low | Mitigated (yaml_escape + quoted placeholders) |
| Confidential prose emitted without classification gate | Med | Low | Low | By design (G-INF-1) |
Bucket B3: CLI caller process and filesystem
Spoofing
Not applicable. No identity surface.
Tampering
The script writes only
slide-NNN/content.yamlfiles beneath the operator-supplied output directory.
Repudiation
Not applicable. Local tool.
Information Disclosure
No credentials or secrets are handled; the skill makes no network connection.
Denial of Service
File writes are bounded by the number of rendered cards; there is no unbounded resource use.
Elevation of Privilege
The skill runs entirely with the caller's privileges and spawns no process. It passes no content or credentials to any other tool.
Risk Rating
| Threat | Likelihood | Impact | Residual Risk | Status |
|---|---|---|---|---|
| Output written outside the intended location | Low | Low | Low | Mitigated (fixed slide-NNN/content.yaml) |
Enterprise Readiness Gaps
The following are known limitations recorded so operators can make informed deployment decisions. Severity ratings are the project's own assessment and are not equivalent to a CVSS score.
| Id | Gap | Severity | Status |
|---|---|---|---|
| G-INF-1 | Canonical DT artifacts may contain confidential product or customer prose; that content flows verbatim (escaped) into the emitted content.yaml. There is no data-classification gate. | InfoDisc-Low | By design; operators must avoid rendering regulated content and control the output directory. |
For an active issue tracker entry covering these gaps, see the hve-core issues list.
References
Repository security model
🤖 Crafted with precision by ✨Copilot following brilliant human instruction, then carefully refined by our team of discerning human reviewers.
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