Persona Dimensions Explorer Demo

This demo walks through the FCC Persona Dimensions subsystem -- a 9-category, 56-dimension persona specification system that extends the R.I.S.C.E.A.R. model with behavioral, cultural, decision-making, and advanced attributes.

---

Table of Contents

1. Overview
2. Prerequisites
3. Step 1: Load the Dimension Registry
4. Step 2: Explore Categories
5. Step 3: Inspect Individual Dimensions
6. Step 4: Build a Dimension Profile
7. Step 5: Compare Personas by Dimension
8. Step 6: Visualize with the Heatmap
9. Dimension Categories Reference
10. Screenshots
11. Next Steps

---

Overview

The fcc.personas.dimensions module defines the full breadth of persona attributes beyond the core R.I.S.C.E.A.R. specification. It captures how personas think, communicate, lead, and innovate through 56 dimensions organized into 9 categories.

The dimension system consists of four dataclasses:

Dataclass	Description
DimensionAttribute	A single attribute within a dimension (e.g., "Age" within "Demographic Information")
PersonaDimension	A named dimension with description and optional attributes
PersonaDimensionProfile	A full 9-category profile containing all dimensions
DimensionRegistry	Registry that loads the canonical 56-dimension reference from YAML

---

Prerequisites

• Python 3.10+ with FCC installed: pip install -e ".[dev]"
• No external dependencies required

---

Step 1: Load the Dimension Registry

The DimensionRegistry loads the canonical persona dimension definitions from the FCC data directory.

from fcc.personas.dimensions import DimensionRegistry
from fcc._resources import get_personas_dir

# Load from the YAML data file
personas_dir = get_personas_dir()
registry = DimensionRegistry.from_yaml(personas_dir / "persona_dimensions.yaml")

print(f"Total dimensions: {registry.total_dimensions}")
print(f"Categories: {len(registry.categories)}")

---

Step 2: Explore Categories

The registry organizes dimensions into 9 categories. Each category contains between 4 and 10 dimensions.

for category in registry.categories:
    dims = registry.dimensions_for_category(category)
    print(f"  {category}: {len(dims)} dimensions")

Category Summary

profile = registry.profile
print(f"Populated categories: {profile.populated_categories}")

# Access category dimensions directly
core = profile.core_persona_elements
print(f"\nCore Persona Elements ({len(core)} dimensions):")
for dim in core:
    print(f"  - {dim.name}: {dim.description[:60]}...")

---

Step 3: Inspect Individual Dimensions

Each PersonaDimension has a name, description, and optional list of DimensionAttribute instances that provide further detail.

# Get all dimension names across all categories
all_names = registry.dimension_names()
print(f"Total dimension names: {len(all_names)}")
for name in all_names[:10]:
    print(f"  - {name}")

# Inspect a specific category's dimensions in detail
behavioral = registry.dimensions_for_category("behavioral_and_motivational_factors")
for dim in behavioral:
    print(f"\n{dim.name}")
    print(f"  Description: {dim.description}")
    if dim.attributes:
        print(f"  Attributes ({len(dim.attributes)}):")
        for attr in dim.attributes:
            value_str = f": {attr.value}" if attr.value else ""
            print(f"    - {attr.name}{value_str}")

---

Step 4: Build a Dimension Profile

Create a custom PersonaDimensionProfile for a specific persona by populating dimension categories with scored attributes.

from fcc.personas.dimensions import (
    PersonaDimensionProfile,
    PersonaDimension,
    DimensionAttribute,
)

# Build a profile for the Research Coordinator persona
rc_profile = PersonaDimensionProfile(
    core_persona_elements=[
        PersonaDimension(
            name="Role Identity",
            description="Primary role within the FCC framework",
            attributes=[
                DimensionAttribute(name="Role Title", value="Research Coordinator"),
                DimensionAttribute(name="FCC Phase", value="Find"),
            ],
        ),
    ],
    behavioral_and_motivational_factors=[
        PersonaDimension(
            name="Curiosity Drive",
            description="Intrinsic motivation to explore and discover",
            attributes=[
                DimensionAttribute(name="Exploration Score", value="0.92"),
                DimensionAttribute(name="Depth vs Breadth", value="balanced"),
            ],
        ),
    ],
)

