mapping-visualization-scaffolds

Name: mapping-visualization-scaffolds
Author: lyndonkl/claude

$npx mdskill add lyndonkl/claude/mapping-visualization-scaffolds

Transforms complex systems into explicit visual maps and diagrams.

Clarifies implicit relationships, dependencies, and structures through visual documentation.
Guides users through identifying nodes, relationships, and selecting visualization approaches.
Validates map completeness and refines outputs based on user feedback.
Delivers concept maps, architectural blueprints, and process flow diagrams.

SKILL.md

.github/skills/mapping-visualization-scaffoldsView on GitHub ↗

---
name: mapping-visualization-scaffolds
description: Creates visual maps that make implicit relationships, dependencies, and structures explicit through diagrams, concept maps, and architectural blueprints. Guides through identifying nodes and relationships, choosing visualization approaches, and validating completeness. Use when complex systems need visual documentation, mapping component relationships and dependencies, creating hierarchies or taxonomies, documenting process flows or decision trees, understanding system architectures, visualizing data lineage or knowledge structures, or when user mentions concept maps, system diagrams, dependency mapping, relationship visualization, or architecture blueprints.
---

# Mapping & Visualization Scaffolds

## Table of Contents
- [Workflow](#workflow)
- [Common Patterns](#common-patterns)
- [Guardrails](#guardrails)
- [Quick Reference](#quick-reference)

## Workflow

Copy this checklist and track your progress:

```
Mapping Visualization Progress:
- [ ] Step 1: Clarify mapping purpose
- [ ] Step 2: Identify nodes and relationships
- [ ] Step 3: Choose visualization approach
- [ ] Step 4: Create the map
- [ ] Step 5: Validate and refine
```

**Step 1: Clarify mapping purpose**

Ask user about their goal: What system/concept needs mapping? Who's the audience? What decisions will this inform? What level of detail is needed? See [Common Patterns](#common-patterns) for typical use cases.

**Step 2: Identify nodes and relationships**

List all key elements (nodes) and their connections (relationships). Identify hierarchy levels, dependency types, and grouping criteria. For simple cases (< 20 nodes), use [resources/template.md](resources/template.md). For complex systems (50+ nodes) or collaborative sessions, see [resources/methodology.md](resources/methodology.md) for advanced strategies.

**Step 3: Choose visualization approach**

Select format based on complexity: Simple lists for < 10 nodes, tree diagrams for hierarchies, network graphs for complex relationships, or layered diagrams for systems. For large-scale systems or multi-map hierarchies, consult [resources/methodology.md](resources/methodology.md) for mapping strategies and tool selection. See [Common Patterns](#common-patterns) for guidance.

**Step 4: Create the map**

Build the visualization using markdown, ASCII diagrams, or structured text. Start with high-level structure, then add details. Include legend if needed. Use [resources/template.md](resources/template.md) as your scaffold.

**Step 5: Validate and refine**

Check completeness, clarity, and accuracy using [resources/evaluators/rubric_mapping_visualization_scaffolds.json](resources/evaluators/rubric_mapping_visualization_scaffolds.json). Ensure all critical nodes and relationships are present. Minimum standard: Score ≥ 3.5 average.

## Common Patterns

**Architecture Diagrams:**
- System components as nodes
- Service calls/data flows as relationships
- Layers as groupings (frontend, backend, data)
- Use for: Technical documentation, system design reviews

**Concept Maps:**
- Concepts/ideas as nodes
- "is-a", "has-a", "leads-to" as relationships
- Themes as groupings
- Use for: Learning, knowledge organization, research synthesis

**Dependency Graphs:**
- Tasks/features/modules as nodes
- "depends-on", "blocks", "requires" as relationships
- Phases/sprints as groupings
- Use for: Project planning, risk assessment, parallel work identification

**Hierarchies & Taxonomies:**
- Categories/classes as nodes
- Parent-child relationships
- Levels as groupings (L1, L2, L3)
- Use for: Information architecture, org charts, skill trees

**Flow Diagrams:**
- Steps/states as nodes
- Transitions/decisions as relationships
- Swim lanes as groupings (roles, systems)
- Use for: Process documentation, user journeys, decision trees

## Guardrails

**Scope Management:**
- Focus on relationships that matter for the specific purpose
- Don't map everything—map what's decision-relevant
- Stop at appropriate detail level (usually 3-4 layers deep)
- For systems with > 50 nodes, create multiple focused maps

**Clarity Over Completeness:**
- Prioritize understandability over exhaustiveness
- Use consistent notation and naming
- Add legend if > 3 relationship types
- Group related nodes to reduce visual complexity

**Validation:**
- Verify accuracy with subject matter experts
- Test if someone unfamiliar can understand the map
- Check for missing critical relationships
- Ensure directionality is clear (A → B vs A ← B)

**Common Pitfalls:**
- ❌ Creating "hairball" diagrams with too many connections
- ❌ Mixing abstraction levels (strategic + implementation details)
- ❌ Using inconsistent node/relationship representations
- ❌ Forgetting to state the map's purpose and scope

## Quick Reference

**Resources:**
- `resources/template.md` - Structured scaffold for creating maps
- `resources/evaluators/rubric_mapping_visualization_scaffolds.json` - Quality criteria

**Output:**
- File: `mapping-visualization-scaffolds.md` in current directory
- Contains: Nodes, relationships, groupings, legend (if needed)
- Format: Markdown with ASCII diagrams or structured lists

**Success Criteria:**
- All critical nodes identified
- Relationships clearly labeled with directionality
- Appropriate grouping/layering applied
- Understandable by target audience without explanation
- Validated against quality rubric (score ≥ 3.5)

More from lyndonkl/claude

Skill	Description
abstraction-concrete-examples	Builds structured abstraction ladders that translate high-level principles into concrete, actionable examples across 3-5 levels. Bridges communication gaps, reveals hidden assumptions, and tests whether abstract ideas work in practice. Use when explaining concepts at different expertise levels, moving between abstract principles and concrete implementation, identifying edge cases by testing ideas against scenarios, designing layered documentation, decomposing complex problems into actionable steps, or bridging strategy-execution gaps.
academic-letter-architect	Guides the creation of evidence-based academic recommendation letters, reference letters, and award nominations that combine concrete examples, meaningful comparisons, and genuine enthusiasm. Use when writing recommendation letters for students, postdocs, or colleagues, or when user mentions recommendation letter, reference, nomination, letter of support, endorsement, or needs help with strong advocacy and comparative statements.
adr-architecture	Documents significant architectural and technical decisions with full context, alternatives considered, trade-offs analyzed, and consequences understood. Creates a decision trail that helps teams understand why decisions were made. Use when choosing between technology options, making infrastructure decisions, establishing standards, migrating systems, or when user mentions ADR, architecture decision, technical decision record, or decision documentation.
adverse-selection-prior	Produces a Bayesian prior probability that an offered transaction is +EV for the recipient, given that the counterparty chose to propose it. Applies Akerlof market-for-lemons logic -- if they offered it, they believe it is +EV for them, so the prior that it is +EV for us is materially below 50%. Reusable across trade evaluation, waiver drops (another team dropping a player is also adverse selection), job-offer analysis, M&A, and any "someone offered me this" situation. Use when you receive an unsolicited trade/offer/proposal, analyzing incoming trade prior, evaluating why a counterparty proposed a deal, or when user mentions adverse selection, market for lemons, why did they offer this, incoming trade prior, they proposed it, Bayesian adjustment on received offer.
alignment-values-north-star	Creates actionable alignment frameworks that give teams a shared North Star (direction), values (guardrails), and decision tenets (behavioral standards). Enables autonomous decision-making while maintaining organizational coherence. Use when starting new teams, scaling organizations, defining culture, establishing product vision, resolving misalignment, creating strategic clarity, or when user mentions North Star, team values, mission, principles, guardrails, decision framework, or cultural alignment.
analogy-weight-check	For every analogy in a substacker draft, verifies it carries mechanical weight — the analogy does real work explaining the mechanism, not merely decorates it. Cross-references analogy-catalog.md for novelty (is this analogy reused from a prior post?) and domain fit (biology > organizational > sports preferred; physics/military disfavored). Use whenever an analogy appears in the draft. Trigger keywords: analogy weight, decorative, mechanical weight, reused analogy, catalog check, metaphor check.
answer-uncomfortable-question	Takes one strategic question about substacker ("should we launch paid?", "is this section dead?", "are we writing for the wrong audience?") and produces the mandatory evidence + reasoning + downside triad plus a recommendation. Used 3 times per Growth Strategist review. Trigger keywords: uncomfortable question, strategic question, evidence reasoning downside, triad.
attribute-performance	For each substacker post that materially over- or under-performs the rolling baseline (\|z\| ≥ 1.0), produces a plain-English attribution paragraph with calibrated confidence (high / medium / low / unexplained). Considers subject-line effect, topic zeitgeist, external share, day-of-week, length effect, and audience-notes signals. Labels unexplained outliers explicitly rather than fabricating a story. Use after compute-baseline when outlier posts exist. Trigger keywords: attribution, why did this post work, outlier explanation, performance analysis.
auction-first-price-shading	Computes the optimal shaded bid for a first-price sealed-bid auction given a true private value, an estimate of the number of competing bidders N, and a value-distribution assumption. Implements the `(N-1)/N` equilibrium shading rule for uniform private values, adjusts for log-normal or empirical value distributions, layers a risk-aversion adjustment, and caps output against the bidder's remaining budget. Domain-neutral auction theory reusable across fantasy sports (baseball FAAB, NBA/NHL waiver auctions), prediction-market limit sizing, sealed procurement bids, and any blind-bid context. Use when user mentions "first-price auction bid", "sealed bid shading", "(N-1)/N", "FAAB bid amount", "auction shading", "optimal bid first-price", "bid for sealed-bid", "blind bid sizing", or when downstream logic needs a principled shade factor rather than an ad-hoc heuristic.
auction-winners-curse-haircut	Applies a Bayesian haircut to a bid valuation for common-value auctions where winning is itself evidence the bidder over-estimated. Takes a raw valuation, a value-type classification (common_value / private_value / mixed), the number of informed bidders N, and a signal-dispersion estimate, and returns an adjusted valuation. Domain-neutral and reusable across fantasy FAAB, prediction markets, M&A bids, ad-auction budgets, and any generic bidding context. Use when user mentions "winner's curse", "common value auction", "valuation haircut", "adverse valuation", "Bayesian bid adjustment", or "over-paying in auction".