Generated banner for Customer Card Render
Generated logo for Customer Card Render

Customer Card Render

MicrosoftOfficialPublished by Microsoft

  • Skill
  • Content generator
  • Documents and content
  • MIT
  • Low risk
  • Has scripts

From the author

Generate customer-card slide content YAML from Design Thinking canonical artifacts
— the description by Microsoft

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

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/microsoft/customer-card-render/download
  2. Unzip 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+

  • uv package 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 uv

    To install from a release archive instead, download it from the uv releases page and check it against its .sha256 file 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.py

Supported Artifact Types

Artifact TypeSlide Layout
Vision StatementSingle slide
Problem StatementSingle slide
ScenarioSingle slide
Use Case4 slides (see below)
PersonaSingle slide
Use Case 4-Slide Layout

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

SlideContent
Slide 1Use Case Description, Use Case Overview, Business Value, Primary User
Slide 2Secondary User, Preconditions, Steps, Data Requirements
Slide 3Equipment Requirements, Operating Environment, Success Criteria, Pain Points
Slide 4Extensions, 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/content

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

generate_cards.py CLI Reference
FlagRequiredDefaultDescription
--canonical-dirNo<skill-root>/canonicalDirectory containing canonical DT markdown files
--output-dirNo<skill-root>/scripts/contentDirectory to write generated content.yaml files
-v, --verboseNo—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

IssueCauseSolution
uv not founduv not installedRun winget install --id astral-sh.uv -e (Windows) or brew install uv (macOS/Linux)
Python not found by uvNo Python 3.11+ on PATHRun uv python install 3.11
Template not found--canonical-dir contains unknown typeCheck frontmatter type: field against supported artifact types
Empty output directoryNo canonical markdown files foundConfirm --canonical-dir path and that files have --- frontmatter

Files

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.md and 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
DimensionValue
Runtime surfaceLocal Python CLI; regex parse of untrusted DT markdown; YAML emission; no network, no credentials, no subprocess
Trust bucketsB1 untrusted markdown parsing, B2 YAML content emission, B3 caller process and filesystem
CredentialsNone handled or persisted
Network egressNone
Open residual gaps1 (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
  1. scripts/generate_cards.py — reads canonical DT markdown, parses frontmatter and sections with regex, escapes text via yaml_escape, fills templates/*.content.yaml, and writes slide-NNN/content.yaml under the output directory.

  2. 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"| OUT

Trust Boundaries

Boundary Diagram
┌───────────────────────────────────────────────────────────┐
│ TRUST BOUNDARY: Operator Workstation / Runner             │
│  ┌─────────────┐   ┌──────────────┐   ┌────────────────┐  │
│  │ generate_   │   │ DT markdown  │   │ content.yaml   │  │
│  │ cards.py    │   │ + templates  │   │ output         │  │
│  └─────────────┘   └──────────────┘   └────────────────┘  │
└───────────────────────────────────────────────────────────┘
Boundary Descriptions
BoundaryAssets ProtectedControls Enforced
Workstation / RunnerOutput integrity, host processyaml_escape of dynamic values; quoted-placeholder templates; string-partition frontmatter (no YAML loader)

Assets

IdAssetLifetimeNotes
A1Canonical DT markdownRead-only during renderUntrusted prose; may contain confidential product/customer content
A2content.yaml templatesRead-onlyShip with the skill; every placeholder is double-quoted
A3Rendered content.yamlPersistedWritten under the operator-chosen output directory

Adversaries

IdAdversaryIn-scope mitigations
ADV-aHostile 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-bCaller supplying an adversarial output pathOutput 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
ThreatLikelihoodImpactResidual RiskStatus
Malicious frontmatter/section triggers unsafe parseLowLowLowMitigated (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
ThreatLikelihoodImpactResidual RiskStatus
YAML breakout via artifact proseLowMedLowMitigated (yaml_escape + quoted placeholders)
Confidential prose emitted without classification gateMedLowLowBy 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.yaml files 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
ThreatLikelihoodImpactResidual RiskStatus
Output written outside the intended locationLowLowLowMitigated (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.

IdGapSeverityStatus
G-INF-1Canonical 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-LowBy 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

🤖 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.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download customer-card-render.zip