print(f"Profile dimensions: {rc_profile.total_dimensions}")
print(f"Populated categories: {rc_profile.populated_categories}")

# Serialize and deserialize
profile_dict = rc_profile.to_dict()
restored = PersonaDimensionProfile.from_dict(profile_dict)
print(f"Restored dimensions: {restored.total_dimensions}")

---

Step 5: Compare Personas by Dimension

Load the full persona registry and compare dimension profiles across personas.

from fcc.personas.registry import PersonaRegistry

persona_registry = PersonaRegistry.from_data_dir()

# Get personas from two different categories
core_personas = persona_registry.by_category("core")
champion_personas = persona_registry.champions()

print(f"Core personas: {len(core_personas)}")
print(f"Champion personas: {len(champion_personas)}")

# Compare role titles
for persona in core_personas:
    print(f"  [{persona.id}] {persona.name} -- {persona.role_title}")

for persona in champion_personas:
    orchestrates = persona.orchestrates or []
    print(f"  [{persona.id}] {persona.name} -- orchestrates {len(orchestrates)} personas")

---

Step 6: Visualize with the Heatmap

The HeatmapMatrix visualization in the React frontend renders persona dimension scores as a color-coded matrix. The data shape matches the PersonaDimensionProfile structure.

# Prepare heatmap data from dimension profiles
heatmap_data = {
    "labels": ["RC", "SA", "CR", "EA", "TW"],
    "dimensions": registry.dimension_names()[:10],
    "cells": [],
}

# In a real scenario, scores would come from persona dimension profiles
import random
random.seed(42)

for persona in heatmap_data["labels"]:
    for dim in heatmap_data["dimensions"]:
        heatmap_data["cells"].append({
            "source": persona,
            "target": dim,
            "value": random.randint(30, 100),
        })

print(f"Heatmap cells: {len(heatmap_data['cells'])}")
print(f"Personas: {len(heatmap_data['labels'])}")
print(f"Dimensions: {len(heatmap_data['dimensions'])}")

The HeatmapMatrix component uses a sequential color scale from light (#f5f5f5) to dark (#1565C0), with rotated column labels and hover tooltips showing exact scores.

---

Dimension Categories Reference

#	Category	Dimensions	Covers
1	Core Persona Elements	7	Role identity, demographics, goals, context
2	Behavioral and Motivational Factors	6	Personality, motivation, risk tolerance
3	Communication and Learning Styles	4	Preferred channels, learning modality
4	Cultural and Social Influences	4	Values, social norms, group dynamics
5	Decision-Making and Leadership Approaches	5	Decision style, leadership type, delegation
6	Professional Development and Wellness	5	Career stage, skills, work-life balance
7	Market and Regulatory Awareness	5	Industry knowledge, compliance, trends
8	Innovative Persona Elements	10	Creativity, experimentation, adaptability
9	Advanced Persona Attributes	10	Systems thinking, ethics, meta-cognition

---

Screenshots

The Persona Dimensions Explorer Streamlit app provides interactive filtering by category, side-by-side persona comparisons, and dimension score heatmaps for visual analysis of persona attributes.

---

Next Steps

• Explore the Knowledge Graph Demo to see how dimensions feed into the knowledge graph as DIMENSION nodes.
• Try the Tutorial Tracking Demo to track your progress through persona-related learning modules.
• See the Web Frontend Guided Demo for the HeatmapMatrix D3 visualization that renders dimension data.
• Browse src/fcc/personas/dimensions.py for the full source code.
• Check src/fcc/data/personas/persona_dimensions.yaml for the canonical dimension definitions.