Pipeline run

{
  "final_skills": [
    {
      "is_primary": true,
      "skill_name": "Python"
    },
    {
      "is_primary": true,
      "skill_name": "TypeScript"
    },
    {
      "is_primary": true,
      "skill_name": "LLM"
    },
    {
      "is_primary": true,
      "skill_name": "Prompting"
    },
    {
      "is_primary": true,
      "skill_name": "Context Management"
    },
    {
      "is_primary": true,
      "skill_name": "Structured Outputs"
    },
    {
      "is_primary": true,
      "skill_name": "VLMs"
    },
    {
      "is_primary": true,
      "skill_name": "OCR"
    },
    {
      "is_primary": true,
      "skill_name": "Layout Parsing"
    },
    {
      "is_primary": true,
      "skill_name": "Containers"
    },
    {
      "is_primary": true,
      "skill_name": "CI/CD"
    },
    {
      "is_primary": true,
      "skill_name": "Azure"
    },
    {
      "is_primary": true,
      "skill_name": "GCP"
    },
    {
      "is_primary": true,
      "skill_name": "Evaluation"
    },
    {
      "is_primary": true,
      "skill_name": "Observability"
    },
    {
      "is_primary": true,
      "skill_name": "Failure Analysis"
    },
    {
      "is_primary": false,
      "skill_name": "RAG"
    },
    {
      "is_primary": false,
      "skill_name": "Hybrid Retrieval"
    },
    {
      "is_primary": false,
      "skill_name": "Reranking"
    },
    {
      "is_primary": false,
      "skill_name": "Vision-Language Models"
    },
    {
      "is_primary": false,
      "skill_name": "Multimodal Document Understanding"
    },
    {
      "is_primary": false,
      "skill_name": "Agentic Systems"
    },
    {
      "is_primary": false,
      "skill_name": "Claude Code"
    },
    {
      "is_primary": false,
      "skill_name": "Cursor"
    },
    {
      "is_primary": false,
      "skill_name": "Codex"
    }
  ],
  "jd_role": null,
  "nano_parsed": {
    "JD_type": "fail"
  },
  "run_id": null
}

{
  "alias_matches": [
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 608,
      "existing_alias_text": "Python",
      "input_term": "Python",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "Python",
        "id": 393,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "python",
        "sub_category_id": 54,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 14,
      "existing_alias_text": "TypeScript",
      "input_term": "TypeScript",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "TypeScript",
        "id": 2,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "typescript",
        "sub_category_id": 54,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 3376,
      "existing_alias_text": "CI/CD",
      "input_term": "CI/CD",
      "matched_canonical": {
        "category_id": 7,
        "display_name": "CI/CD",
        "id": 2579,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "ci-cd",
        "sub_category_id": 2102,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 349,
      "existing_alias_text": "Azure",
      "input_term": "Azure",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Azure",
        "id": 164,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "azure",
        "sub_category_id": 161,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 3043,
      "existing_alias_text": "GCP",
      "input_term": "GCP",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "GCP",
        "id": 2304,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "gcp",
        "sub_category_id": 161,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    }
  ],
  "candidate_roles": [
    {
      "display_name": "Data Analyst",
      "id": 20,
      "rationale": null,
      "role_archetype": null,
      "slug": "data-analyst",
      "source": "db"
    },
    {
      "display_name": "Data Scientist",
      "id": 7,
      "rationale": null,
      "role_archetype": null,
      "slug": "data-scientist",
      "source": "db"
    },
    {
      "display_name": "Azure Cloud Engineer",
      "id": 4,
      "rationale": null,
      "role_archetype": null,
      "slug": "azure-cloud-engineer",
      "source": "db"
    },
    {
      "display_name": "Cloud Engineer",
      "id": 18,
      "rationale": null,
      "role_archetype": null,
      "slug": "cloud-engineer",
      "source": "db"
    },
    {
      "display_name": "Virtualization Engineer",
      "id": 26,
      "rationale": null,
      "role_archetype": null,
      "slug": "virtualization-engineer",
      "source": "db"
    },
    {
      "display_name": "Network Engineer",
      "id": 21,
      "rationale": null,
      "role_archetype": null,
      "slug": "network-engineer",
      "source": "db"
    },
    {
      "display_name": "AI Engineer",
      "id": 12,
      "rationale": null,
      "role_archetype": null,
      "slug": "ai-engineer",
      "source": "db"
    },
    {
      "display_name": "Backend Engineer",
      "id": 14,
      "rationale": null,
      "role_archetype": null,
      "slug": "backend-engineer",
      "source": "db"
    },
    {
      "display_name": "Data Engineer",
      "id": 6,
      "rationale": null,
      "role_archetype": null,
      "slug": "data-engineer",
      "source": "db"
    },
    {
      "display_name": "Machine Learning Engineer",
      "id": 10,
      "rationale": null,
      "role_archetype": null,
      "slug": "machine-learning-engineer",
      "source": "db"
    },
    {
      "display_name": "Cybersecurity Engineer",
      "id": 9,
      "rationale": null,
      "role_archetype": null,
      "slug": "cybersecurity-engineer",
      "source": "db"
    },
    {
      "display_name": "Automation Tester",
      "id": 16,
      "rationale": null,
      "role_archetype": null,
      "slug": "automation-tester",
      "source": "db"
    },
    {
      "display_name": "Frontend Engineer",
      "id": 3,
      "rationale": null,
      "role_archetype": "Frontend Engineers design and build the user-facing parts of applications, translating product and design requirements into interactive experiences. They focus on how the application looks, behaves, and responds in the browser, ensuring usability, accessibility, and consistency across the interface.",
      "slug": "frontend-engineer",
      "source": "db"
    },
    {
      "display_name": "Full Stack Developer",
      "id": 2,
      "rationale": null,
      "role_archetype": null,
      "slug": "full-stack-developer",
      "source": "db"
    },
    {
      "display_name": "DevOps Engineer",
      "id": 1,
      "rationale": null,
      "role_archetype": "A DevOps Engineer enables reliable, repeatable delivery of software by designing and operating the processes that connect development and production. They focus on improving deployment flow, operational stability, and collaboration between teams through automation, standardization, and monitoring of delivery and runtime practices.",
      "slug": "devops-engineer",
      "source": "db"
    },
    {
      "display_name": "Manual Tester",
      "id": 17,
      "rationale": null,
      "role_archetype": null,
      "slug": "manual-tester",
      "source": "db"
    },
    {
      "display_name": "MySQL DBA",
      "id": 23,
      "rationale": null,
      "role_archetype": null,
      "slug": "mysql-dba",
      "source": "db"
    },
    {
      "display_name": "Cloud Architect",
      "id": 11,
      "rationale": null,
      "role_archetype": null,
      "slug": "cloud-architect",
      "source": "db"
    }
  ],
  "chosen_role": {
    "display_name": "AI Engineer",
    "id": 12,
    "rationale": "This role leverages multiple primary skills including Python, TypeScript, and AI workflows.",
    "role_archetype": null,
    "slug": "ai-engineer",
    "source": "db"
  },
  "dimensions": [
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Analytical Programming Languages",
        "id": 82,
        "rationale": "Languages used to clean, transform, analyze, and prototype models in notebooks and scripts. This is the core coding surface for expressing statistical logic and data manipulation in a reproducible way.",
        "slug": "analytical-programming-languages",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Data Analyst",
          "id": 20,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-analyst",
          "source": "db"
        },
        {
          "display_name": "Data Scientist",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-scientist",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Automation Scripting and CLI",
        "id": 48,
        "rationale": "Uses scripts and command-line tooling to execute repeatable Azure operations and reduce manual work. This is a practical cluster because the role frequently automates provisioning, checks, and remediation tasks.",
        "slug": "automation-scripting-and-cli",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Azure Cloud Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "azure-cloud-engineer",
          "source": "db"
        },
        {
          "display_name": "Cloud Engineer",
          "id": 18,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Automation and Scripting for Operations",
        "id": 361,
        "rationale": "Scripts and lightweight automation used to execute repetitive virtualization tasks and enforce operational consistency. This is the practical glue that reduces manual host and VM administration.",
        "slug": "automation-and-scripting-for-operations",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Virtualization Engineer",
          "id": 26,
          "rationale": null,
          "role_archetype": null,
          "slug": "virtualization-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Network Automation and Scripting",
        "id": 285,
        "rationale": "Covers scripts and automation used to configure, validate, and audit network devices and services. This cluster is coherent because repeatable network operations increasingly depend on programmatic changes and checks.",
        "slug": "network-automation-and-scripting",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Network Engineer",
          "id": 21,
          "rationale": null,
          "role_archetype": null,
          "slug": "network-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for AI Workflows",
        "id": 261,
        "rationale": "Languages used to implement AI feature logic, orchestration, and response handling inside product code. This is the core coding surface for turning prompts and model calls into reliable application behavior.",
        "slug": "programming-languages-for-ai-workflows",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 12,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for Backend Systems",
        "id": 140,
        "rationale": "Languages used to implement server-side business logic, request handlers, workers, and service integrations. This is the core coding surface for backend feature delivery and maintenance.",
        "slug": "programming-languages-for-backend-systems",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "id": 14,
          "rationale": null,
          "role_archetype": null,
          "slug": "backend-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for Data Work",
        "id": 67,
        "rationale": "Languages used to implement data pipelines, transformations, and operational utilities. This is the code layer for expressing extraction, parsing, validation, and orchestration logic in data engineering workflows.",
        "slug": "programming-languages-for-data-work",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Data Engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for ML Systems",
        "id": 113,
        "rationale": "Languages used to implement model integration code, inference services, and feature-processing logic. This is the core coding surface for turning trained models into product-facing software components.",
        "slug": "programming-languages-for-ml-systems",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Machine Learning Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "machine-learning-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for Security Work",
        "id": 328,
        "rationale": "Languages used to automate security tasks, write detection logic, and build analysis or remediation tooling. This is the core coding surface for a cybersecurity engineer across scripts, queries, and small utilities.",
        "slug": "programming-languages-for-security-work",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cybersecurity Engineer",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for Test Automation",
        "id": 193,
        "rationale": "Languages used to implement automated checks, helper utilities, and test harness code. This is the core coding surface for turning test ideas into maintainable automation.",
        "slug": "programming-languages-for-test-automation",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Automation Tester",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "automation-tester",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Security Automation and Scripting",
        "id": 258,
        "rationale": "Automating repeatable security checks, enrichment, and remediation workflows. This cluster is coherent because the role often needs lightweight automation to scale analysis and response.",
        "slug": "security-automation-and-scripting",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cybersecurity Engineer",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Frontend Programming Languages",
        "id": 1,
        "rationale": "Languages used to implement browser-side application logic, component behavior, and UI state. This is the core code layer for frontend features and interactive experiences.",
        "slug": "frontend-programming-languages",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": "Frontend Engineers design and build the user-facing parts of applications, translating product and design requirements into interactive experiences. They focus on how the application looks, behaves, and responds in the browser, ensuring usability, accessibility, and consistency across the interface.",
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Full Stack Developer",
          "id": 2,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for AI Workflows",
        "id": 261,
        "rationale": "Languages used to implement AI feature logic, orchestration, and response handling inside product code. This is the core coding surface for turning prompts and model calls into reliable application behavior.",
        "slug": "programming-languages-for-ai-workflows",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 12,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for ML Systems",
        "id": 113,
        "rationale": "Languages used to implement model integration code, inference services, and feature-processing logic. This is the core coding surface for turning trained models into product-facing software components.",
        "slug": "programming-languages-for-ml-systems",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Machine Learning Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "machine-learning-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for Test Automation",
        "id": 193,
        "rationale": "Languages used to implement automated checks, helper utilities, and test harness code. This is the core coding surface for turning test ideas into maintainable automation.",
        "slug": "programming-languages-for-test-automation",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Automation Tester",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "automation-tester",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Version Control Systems",
        "id": 365,
        "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "CI/CD",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platform Operations",
        "id": 26,
        "rationale": "Uses cloud provider services to support delivery and runtime environments. The focus is on consumer-level operation of cloud services rather than deep cloud architecture ownership.",
        "slug": "cloud-platform-operations",
        "source": "db"
      },
      "input_skill": "Azure",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A DevOps Engineer enables reliable, repeatable delivery of software by designing and operating the processes that connect development and production. They focus on improving deployment flow, operational stability, and collaboration between teams through automation, standardization, and monitoring of delivery and runtime practices.",
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Security Platforms",
        "id": 332,
        "rationale": "Cloud-native security products used to assess posture, detect misconfigurations, and monitor workloads across AWS, Azure, and GCP. This is a distinct product family because the role often works across multiple CNAPP/CSPM/CWPP offerings and cloud-native detectors.",
        "slug": "cloud-security-platforms",
        "source": "db"
      },
      "input_skill": "Azure",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cybersecurity Engineer",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Security Platforms",
        "id": 332,
        "rationale": "Cloud-native security products used to assess posture, detect misconfigurations, and monitor workloads across AWS, Azure, and GCP. This is a distinct product family because the role often works across multiple CNAPP/CSPM/CWPP offerings and cloud-native detectors.",
        "slug": "cloud-security-platforms",
        "source": "db"
      },
      "input_skill": "GCP",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cybersecurity Engineer",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Version Control Systems",
        "id": 365,
        "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "LLM",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Version Control Systems",
        "id": 365,
        "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Prompting",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Context Management and Retrieval",
        "id": 264,
        "rationale": "Preparing, selecting, and packaging context for model calls so responses stay relevant and grounded. This is a distinct cluster because AI features often depend on what information is included, summarized, or retrieved at call time.",
        "slug": "context-management-and-retrieval",
        "source": "db"
      },
      "input_skill": "Context Management",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 12,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Version Control Systems",
        "id": 365,
        "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Context Management",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Context Management and Retrieval",
        "id": 264,
        "rationale": "Preparing, selecting, and packaging context for model calls so responses stay relevant and grounded. This is a distinct cluster because AI features often depend on what information is included, summarized, or retrieved at call time.",
        "slug": "context-management-and-retrieval",
        "source": "db"
      },
      "input_skill": "Context Management",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 12,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": null,
        "display_name": "Context Management, Retrieval, and Response Shaping",
        "id": null,
        "rationale": "Preparing, selecting, retrieving, and packaging the right context for model calls so responses are relevant, grounded, and usable. Includes prompt context selection, retrieval-augmented generation, context window management, schema-constrained generation, Structured Outputs, JSON schema prompting, tool-call argument shaping, and other response-grounding techniques that control what information the model sees and how its output is structured.",
        "slug": "d_merge_01",
        "source": "llm"
      },
      "input_skill": "Structured Outputs",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Version Control Systems",
        "id": 365,
        "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "VLMs",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Version Control Systems",
        "id": 365,
        "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "OCR",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Project Delivery and Coordination",
        "id": 366,
        "rationale": "Coordination practices for organizing work, tracking progress, and aligning stakeholders across a delivery effort. Agile fits here when used as a team execution framework for managing scope, cadence, and collaboration.",
        "slug": "d_init_02",
        "source": "db"
      },
      "input_skill": "OCR",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Version Control Systems",
        "id": 365,
        "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Layout Parsing",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Version Control Systems",
        "id": 365,
        "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Containers",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Model Evaluation and Validation",
        "id": 86,
        "rationale": "Techniques for assessing model quality, robustness, and uncertainty before recommendations are made. This includes choosing metrics, validating generalization, and understanding error tradeoffs.",
        "slug": "model-evaluation-and-validation",
        "source": "db"
      },
      "input_skill": "Evaluation",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Data Scientist",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-scientist",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Version Control Systems",
        "id": 365,
        "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Observability",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Test Evidence, Defect Reporting, and Triage",
        "id": 241,
        "rationale": "Capturing and organizing clear evidence from manual testing, including what was tested, what was observed, and how to reproduce issues, then communicating defect severity, impact, and triage notes so teams can prioritize fixes and make release decisions. This includes test notes, screenshots, screen recordings, execution logs, reproduction steps, bug reports, severity/priority assessment, and concise status or coverage summaries.",
        "slug": "test-evidence-defect-reporting-and-triage",
        "source": "db"
      },
      "input_skill": "Failure Analysis",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Manual Tester",
          "id": 17,
          "rationale": null,
          "role_archetype": null,
          "slug": "manual-tester",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "MySQL Operational Monitoring, Logging, and Diagnostics",
        "id": 166,
        "rationale": "Covers the DBA practice of monitoring MySQL production health and using MySQL-native logs and diagnostic views to detect, investigate, and explain incidents or performance anomalies. Includes routine health checks, alerting, replication and availability monitoring, resource and connection monitoring, and use of error logs, slow query logs, SHOW PROCESSLIST, performance_schema, status variables, and diagnostic queries to understand behavior and support recovery decisions.",
        "slug": "mysql-operational-monitoring-logging-and-diagnostics",
        "source": "db"
      },
      "input_skill": "Failure Analysis",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "MySQL DBA",
          "id": 23,
          "rationale": null,
          "role_archetype": null,
          "slug": "mysql-dba",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "MySQL Operational Monitoring, Logging, and Diagnostics",
        "id": 166,
        "rationale": "Covers the DBA practice of monitoring MySQL production health and using MySQL-native logs and diagnostic views to detect, investigate, and explain incidents or performance anomalies. Includes routine health checks, alerting, replication and availability monitoring, resource and connection monitoring, and use of error logs, slow query logs, SHOW PROCESSLIST, performance_schema, status variables, and diagnostic queries to understand behavior and support recovery decisions.",
        "slug": "mysql-operational-monitoring-logging-and-diagnostics",
        "source": "db"
      },
      "input_skill": "Failure Analysis",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "MySQL DBA",
          "id": 23,
          "rationale": null,
          "role_archetype": null,
          "slug": "mysql-dba",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": null,
        "display_name": "Context Management, Retrieval, and Grounding for Model Calls",
        "id": null,
        "rationale": "Preparing, selecting, retrieving, summarizing, and packaging information for model calls so outputs stay relevant, grounded, and within the available context window. This includes RAG / retrieval-augmented generation, chunking documents, embedding-based retrieval, vector search, reranking, source grounding, prompt assembly, and other call-time knowledge retrieval and context management techniques.",
        "slug": "d_merge_01",
        "source": "llm"
      },
      "input_skill": "RAG",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Service Integration Patterns",
        "id": 188,
        "rationale": "Covers how cloud services and workloads connect through APIs, events, shared services, and integration boundaries. This cluster is coherent because architects must define interaction patterns that preserve decoupling, security, and operability.",
        "slug": "cloud-service-integration-patterns",
        "source": "db"
      },
      "input_skill": "RAG",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Service Integration Patterns",
        "id": 188,
        "rationale": "Covers how cloud services and workloads connect through APIs, events, shared services, and integration boundaries. This cluster is coherent because architects must define interaction patterns that preserve decoupling, security, and operability.",
        "slug": "cloud-service-integration-patterns",
        "source": "db"
      },
      "input_skill": "RAG",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": null,
        "display_name": "Context Assembly and Retrieval for Model Calls",
        "id": null,
        "rationale": "Preparing, selecting, retrieving, reranking, and packaging information for model calls so responses stay relevant and grounded. Includes hybrid retrieval, vector and keyword search, chunk selection, context assembly, retrieval-augmented generation, document grounding, and query rewriting when used to build the context supplied to a model.",
        "slug": "d_merge_01",
        "source": "llm"
      },
      "input_skill": "Hybrid Retrieval",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Context Management and Retrieval",
        "id": 264,
        "rationale": "Preparing, selecting, and packaging context for model calls so responses stay relevant and grounded. This is a distinct cluster because AI features often depend on what information is included, summarized, or retrieved at call time.",
        "slug": "context-management-and-retrieval",
        "source": "db"
      },
      "input_skill": "Reranking",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 12,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Context Management and Retrieval",
        "id": 264,
        "rationale": "Preparing, selecting, and packaging context for model calls so responses stay relevant and grounded. This is a distinct cluster because AI features often depend on what information is included, summarized, or retrieved at call time.",
        "slug": "context-management-and-retrieval",
        "source": "db"
      },
      "input_skill": "Reranking",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 12,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Version Control Systems",
        "id": 365,
        "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Vision-Language Models",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Version Control Systems",
        "id": 365,
        "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Multimodal Document Understanding",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Version Control Systems",
        "id": 365,
        "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Agentic Systems",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Automation Scripting and CLI",
        "id": 48,
        "rationale": "Uses scripts and command-line tooling to execute repeatable Azure operations and reduce manual work. This is a practical cluster because the role frequently automates provisioning, checks, and remediation tasks.",
        "slug": "automation-scripting-and-cli",
        "source": "db"
      },
      "input_skill": "Claude Code",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Azure Cloud Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "azure-cloud-engineer",
          "source": "db"
        },
        {
          "display_name": "Cloud Engineer",
          "id": 18,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Automation Scripting and CLI",
        "id": 48,
        "rationale": "Uses scripts and command-line tooling to execute repeatable Azure operations and reduce manual work. This is a practical cluster because the role frequently automates provisioning, checks, and remediation tasks.",
        "slug": "automation-scripting-and-cli",
        "source": "db"
      },
      "input_skill": "Claude Code",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Azure Cloud Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "azure-cloud-engineer",
          "source": "db"
        },
        {
          "display_name": "Cloud Engineer",
          "id": 18,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Version Control Systems",
        "id": 365,
        "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Cursor",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Version Control Systems",
        "id": 365,
        "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Codex",
      "llm_role": null,
      "roles_from_db": []
    }
  ],
  "input_final_skills": [
    "Python",
    "TypeScript",
    "LLM",
    "Prompting",
    "Context Management",
    "Structured Outputs",
    "VLMs",
    "OCR",
    "Layout Parsing",
    "Containers",
    "CI/CD",
    "Azure",
    "GCP",
    "Evaluation",
    "Observability",
    "Failure Analysis",
    "RAG",
    "Hybrid Retrieval",
    "Reranking",
    "Vision-Language Models",
    "Multimodal Document Understanding",
    "Agentic Systems",
    "Claude Code",
    "Cursor",
    "Codex"
  ],
  "input_llm_skills": [
    "Python",
    "TypeScript",
    "LLM",
    "Prompting",
    "Context Management",
    "Structured Outputs",
    "VLMs",
    "OCR",
    "Layout Parsing",
    "Containers",
    "CI/CD",
    "Azure",
    "GCP",
    "Evaluation",
    "Observability",
    "Failure Analysis",
    "RAG",
    "Hybrid Retrieval",
    "Reranking",
    "Vision-Language Models",
    "Multimodal Document Understanding",
    "Agentic Systems",
    "Claude Code",
    "Cursor",
    "Codex"
  ],
  "new_aliases_persisted": 0,
  "run_id": "62310ed0-c8e6-4590-a4e8-edafce525331",
  "skills_detail": [
    {
      "aliases_in_db": [
        {
          "alias_text": "Python",
          "alias_type": "CANONICAL",
          "id": 608,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 2",
          "alias_type": "VERSION",
          "id": 611,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 2.x",
          "alias_type": "VERSION",
          "id": 613,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3",
          "alias_type": "VERSION",
          "id": 612,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.10",
          "alias_type": "VERSION",
          "id": 2330,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.11",
          "alias_type": "VERSION",
          "id": 2331,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.12",
          "alias_type": "VERSION",
          "id": 2332,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.x",
          "alias_type": "VERSION",
          "id": 614,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "py2",
          "alias_type": "VERSION",
          "id": 609,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "py3",
          "alias_type": "VERSION",
          "id": 610,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python 2",
          "alias_type": "VERSION",
          "id": 2152,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python 2.x",
          "alias_type": "VERSION",
          "id": 2154,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python 3",
          "alias_type": "VERSION",
          "id": 990,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python 3.10",
          "alias_type": "VERSION",
          "id": 992,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python 3.11",
          "alias_type": "VERSION",
          "id": 993,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python 3.12",
          "alias_type": "VERSION",
          "id": 994,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python 3.x",
          "alias_type": "VERSION",
          "id": 991,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python2",
          "alias_type": "VERSION",
          "id": 2150,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python3",
          "alias_type": "VERSION",
          "id": 989,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "Python",
        "id": 393,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "python",
        "sub_category_id": 54,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Analytical Programming Languages",
            "id": 82,
            "rationale": "Languages used to clean, transform, analyze, and prototype models in notebooks and scripts. This is the core coding surface for expressing statistical logic and data manipulation in a reproducible way.",
            "slug": "analytical-programming-languages",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Data Analyst",
              "id": 20,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-analyst",
              "source": "db"
            },
            {
              "display_name": "Data Scientist",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-scientist",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Automation Scripting and CLI",
            "id": 48,
            "rationale": "Uses scripts and command-line tooling to execute repeatable Azure operations and reduce manual work. This is a practical cluster because the role frequently automates provisioning, checks, and remediation tasks.",
            "slug": "automation-scripting-and-cli",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Azure Cloud Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "azure-cloud-engineer",
              "source": "db"
            },
            {
              "display_name": "Cloud Engineer",
              "id": 18,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Automation and Scripting for Operations",
            "id": 361,
            "rationale": "Scripts and lightweight automation used to execute repetitive virtualization tasks and enforce operational consistency. This is the practical glue that reduces manual host and VM administration.",
            "slug": "automation-and-scripting-for-operations",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Virtualization Engineer",
              "id": 26,
              "rationale": null,
              "role_archetype": null,
              "slug": "virtualization-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Network Automation and Scripting",
            "id": 285,
            "rationale": "Covers scripts and automation used to configure, validate, and audit network devices and services. This cluster is coherent because repeatable network operations increasingly depend on programmatic changes and checks.",
            "slug": "network-automation-and-scripting",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Network Engineer",
              "id": 21,
              "rationale": null,
              "role_archetype": null,
              "slug": "network-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for AI Workflows",
            "id": 261,
            "rationale": "Languages used to implement AI feature logic, orchestration, and response handling inside product code. This is the core coding surface for turning prompts and model calls into reliable application behavior.",
            "slug": "programming-languages-for-ai-workflows",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 12,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for Backend Systems",
            "id": 140,
            "rationale": "Languages used to implement server-side business logic, request handlers, workers, and service integrations. This is the core coding surface for backend feature delivery and maintenance.",
            "slug": "programming-languages-for-backend-systems",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "id": 14,
              "rationale": null,
              "role_archetype": null,
              "slug": "backend-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for Data Work",
            "id": 67,
            "rationale": "Languages used to implement data pipelines, transformations, and operational utilities. This is the code layer for expressing extraction, parsing, validation, and orchestration logic in data engineering workflows.",
            "slug": "programming-languages-for-data-work",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Data Engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for ML Systems",
            "id": 113,
            "rationale": "Languages used to implement model integration code, inference services, and feature-processing logic. This is the core coding surface for turning trained models into product-facing software components.",
            "slug": "programming-languages-for-ml-systems",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Machine Learning Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "machine-learning-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for Security Work",
            "id": 328,
            "rationale": "Languages used to automate security tasks, write detection logic, and build analysis or remediation tooling. This is the core coding surface for a cybersecurity engineer across scripts, queries, and small utilities.",
            "slug": "programming-languages-for-security-work",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cybersecurity Engineer",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for Test Automation",
            "id": 193,
            "rationale": "Languages used to implement automated checks, helper utilities, and test harness code. This is the core coding surface for turning test ideas into maintainable automation.",
            "slug": "programming-languages-for-test-automation",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Automation Tester",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "automation-tester",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Security Automation and Scripting",
            "id": 258,
            "rationale": "Automating repeatable security checks, enrichment, and remediation workflows. This cluster is coherent because the role often needs lightweight automation to scale analysis and response.",
            "slug": "security-automation-and-scripting",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cybersecurity Engineer",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Python",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "TypeScript",
          "alias_type": "CANONICAL",
          "id": 14,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TS",
          "alias_type": "VERSION",
          "id": 1015,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TypeScript 3",
          "alias_type": "VERSION",
          "id": 1016,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TypeScript 3.x",
          "alias_type": "VERSION",
          "id": 1019,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TypeScript 4",
          "alias_type": "VERSION",
          "id": 1017,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TypeScript 4.x",
          "alias_type": "VERSION",
          "id": 1020,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TypeScript 5",
          "alias_type": "VERSION",
          "id": 1018,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TypeScript 5.x",
          "alias_type": "VERSION",
          "id": 1021,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "TypeScript",
        "id": 2,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "typescript",
        "sub_category_id": 54,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Frontend Programming Languages",
            "id": 1,
            "rationale": "Languages used to implement browser-side application logic, component behavior, and UI state. This is the core code layer for frontend features and interactive experiences.",
            "slug": "frontend-programming-languages",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": "Frontend Engineers design and build the user-facing parts of applications, translating product and design requirements into interactive experiences. They focus on how the application looks, behaves, and responds in the browser, ensuring usability, accessibility, and consistency across the interface.",
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Full Stack Developer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for AI Workflows",
            "id": 261,
            "rationale": "Languages used to implement AI feature logic, orchestration, and response handling inside product code. This is the core coding surface for turning prompts and model calls into reliable application behavior.",
            "slug": "programming-languages-for-ai-workflows",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 12,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for ML Systems",
            "id": 113,
            "rationale": "Languages used to implement model integration code, inference services, and feature-processing logic. This is the core coding surface for turning trained models into product-facing software components.",
            "slug": "programming-languages-for-ml-systems",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Machine Learning Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "machine-learning-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for Test Automation",
            "id": 193,
            "rationale": "Languages used to implement automated checks, helper utilities, and test harness code. This is the core coding surface for turning test ideas into maintainable automation.",
            "slug": "programming-languages-for-test-automation",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Automation Tester",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "automation-tester",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "TypeScript",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Version Control Systems",
            "id": 365,
            "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "LLM",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "LLM",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "machine_learning_model",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": true,
            "confused_with": [
              "large_language_model",
              "language_model"
            ],
            "reasoning": "LLM is a common acronym for Large Language Model, but in JDs it can also be used loosely for language model generally. A parser could conflate the specific acronym with the broader model concept."
          },
          "context_keywords": {
            "context_keywords": [
              "prompt engineering",
              "RAG",
              "fine-tuning",
              "inference",
              "tokenization",
              "embeddings",
              "vector database",
              "context window",
              "few-shot",
              "chain-of-thought",
              "function calling",
              "guardrails",
              "hallucination",
              "alignment",
              "transformer"
            ]
          },
          "maturity": {
            "confidence": 0.86,
            "maturity": "emerging",
            "reasoning": "LLMs appear in many recent job descriptions and vendor roadmaps, but are not yet universal across engineering roles; GitHub and cloud provider trend data show rapid growth rather than saturation."
          },
          "skill_id": "llm",
          "vendor_license": {
            "confidence": 0.99,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Covers the core concepts, capabilities, and practical use of large language models for text generation and reasoning. LLM fits here because it names the model class itself rather than a deployment, data, or integration concern.",
            "exemplar_skills": [
              "LLM",
              "large language models",
              "prompt engineering",
              "few-shot prompting",
              "zero-shot prompting",
              "instruction tuning",
              "transformer models"
            ],
            "in_scope": "LLM, large language models, transformer-based language models, prompt engineering, text generation, instruction tuning, few-shot prompting, zero-shot prompting, model selection, token limits",
            "name": "Large Language Models",
            "out_of_scope": "model serving deployment, runtime packaging, inference pipelines, context retrieval, API integration, training infrastructure, these belong to deployment, data, or integration dimensions",
            "overlap_flags": [
              {
                "reason": "LLM applications often depend on retrieval and context packing, but that dimension owns the mechanics of grounding and context selection.",
                "with_dim_id": "context-management-and-retrieval",
                "with_dim_name": null,
                "with_role": "AI Engineer"
              },
              {
                "reason": "LLM systems are frequently served as inference endpoints, but this dimension owns hosting, routing, and scaling concerns.",
                "with_dim_id": "model-serving-architecture",
                "with_dim_name": null,
                "with_role": "Machine Learning Engineer"
              },
              {
                "reason": "Operational packaging of LLMs into containers or runtimes belongs to deployment rather than the model concept itself.",
                "with_dim_id": "model-serving-deployment-and-runtime-packaging",
                "with_dim_name": null,
                "with_role": "MLOps Engineer, Machine Learning Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "LLM",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "llm"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "ml"
          ],
          "related_to": [
            "mlops",
            "mlflow",
            "lakefs",
            "lean",
            "certora",
            "truffle",
            "merkle-proofs",
            "mfa",
            "tls",
            "hsms"
          ],
          "requires": [],
          "skill_id": "llm",
          "suppress_on_match": []
        },
        "skill_id": "llm",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.88,
          "name": "LLM",
          "reasoning": "LLM is fundamentally a knowledge unit describing a class of machine learning models, not a tool, platform, or language, so it fits the Concept type.",
          "skill_id": "llm",
          "subtype": "machine_learning_model",
          "type": "Concept"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Version Control Systems",
            "id": 365,
            "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Prompting",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Prompting",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "prompt_engineering_concept",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cPrompting\u201d in a JD usually refers to prompt engineering or prompting techniques. It\u2019s a fairly specific concept and not commonly mistaken for another catalog skill in typical job descriptions."
          },
          "context_keywords": {
            "context_keywords": [
              "prompt engineering",
              "few-shot",
              "zero-shot",
              "chain-of-thought",
              "system prompt",
              "instruction tuning",
              "few-shot examples",
              "prompt templates",
              "LLM",
              "context window",
              "temperature",
              "token limit",
              "retrieval-augmented generation",
              "function calling",
              "guardrails"
            ]
          },
          "maturity": {
            "confidence": 0.86,
            "maturity": "emerging",
            "reasoning": "Prompt engineering appears in many recent AI/LLM job descriptions and vendor docs, but it is still often bundled under broader AI/ML roles rather than a universal standalone requirement."
          },
          "skill_id": "prompting",
          "vendor_license": {
            "confidence": 0.99,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Crafting inputs to guide model behavior, improve response quality, and control format, tone, and task completion. This includes writing instructions, examples, constraints, and iterative refinements for LLM interactions.",
            "exemplar_skills": [
              "Prompting",
              "Prompt engineering",
              "Few-shot prompting",
              "Zero-shot prompting",
              "Prompt templates",
              "Instruction writing"
            ],
            "in_scope": "Prompting, prompt engineering, instruction writing, few-shot prompting, zero-shot prompting, chain-of-thought prompting, role prompting, output formatting constraints, prompt templates, prompt iteration, prompt evaluation",
            "name": "Prompt Engineering",
            "out_of_scope": "Context retrieval and chunk selection for model calls, which belongs to context-management-and-retrieval; model hosting, routing, and scaling, which belongs to model-serving-architecture; application code that calls APIs, which belongs to api-integration-and-data-fetching",
            "overlap_flags": [
              {
                "reason": "Prompt quality often depends on retrieved context, but this dimension is about composing the instruction itself rather than selecting or packaging context.",
                "with_dim_id": "context-management-and-retrieval",
                "with_dim_name": null,
                "with_role": "AI Engineer"
              },
              {
                "reason": "Prompting is used within serving flows, but serving architecture covers deployment and runtime concerns, not prompt authoring.",
                "with_dim_id": "model-serving-architecture",
                "with_dim_name": null,
                "with_role": "Machine Learning Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Prompting",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "prompting"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "ai",
            "ml",
            "threat-modeling",
            "authentication",
            "masking",
            "approvals",
            "cve-triage",
            "restore-testing",
            "restore-validation",
            "capacity-alerts"
          ],
          "requires": [],
          "skill_id": "prompting",
          "suppress_on_match": []
        },
        "skill_id": "prompting",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Methodology: ruled out \u2014 prompting can be used as a practice, but the skill name here refers more to the underlying concept than a formal process.",
            "SoftSkill: ruled out \u2014 it is technical and model-interaction specific, not an interpersonal capability."
          ],
          "confidence": 0.9,
          "name": "Prompting",
          "reasoning": "Prompting is best treated as a named knowledge unit about how to interact with language models, so under the Concept vs Methodology rule it fits Concept rather than a tool or methodology.",
          "skill_id": "prompting",
          "subtype": "prompt_engineering_concept",
          "type": "Concept"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Context Management and Retrieval",
            "id": 264,
            "rationale": "Preparing, selecting, and packaging context for model calls so responses stay relevant and grounded. This is a distinct cluster because AI features often depend on what information is included, summarized, or retrieved at call time.",
            "slug": "context-management-and-retrieval",
            "source": "db"
          },
          "input_skill": "Context Management",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 12,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Version Control Systems",
            "id": 365,
            "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Context Management",
          "llm_role": null,
          "roles_from_db": []
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Context Management and Retrieval",
            "id": 264,
            "rationale": "Preparing, selecting, and packaging context for model calls so responses stay relevant and grounded. This is a distinct cluster because AI features often depend on what information is included, summarized, or retrieved at call time.",
            "slug": "context-management-and-retrieval",
            "source": "db"
          },
          "input_skill": "Context Management",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 12,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Context Management",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "SoftSkill",
          "skill_nature": "PRACTICE",
          "sub_category": "context_management",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "The phrase is fairly specific and usually denotes the soft skill of managing context in work or conversations. It is unlikely to be mistaken for a different catalog skill in a typical job description."
          },
          "context_keywords": {
            "context_keywords": [
              "situational awareness",
              "stakeholder alignment",
              "cross-functional",
              "requirements gathering",
              "decision context",
              "project scope",
              "prioritization",
              "trade-offs",
              "dependency management",
              "meeting facilitation",
              "status updates",
              "handoffs",
              "escalation",
              "risk assessment",
              "knowledge transfer"
            ]
          },
          "maturity": {
            "confidence": 0.78,
            "maturity": "well_known",
            "reasoning": "Context management is a common requirement in LLM/agent JDs and product docs, with many listings asking for long-context handling, memory, and retrieval-augmented workflows."
          },
          "skill_id": "context-management",
          "vendor_license": {
            "confidence": 0.99,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [
          {
            "a_dim_id": "context-management-and-retrieval",
            "a_name": "Context Management and Retrieval",
            "a_role": "__skill_focal__",
            "b_dim_id": "context-management-and-retrieval",
            "b_name": "Context Management and Retrieval",
            "b_role": "AI Engineer",
            "pair_kind": "cross_role",
            "reasoning": "Cross-role pair with identical wording, but Dim A is a skill-focal taxonomy entry with concrete boundaries: prompt context assembly, RAG context selection, chunking/windowing, history trimming, memory buffers, and document retrieval; it excludes training, embeddings, vector DB infra, and UI history rendering. Dim B has the same generic label but no scope or exemplars, so there is no evidence it targets the same narrowly defined cluster. The similarity is from copied wording, not shared role-specific skill content.",
            "similarity": 0.8889341620435042
          }
        ],
        "locked_dimensions": [
          {
            "description": "Preparing, selecting, and packaging context for model calls so responses stay relevant and grounded. This skill belongs here because it is about deciding what information to retrieve, retain, trim, and pass into the model.",
            "exemplar_skills": [
              "Context Management",
              "retrieval-augmented generation",
              "prompt context assembly",
              "conversation history trimming",
              "context window optimization",
              "document chunking",
              "grounded prompt construction"
            ],
            "in_scope": "Context Management, prompt context assembly, retrieval-augmented generation context selection, chunking and windowing, conversation history trimming, memory buffers, document retrieval for LLM prompts, grounding inputs, citation-ready context packaging",
            "name": "Context Management and Retrieval",
            "out_of_scope": "Model training, fine-tuning, embedding model design, vector database infrastructure, UI chat history rendering, generic API integration, which belong to other dimensions",
            "overlap_flags": [
              {
                "reason": "Context retrieval often uses service APIs and orchestration, but this dimension focuses on the context-selection logic rather than integration plumbing.",
                "with_dim_id": "cloud-service-integration-patterns",
                "with_dim_name": null,
                "with_role": "Cloud Architect"
              },
              {
                "reason": "Event streams can supply context, but this dimension is about packaging relevant information for model calls, not the streaming system itself.",
                "with_dim_id": "messaging-and-event-streaming",
                "with_dim_name": null,
                "with_role": "Backend Engineer"
              }
            ],
            "tentative_id": "context-management-and-retrieval"
          },
          {
            "description": "Managing short-term and long-term conversational state so assistants can preserve useful details across turns. This fits when Context Management refers specifically to chat memory, summaries, and retention policies rather than retrieval pipelines.",
            "exemplar_skills": [
              "Context Management",
              "conversation memory",
              "chat summarization",
              "turn pruning",
              "session state retention",
              "rolling window context",
              "memory refresh policies"
            ],
            "in_scope": "Context Management, chat memory, conversation summarization, turn pruning, session state retention, user preference memory, rolling conversation windows, memory refresh policies",
            "name": "Conversation Memory Management",
            "out_of_scope": "Document retrieval, vector search, embedding generation, model serving, API request orchestration, which are owned by retrieval and platform dimensions",
            "overlap_flags": [
              {
                "reason": "Client-side state can store conversation data, but this dimension is specifically about preserving conversational memory for assistant behavior.",
                "with_dim_id": "state-management-and-client-data",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Developer, iOS Engineer"
              },
              {
                "reason": "Conversation memory is often implemented alongside retrieval, and the two can overlap in assistant architectures.",
                "with_dim_id": "context-management-and-retrieval",
                "with_dim_name": null,
                "with_role": "AI Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          },
          {
            "description": "Preparing, selecting, and packaging context for model calls so responses stay relevant and grounded. This is a distinct cluster because AI features often depend on what information is included, summarized, or retrieved at call time.",
            "exemplar_skills": [
              "Context Management and Retrieval"
            ],
            "in_scope": "Skills, tools, and practices that belong under Context Management and Retrieval for the target role, including items implied by the dimension rationale.",
            "name": "Context Management and Retrieval",
            "out_of_scope": "Adjacent clusters explicitly not owned by Context Management and Retrieval, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "context-management-and-retrieval"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Context Management",
          "placement_confidence": 0.92,
          "primary_dimension": "context-management-and-retrieval",
          "reasoning": "Deterministic JD placement: locked_dimensions has 3 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [
            "d_init_01"
          ],
          "skill_id": "context-management"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "migration-scripts",
            "rollback-planning",
            "storage-layout",
            "ci-cd",
            "authentication",
            "capacity-forecasting",
            "devops",
            "network-segmentation",
            "mlops",
            "state-transitions"
          ],
          "requires": [],
          "skill_id": "context-management",
          "suppress_on_match": []
        },
        "skill_id": "context-management",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Concept: ruled out \u2014 this is more about how people coordinate and retain information in work than a named technical knowledge unit.",
            "Methodology: ruled out \u2014 it is not a formal process or operating method like Agile or TDD."
          ],
          "confidence": 0.88,
          "name": "Context Management",
          "reasoning": "Context Management is fundamentally an interpersonal/work-practice capability for organizing and maintaining shared understanding, so it fits the SoftSkill category rather than a technical concept or methodology.",
          "skill_id": "context-management",
          "subtype": "context_management",
          "type": "SoftSkill"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:42-\u003e3"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": null,
            "display_name": "Context Management, Retrieval, and Response Shaping",
            "id": null,
            "rationale": "Preparing, selecting, retrieving, and packaging the right context for model calls so responses are relevant, grounded, and usable. Includes prompt context selection, retrieval-augmented generation, context window management, schema-constrained generation, Structured Outputs, JSON schema prompting, tool-call argument shaping, and other response-grounding techniques that control what information the model sees and how its output is structured.",
            "slug": "d_merge_01",
            "source": "llm"
          },
          "input_skill": "Structured Outputs",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Structured Outputs",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "output_schema_constraint",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "The phrase is fairly specific to schema-constrained model output and is unlikely to be mistaken for a different catalog skill in typical JDs."
          },
          "context_keywords": {
            "context_keywords": [
              "JSON Schema",
              "schema validation",
              "function calling",
              "tool calling",
              "response format",
              "schema enforcement",
              "typed outputs",
              "Pydantic",
              "OpenAPI",
              "strict mode",
              "object properties",
              "enum",
              "required fields",
              "schema-constrained",
              "LLM parsing"
            ]
          },
          "maturity": {
            "confidence": 0.78,
            "maturity": "emerging",
            "reasoning": "Appears in growing LLM API docs and JDs for AI app roles, but is still far less common than JSON mode/function calling; market signal is rising adoption rather than universal demand."
          },
          "skill_id": "structured-outputs",
          "vendor_license": {
            "confidence": 0.98,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Preparing, selecting, retrieving, and packaging the right context for model calls so responses are relevant, grounded, and usable. Includes prompt context selection, retrieval-augmented generation, context window management, schema-constrained generation, Structured Outputs, JSON schema prompting, tool-call argument shaping, and other response-grounding techniques that control what information the model sees and how its output is structured.",
            "exemplar_skills": [
              "Context Management, Retrieval, and Response Shaping"
            ],
            "in_scope": "Skills, tools, and practices that belong under Context Management, Retrieval, and Response Shaping for the target role, including items implied by the dimension rationale.",
            "name": "Context Management, Retrieval, and Response Shaping",
            "out_of_scope": "Adjacent clusters explicitly not owned by Context Management, Retrieval, and Response Shaping, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "d_merge_01"
          }
        ],
        "merge_log": [
          {
            "a_dim_id": "context-management-and-retrieval",
            "a_name": "Context Management and Retrieval",
            "a_role": "__skill_focal__",
            "b_dim_id": "context-management-and-retrieval",
            "b_name": "Context Management and Retrieval",
            "b_role": "AI Engineer",
            "into": "d_merge_01",
            "into_name": "Context Management, Retrieval, and Response Shaping",
            "merged_from": [
              "context-management-and-retrieval",
              "context-management-and-retrieval"
            ],
            "pair_kind": "cross_role",
            "reasoning": "Both dimensions describe the same cluster: preparing, selecting, and packaging context for model calls so outputs are grounded and relevant. Dim A explicitly includes prompt context selection, RAG, context window management, and Structured Outputs/JSON schema prompting; Dim B restates the same idea at a higher level. No distinct skill boundary appears, and B adds no separate exemplar skills.",
            "similarity": 0.7905608610902006
          }
        ],
        "placed": {
          "name": "Structured Outputs",
          "placement_confidence": 0.92,
          "primary_dimension": "d_merge_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "structured-outputs"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "data-structures",
            "storage-layout",
            "derived-views",
            "sql",
            "opensearch",
            "snapshot",
            "state-transitions",
            "subgraphs",
            "mlops",
            "solidity"
          ],
          "requires": [],
          "skill_id": "structured-outputs",
          "suppress_on_match": []
        },
        "skill_id": "structured-outputs",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.88,
          "name": "Structured Outputs",
          "reasoning": "This is fundamentally a named knowledge unit about constraining model responses to a structure, so by the Concept vs Methodology rule it is a Concept rather than a tool or format.",
          "skill_id": "structured-outputs",
          "subtype": "output_schema_constraint",
          "type": "Concept"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:40-\u003e1"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Version Control Systems",
            "id": 365,
            "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "VLMs",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "VLMs",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "vision_language_models",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "VLMs is a fairly specific ML acronym for vision-language models; in typical JDs it is unlikely to be confused with a different catalog skill."
          },
          "context_keywords": {
            "context_keywords": [
              "multimodal",
              "image captioning",
              "visual question answering",
              "OCR",
              "object detection",
              "CLIP",
              "transformer",
              "cross-attention",
              "prompt engineering",
              "fine-tuning",
              "zero-shot",
              "few-shot",
              "embeddings",
              "image-text retrieval",
              "grounding"
            ]
          },
          "maturity": {
            "confidence": 0.84,
            "maturity": "emerging",
            "reasoning": "VLMs are appearing in more job descriptions and product roadmaps, but JD volume is still far below core ML stacks; market signal is rapid GitHub/model release growth rather than universal hiring demand."
          },
          "skill_id": "vlms",
          "vendor_license": {
            "confidence": 0.99,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Models that jointly process images and text for understanding, captioning, grounding, and multimodal generation. VLMs belong here because they are the core model family for image-text reasoning and multimodal inference.",
            "exemplar_skills": [
              "VLMs",
              "vision-language models",
              "multimodal transformers",
              "visual question answering",
              "image captioning",
              "grounding"
            ],
            "in_scope": "VLMs, vision-language models, image-text models, multimodal transformers, image captioning, visual question answering, OCR-aware multimodal models, grounding, multimodal prompting",
            "name": "Vision Language Models",
            "out_of_scope": "pure text LLMs and chat models, image-only computer vision models, model deployment and serving infrastructure, context retrieval pipelines, which belong to other dimensions",
            "overlap_flags": [
              {
                "reason": "VLMs are often deployed as inference services, but this dimension is about the model family itself rather than serving patterns.",
                "with_dim_id": "model-serving-architecture",
                "with_dim_name": null,
                "with_role": "Machine Learning Engineer"
              },
              {
                "reason": "Some VLM applications use retrieved context or external documents, but retrieval is a separate capability from the multimodal model.",
                "with_dim_id": "context-management-and-retrieval",
                "with_dim_name": null,
                "with_role": "AI Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "VLMs",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "vlms"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "ml"
          ],
          "related_to": [
            "mlflow",
            "mlops",
            "bls",
            "hsms",
            "vmfs",
            "vcenter-server",
            "vmware-esxi",
            "lxc-lxd",
            "rapid7-insightvm",
            "lakefs"
          ],
          "requires": [],
          "skill_id": "vlms",
          "suppress_on_match": []
        },
        "skill_id": "vlms",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.93,
          "name": "VLMs",
          "reasoning": "VLMs (vision-language models) are a named knowledge unit/model family, so by the Concept vs Methodology rule they are best treated as a Concept rather than a tool or framework.",
          "skill_id": "vlms",
          "subtype": "vision_language_models",
          "type": "Concept"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Version Control Systems",
            "id": 365,
            "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "OCR",
          "llm_role": null,
          "roles_from_db": []
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Project Delivery and Coordination",
            "id": 366,
            "rationale": "Coordination practices for organizing work, tracking progress, and aligning stakeholders across a delivery effort. Agile fits here when used as a team execution framework for managing scope, cadence, and collaboration.",
            "slug": "d_init_02",
            "source": "db"
          },
          "input_skill": "OCR",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "OCR",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "optical_character_recognition",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "OCR is a well-known, specific acronym for optical character recognition in job descriptions. It is unlikely to be reasonably confused with a different catalog skill in typical JD context."
          },
          "context_keywords": {
            "context_keywords": [
              "Tesseract",
              "document scanning",
              "image preprocessing",
              "deskew",
              "binarization",
              "text extraction",
              "layout analysis",
              "bounding boxes",
              "PDF to text",
              "computer vision",
              "handwriting recognition",
              "template matching",
              "page segmentation",
              "confidence scores",
              "OCR engine"
            ]
          },
          "maturity": {
            "confidence": 0.92,
            "maturity": "well_known",
            "reasoning": "OCR is broadly used in enterprise document automation and appears frequently in job postings for RPA, IDP, and computer vision roles; cloud vendors also offer mature OCR APIs, signaling mainstream adoption."
          },
          "skill_id": "ocr",
          "vendor_license": {
            "confidence": 0.99,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Techniques and tools for detecting, extracting, and converting text from images or scanned documents into machine-readable text. OCR belongs here because it is the core capability for document digitization, text extraction, and downstream parsing workflows.",
            "exemplar_skills": [
              "OCR",
              "Tesseract",
              "EasyOCR",
              "Google Cloud Vision OCR",
              "Azure AI Vision OCR",
              "Amazon Textract",
              "handwriting recognition",
              "document digitization"
            ],
            "in_scope": "OCR, text extraction from images, scanned PDFs, document digitization, Tesseract, EasyOCR, Google Cloud Vision OCR, Azure AI Vision OCR, Amazon Textract, handwriting recognition, layout-aware OCR",
            "name": "Optical Character Recognition",
            "out_of_scope": "Document classification, PDF generation, image segmentation for non-text tasks, natural language understanding of extracted text, barcode scanning",
            "overlap_flags": [
              {
                "reason": "OCR services are often consumed via APIs, but this dimension covers the text-recognition capability itself rather than client request orchestration.",
                "with_dim_id": "api-integration-and-data-fetching",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Developer"
              },
              {
                "reason": "Managed OCR offerings are integrated as cloud services, but the core skill is recognizing text from visual inputs.",
                "with_dim_id": "cloud-service-integration-patterns",
                "with_dim_name": null,
                "with_role": "Cloud Architect"
              }
            ],
            "tentative_id": "d_init_01"
          },
          {
            "description": "Preprocessing and layout handling for scanned documents and photos so OCR can work reliably. This dimension covers image cleanup, deskewing, denoising, cropping, and page segmentation around OCR workflows.",
            "exemplar_skills": [
              "OCR",
              "deskewing",
              "denoising",
              "binarization",
              "page segmentation",
              "layout detection",
              "image preprocessing",
              "document cleanup"
            ],
            "in_scope": "OCR, deskewing, denoising, binarization, image preprocessing, page segmentation, layout detection, document cleanup, scan quality correction",
            "name": "Document Image Processing",
            "out_of_scope": "Text recognition model selection, API integration with OCR vendors, downstream NLP extraction, document storage and indexing",
            "overlap_flags": [
              {
                "reason": "OCR is the target skill and the end goal of this preprocessing work, but this dimension emphasizes preparing images rather than recognizing text.",
                "with_dim_id": "d_init_01",
                "with_dim_name": null,
                "with_role": null
              }
            ],
            "tentative_id": "d_init_02"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "OCR",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 2 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [
            "d_init_02"
          ],
          "skill_id": "ocr"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "ml",
            "ai",
            "sql",
            "authentication",
            "git",
            "go",
            "objective-c",
            "ios",
            "android",
            "ocsp-validation"
          ],
          "requires": [],
          "skill_id": "ocr",
          "suppress_on_match": []
        },
        "skill_id": "ocr",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.96,
          "name": "OCR",
          "reasoning": "OCR is fundamentally a named knowledge unit about extracting text from images, so it fits the Concept category rather than a tool, library, or format.",
          "skill_id": "ocr",
          "subtype": "optical_character_recognition",
          "type": "Concept"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Version Control Systems",
            "id": 365,
            "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Layout Parsing",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Layout Parsing",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "document_layout_parsing",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cLayout Parsing\u201d is a fairly specific document-processing concept and is unlikely to be mistaken for a different catalog skill in typical job descriptions."
          },
          "context_keywords": {
            "context_keywords": [
              "OCR",
              "document understanding",
              "PDF extraction",
              "table detection",
              "reading order",
              "bounding boxes",
              "page segmentation",
              "document AI",
              "form extraction",
              "key-value pairs",
              "layout analysis",
              "text blocks",
              "spatial relationships",
              "template matching",
              "document classification"
            ]
          },
          "maturity": {
            "confidence": 0.78,
            "maturity": "emerging",
            "reasoning": "Appears in growing JDs for OCR/IDP and document AI roles, and vendor docs from AWS Textract, Google Document AI, and Azure Form Recognizer emphasize layout extraction as a core capability."
          },
          "skill_id": "layout-parsing",
          "vendor_license": {
            "confidence": 0.98,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Techniques for detecting and interpreting the visual structure of documents so text, tables, and fields can be extracted in reading order. This skill belongs here because layout parsing focuses on page geometry and structural segmentation rather than OCR alone.",
            "exemplar_skills": [
              "Layout Parsing",
              "Document Layout Analysis",
              "Page Segmentation",
              "Reading Order Detection",
              "Table Structure Extraction",
              "Form Field Detection"
            ],
            "in_scope": "Layout Parsing, page segmentation, reading order detection, bounding boxes, document zones, table structure extraction, form field detection, PDF layout analysis, scanned document structure",
            "name": "Document Layout Parsing",
            "out_of_scope": "Plain OCR text recognition, image classification, handwriting recognition, semantic information extraction, downstream NLP entity extraction",
            "overlap_flags": [
              {
                "reason": "Both can involve preparing document context, but layout parsing is specifically about spatial structure rather than retrieval or prompt context.",
                "with_dim_id": "context-management-and-retrieval",
                "with_dim_name": null,
                "with_role": "AI Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Layout Parsing",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "layout-parsing"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "metadata-json",
            "migration-scripts",
            "rollback-planning",
            "storage-layout",
            "storage-layout-compatibility",
            "proxy-patterns",
            "rest-apis",
            "javascript",
            "node-js",
            "bash-scripting"
          ],
          "requires": [],
          "skill_id": "layout-parsing",
          "suppress_on_match": []
        },
        "skill_id": "layout-parsing",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.88,
          "name": "Layout Parsing",
          "reasoning": "Layout Parsing is best treated as a Concept because it names a knowledge unit about extracting structure from documents rather than a tool, language, or workflow.",
          "skill_id": "layout-parsing",
          "subtype": "document_layout_parsing",
          "type": "Concept"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Version Control Systems",
            "id": 365,
            "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Containers",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Containers",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Architecture",
          "skill_nature": "PATTERN",
          "sub_category": "containerization_architecture",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": true,
            "confused_with": [
              "docker",
              "kubernetes",
              "containerization"
            ],
            "reasoning": "\"Containers\" is broad and can mean generic containerization architecture, but JDs often use it to refer to Docker or Kubernetes work. A parser could reasonably map the term to those more specific catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "Docker",
              "Kubernetes",
              "Podman",
              "containerd",
              "OCI",
              "image registry",
              "Dockerfile",
              "Compose",
              "Helm",
              "pod",
              "namespace",
              "cgroups",
              "overlay filesystem",
              "orchestration",
              "microservices"
            ]
          },
          "maturity": {
            "confidence": 0.98,
            "maturity": "well_known",
            "reasoning": "Containers are a hiring-pipeline staple: Docker/Kubernetes appear in a large share of cloud and platform JDs, and major vendors (AWS, Azure, GCP) offer first-class container services."
          },
          "skill_id": "containers",
          "vendor_license": {
            "confidence": 0.98,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Covers packaging applications and services into containers and working with container images, runtimes, and lifecycle basics. The target skill belongs here because containers are the core abstraction for isolating and shipping software consistently across environments.",
            "exemplar_skills": [
              "Containers",
              "Docker",
              "OCI images",
              "container runtime",
              "container registries",
              "image layering"
            ],
            "in_scope": "Containers, Docker, OCI images, container runtime basics, image builds, layering, tagging, container lifecycle, container registries, container networking basics",
            "name": "Containerization",
            "out_of_scope": "Kubernetes orchestration, service scheduling, and cluster operations; model packaging for inference platforms; VM provisioning and guest OS management",
            "overlap_flags": [
              {
                "reason": "Model serving often packages inference code into containers, but that dimension focuses on deployment/runtime patterns rather than container fundamentals.",
                "with_dim_id": "model-serving-deployment-and-runtime-packaging",
                "with_dim_name": null,
                "with_role": "MLOps Engineer, Machine Learning Engineer"
              },
              {
                "reason": "Both involve workload isolation, but VMs are full machine instances while containers are OS-level packaging and runtime units.",
                "with_dim_id": "virtual-machine-lifecycle-management",
                "with_dim_name": null,
                "with_role": "Virtualization Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Containers",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "containers"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "lxc-lxd",
            "host-isolation",
            "ci-cd",
            "ec2",
            "tls",
            "snapshot",
            "storage-layout",
            "storage-layout-compatibility",
            "vmfs",
            "minio"
          ],
          "requires": [],
          "skill_id": "containers",
          "suppress_on_match": []
        },
        "skill_id": "containers",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.88,
          "name": "Containers",
          "reasoning": "By the Architecture vs Concept rule, Containers refers to the system-shape approach of packaging and isolating applications rather than a tool or runtime.",
          "skill_id": "containers",
          "subtype": "containerization_architecture",
          "type": "Architecture"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "CI/CD",
          "alias_type": "CANONICAL",
          "id": 3376,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 7,
        "display_name": "CI/CD",
        "id": 2579,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "ci-cd",
        "sub_category_id": 2102,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Version Control Systems",
            "id": 365,
            "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "CI/CD",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "CI/CD",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Azure",
          "alias_type": "CANONICAL",
          "id": 349,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Azure",
        "id": 164,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "azure",
        "sub_category_id": 161,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platform Operations",
            "id": 26,
            "rationale": "Uses cloud provider services to support delivery and runtime environments. The focus is on consumer-level operation of cloud services rather than deep cloud architecture ownership.",
            "slug": "cloud-platform-operations",
            "source": "db"
          },
          "input_skill": "Azure",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A DevOps Engineer enables reliable, repeatable delivery of software by designing and operating the processes that connect development and production. They focus on improving deployment flow, operational stability, and collaboration between teams through automation, standardization, and monitoring of delivery and runtime practices.",
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Security Platforms",
            "id": 332,
            "rationale": "Cloud-native security products used to assess posture, detect misconfigurations, and monitor workloads across AWS, Azure, and GCP. This is a distinct product family because the role often works across multiple CNAPP/CSPM/CWPP offerings and cloud-native detectors.",
            "slug": "cloud-security-platforms",
            "source": "db"
          },
          "input_skill": "Azure",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cybersecurity Engineer",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Azure",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "GCP",
          "alias_type": "CANONICAL",
          "id": 3043,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "GCP",
        "id": 2304,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "gcp",
        "sub_category_id": 161,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Security Platforms",
            "id": 332,
            "rationale": "Cloud-native security products used to assess posture, detect misconfigurations, and monitor workloads across AWS, Azure, and GCP. This is a distinct product family because the role often works across multiple CNAPP/CSPM/CWPP offerings and cloud-native detectors.",
            "slug": "cloud-security-platforms",
            "source": "db"
          },
          "input_skill": "GCP",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cybersecurity Engineer",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "GCP",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Model Evaluation and Validation",
            "id": 86,
            "rationale": "Techniques for assessing model quality, robustness, and uncertainty before recommendations are made. This includes choosing metrics, validating generalization, and understanding error tradeoffs.",
            "slug": "model-evaluation-and-validation",
            "source": "db"
          },
          "input_skill": "Evaluation",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Data Scientist",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-scientist",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Evaluation",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "evaluation",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cEvaluation\u201d is a broad concept, but in JDs it usually appears as the intended skill itself (e.g., model/program evaluation). It is not a short acronym or vendor/product name likely to be mistaken for a distinct catalog skill."
          },
          "context_keywords": {
            "context_keywords": [
              "metrics",
              "benchmarking",
              "A/B testing",
              "validation set",
              "cross-validation",
              "precision",
              "recall",
              "F1 score",
              "confusion matrix",
              "ground truth",
              "inter-rater reliability",
              "rubric",
              "KPI",
              "baseline",
              "ablation study"
            ]
          },
          "maturity": {
            "confidence": 0.86,
            "maturity": "well_known",
            "reasoning": "Evaluation is a core ML/analytics concept and appears broadly in JDs for model validation, A/B testing, and KPI measurement; it\u2019s a standard hiring-pipeline topic rather than a niche tool."
          },
          "skill_id": "evaluation",
          "vendor_license": {
            "confidence": 0.99,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Covers assessing model quality, reliability, and fit for purpose using offline and online validation methods. This skill belongs here because evaluation is the core activity for measuring whether a model or system meets expected performance criteria.",
            "exemplar_skills": [
              "Evaluation",
              "model evaluation",
              "validation metrics",
              "cross-validation",
              "benchmarking",
              "offline validation",
              "online evaluation"
            ],
            "in_scope": "Evaluation, model evaluation, validation metrics, accuracy, precision, recall, F1, ROC-AUC, calibration, cross-validation, holdout testing, benchmark comparison, human review, offline scoring, online evaluation, acceptance criteria",
            "name": "Model Evaluation and Validation",
            "out_of_scope": "Experiment design and causal inference, which focuses on controlled treatment comparison and impact estimation; test reporting and quality metrics, which summarizes results rather than defining evaluation methods; performance tuning and latency, which optimizes runtime behavior rather than judging model quality",
            "overlap_flags": [
              {
                "reason": "Evaluation often uses experiments or A/B tests, but this dimension owns the causal design and analysis rather than the scoring criteria.",
                "with_dim_id": "experiment-design-and-analysis",
                "with_dim_name": null,
                "with_role": "Data Scientist"
              },
              {
                "reason": "Both involve reporting results, but that dimension focuses on communicating test outcomes and trends, not the evaluation methodology itself.",
                "with_dim_id": "test-reporting-and-quality-metrics",
                "with_dim_name": null,
                "with_role": "Automation Tester"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Evaluation",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "evaluation"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "snapshot",
            "approvals",
            "authentication",
            "cve-triage",
            "derived-views",
            "restore-testing",
            "evidence-preservation",
            "restore-validation",
            "recovery-procedures",
            "lean"
          ],
          "requires": [],
          "skill_id": "evaluation",
          "suppress_on_match": []
        },
        "skill_id": "evaluation",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Methodology: ruled out \u2014 it would fit only if the skill referred to a specific evaluation process or workflow, which the name alone does not indicate.",
            "SoftSkill: ruled out \u2014 this is not primarily an interpersonal capability."
          ],
          "confidence": 0.88,
          "name": "Evaluation",
          "reasoning": "Evaluation is a named knowledge unit about assessing outcomes or performance, so by the Concept vs Methodology rule it is a Concept rather than a way of working.",
          "skill_id": "evaluation",
          "subtype": "evaluation",
          "type": "Concept"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Version Control Systems",
            "id": 365,
            "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Observability",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Observability",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "observability",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "Observability is a well-established engineering concept with a specific meaning in JDs; it is unlikely to be confused with a different catalog skill in typical usage."
          },
          "context_keywords": {
            "context_keywords": [
              "metrics",
              "logs",
              "traces",
              "distributed tracing",
              "OpenTelemetry",
              "Prometheus",
              "Grafana",
              "Jaeger",
              "ELK stack",
              "alerting",
              "dashboards",
              "SLO",
              "SLI",
              "error budgets",
              "instrumentation"
            ]
          },
          "maturity": {
            "confidence": 0.93,
            "maturity": "well_known",
            "reasoning": "Observability is broadly listed in SRE/DevOps job descriptions and supported by major vendors (Datadog, Grafana, New Relic, OpenTelemetry), indicating mainstream adoption rather than niche use."
          },
          "skill_id": "observability",
          "vendor_license": {
            "confidence": 0.99,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Practices and tooling for instrumenting systems so their health and behavior can be measured, inspected, and understood in production. This includes logs, metrics, traces, dashboards, and alerting, which are the core concerns of observability.",
            "exemplar_skills": [
              "Observability",
              "logging",
              "metrics",
              "distributed tracing",
              "alerting",
              "dashboards",
              "OpenTelemetry",
              "Prometheus",
              "Grafana"
            ],
            "in_scope": "Observability, logging, metrics, distributed tracing, dashboards, alerts, SLIs, SLOs, error budgets, telemetry instrumentation, OpenTelemetry, Prometheus, Grafana, Datadog",
            "name": "Observability and Telemetry",
            "out_of_scope": "Incident triage, containment, and recovery actions, which belong to incident-response-and-containment; capacity forecasting and performance headroom analysis, which belong to capacity-planning-and-performance-tuning; database-native monitoring specifics, which belong to mysql-operational-monitoring-logging-and-diagnostics",
            "overlap_flags": [
              {
                "reason": "Observability often feeds incident detection and diagnosis, but this dimension covers the telemetry itself rather than the response workflow.",
                "with_dim_id": "incident-response-and-containment",
                "with_dim_name": null,
                "with_role": "Cybersecurity Engineer"
              },
              {
                "reason": "Telemetry is used to assess performance trends, but capacity planning is the separate discipline of forecasting and tuning headroom.",
                "with_dim_id": "capacity-planning-and-performance-tuning",
                "with_dim_name": null,
                "with_role": "Network Engineer, Virtualization Engineer"
              },
              {
                "reason": "MySQL-specific monitoring and diagnostic views are a specialized observability subset for database operations.",
                "with_dim_id": "mysql-operational-monitoring-logging-and-diagnostics",
                "with_dim_name": null,
                "with_role": "MySQL DBA"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Observability",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "observability"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "devops",
            "mlops",
            "ci-cd",
            "cloudwatch",
            "opensearch",
            "event-emission",
            "event-logs",
            "capacity-alerts",
            "threat-modeling",
            "authentication"
          ],
          "requires": [],
          "skill_id": "observability",
          "suppress_on_match": []
        },
        "skill_id": "observability",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.97,
          "name": "Observability",
          "reasoning": "Observability is a named knowledge unit about understanding system behavior from outputs, so by the Concept vs Methodology rule it is a Concept rather than a tool or architecture.",
          "skill_id": "observability",
          "subtype": "observability",
          "type": "Concept"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Test Evidence, Defect Reporting, and Triage",
            "id": 241,
            "rationale": "Capturing and organizing clear evidence from manual testing, including what was tested, what was observed, and how to reproduce issues, then communicating defect severity, impact, and triage notes so teams can prioritize fixes and make release decisions. This includes test notes, screenshots, screen recordings, execution logs, reproduction steps, bug reports, severity/priority assessment, and concise status or coverage summaries.",
            "slug": "test-evidence-defect-reporting-and-triage",
            "source": "db"
          },
          "input_skill": "Failure Analysis",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Manual Tester",
              "id": 17,
              "rationale": null,
              "role_archetype": null,
              "slug": "manual-tester",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "MySQL Operational Monitoring, Logging, and Diagnostics",
            "id": 166,
            "rationale": "Covers the DBA practice of monitoring MySQL production health and using MySQL-native logs and diagnostic views to detect, investigate, and explain incidents or performance anomalies. Includes routine health checks, alerting, replication and availability monitoring, resource and connection monitoring, and use of error logs, slow query logs, SHOW PROCESSLIST, performance_schema, status variables, and diagnostic queries to understand behavior and support recovery decisions.",
            "slug": "mysql-operational-monitoring-logging-and-diagnostics",
            "source": "db"
          },
          "input_skill": "Failure Analysis",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "MySQL DBA",
              "id": 23,
              "rationale": null,
              "role_archetype": null,
              "slug": "mysql-dba",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "MySQL Operational Monitoring, Logging, and Diagnostics",
            "id": 166,
            "rationale": "Covers the DBA practice of monitoring MySQL production health and using MySQL-native logs and diagnostic views to detect, investigate, and explain incidents or performance anomalies. Includes routine health checks, alerting, replication and availability monitoring, resource and connection monitoring, and use of error logs, slow query logs, SHOW PROCESSLIST, performance_schema, status variables, and diagnostic queries to understand behavior and support recovery decisions.",
            "slug": "mysql-operational-monitoring-logging-and-diagnostics",
            "source": "db"
          },
          "input_skill": "Failure Analysis",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "MySQL DBA",
              "id": 23,
              "rationale": null,
              "role_archetype": null,
              "slug": "mysql-dba",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Failure Analysis",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "failure_analysis",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cFailure Analysis\u201d is a standard, specific engineering concept and is unlikely to be mistaken for another catalog skill in typical job descriptions."
          },
          "context_keywords": {
            "context_keywords": [
              "root cause analysis",
              "RCA",
              "fault tree analysis",
              "FMEA",
              "FRACAS",
              "Pareto analysis",
              "5 Whys",
              "fishbone diagram",
              "Weibull analysis",
              "reliability engineering",
              "fractography",
              "metallurgical analysis",
              "non-destructive testing",
              "NDT",
              "corrective action"
            ]
          },
          "maturity": {
            "confidence": 0.84,
            "maturity": "well_known",
            "reasoning": "Common in reliability, manufacturing, and SRE job descriptions; market demand is broad and sustained, with many JDs listing root-cause/failure analysis as a core responsibility."
          },
          "skill_id": "failure-analysis",
          "vendor_license": {
            "confidence": 0.99,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Capturing and organizing evidence from testing to investigate failures, reproduce issues, and communicate clear defect reports for triage. Includes documenting what was tested and observed, collecting logs/screenshots/screen recordings, writing reproduction steps and bug reports, assessing severity/priority or release impact, and providing concise notes that help teams prioritize fixes.",
            "exemplar_skills": [
              "Test Evidence, Defect Reporting, and Triage"
            ],
            "in_scope": "Skills, tools, and practices that belong under Test Evidence, Defect Reporting, and Triage for the target role, including items implied by the dimension rationale.",
            "name": "Test Evidence, Defect Reporting, and Triage",
            "out_of_scope": "Adjacent clusters explicitly not owned by Test Evidence, Defect Reporting, and Triage, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "d_merge_01"
          },
          {
            "description": "Covers using logs, metrics, traces, and diagnostic views to understand system failures and explain what happened. Failure Analysis belongs here when the emphasis is on operational investigation rather than test-case defect reporting.",
            "exemplar_skills": [
              "Failure Analysis",
              "log analysis",
              "diagnostic troubleshooting",
              "incident forensics",
              "metric correlation",
              "error investigation"
            ],
            "in_scope": "Failure Analysis, log inspection, diagnostic queries, metric correlation, trace review, error pattern analysis, incident forensics, health checks, alert investigation",
            "name": "Operational Diagnostics and Logging",
            "out_of_scope": "Capacity planning, performance tuning, schema design, query optimization, backup/restore operations, and routine automation, which are separate DBA concerns",
            "overlap_flags": [
              {
                "reason": "Operational failure analysis often feeds incident response, but incident response owns containment and recovery coordination.",
                "with_dim_id": "incident-response-and-containment",
                "with_dim_name": null,
                "with_role": "Cybersecurity Engineer"
              },
              {
                "reason": "Some failures are performance-related; that dimension owns tuning and latency remediation rather than general diagnosis.",
                "with_dim_id": "performance-tuning-and-latency",
                "with_dim_name": null,
                "with_role": "Storage Engineer"
              }
            ],
            "tentative_id": "mysql-operational-monitoring-logging-and-diagnostics"
          },
          {
            "description": "Covers the DBA practice of monitoring MySQL production health and using MySQL-native logs and diagnostic views to detect, investigate, and explain incidents or performance anomalies. Includes routine health checks, alerting, replication and availability monitoring, resource and connection monitoring, and use of error logs, slow query logs, SHOW PROCESSLIST, performance_schema, status variables, and diagnostic queries to understand behavior and support recovery decisions.",
            "exemplar_skills": [
              "MySQL Operational Monitoring, Logging, and Diagnostics"
            ],
            "in_scope": "Skills, tools, and practices that belong under MySQL Operational Monitoring, Logging, and Diagnostics for the target role, including items implied by the dimension rationale.",
            "name": "MySQL Operational Monitoring, Logging, and Diagnostics",
            "out_of_scope": "Adjacent clusters explicitly not owned by MySQL Operational Monitoring, Logging, and Diagnostics, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "mysql-operational-monitoring-logging-and-diagnostics"
          }
        ],
        "merge_log": [
          {
            "a_dim_id": "test-evidence-defect-reporting-and-triage",
            "a_name": "Test Evidence and Defect Triage",
            "a_role": "__skill_focal__",
            "b_dim_id": "test-evidence-defect-reporting-and-triage",
            "b_name": "Test Evidence, Defect Reporting, and Triage",
            "b_role": "Manual Tester",
            "into": "d_merge_01",
            "into_name": "Test Evidence, Defect Reporting, and Triage",
            "merged_from": [
              "test-evidence-defect-reporting-and-triage",
              "test-evidence-defect-reporting-and-triage"
            ],
            "pair_kind": "cross_role",
            "reasoning": "Both dims cover the same manual-testing cluster: collecting evidence, reproducing failures, and writing actionable defect/triage notes. A includes investigating observed failures, logs/screenshots/steps, severity assessment, defect write-up, and issue triage; B adds what was tested/observed, screen recordings, execution logs, reproduction steps, bug reports, and release-impact summaries. The exemplar skills also match closely (failure analysis, defect triage, reproduction steps, test evidence collection, bug reporting).",
            "similarity": 0.8239546828914645
          }
        ],
        "placed": {
          "name": "Failure Analysis",
          "placement_confidence": 0.92,
          "primary_dimension": "d_merge_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 3 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [
            "mysql-operational-monitoring-logging-and-diagnostics"
          ],
          "skill_id": "failure-analysis"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "threat-modeling",
            "restore-testing",
            "cve-triage",
            "rollback-planning",
            "owasp-top-10",
            "mlops",
            "devops",
            "recovery-procedures",
            "event-logs",
            "state-transitions"
          ],
          "requires": [],
          "skill_id": "failure-analysis",
          "suppress_on_match": []
        },
        "skill_id": "failure-analysis",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.94,
          "name": "Failure Analysis",
          "reasoning": "Failure Analysis is fundamentally a named knowledge unit about diagnosing why systems fail, so it fits the Concept category rather than a methodology or tool.",
          "skill_id": "failure-analysis",
          "subtype": "failure_analysis",
          "type": "Concept"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:41-\u003e3"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": null,
            "display_name": "Context Management, Retrieval, and Grounding for Model Calls",
            "id": null,
            "rationale": "Preparing, selecting, retrieving, summarizing, and packaging information for model calls so outputs stay relevant, grounded, and within the available context window. This includes RAG / retrieval-augmented generation, chunking documents, embedding-based retrieval, vector search, reranking, source grounding, prompt assembly, and other call-time knowledge retrieval and context management techniques.",
            "slug": "d_merge_01",
            "source": "llm"
          },
          "input_skill": "RAG",
          "llm_role": null,
          "roles_from_db": []
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Service Integration Patterns",
            "id": 188,
            "rationale": "Covers how cloud services and workloads connect through APIs, events, shared services, and integration boundaries. This cluster is coherent because architects must define interaction patterns that preserve decoupling, security, and operability.",
            "slug": "cloud-service-integration-patterns",
            "source": "db"
          },
          "input_skill": "RAG",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Service Integration Patterns",
            "id": 188,
            "rationale": "Covers how cloud services and workloads connect through APIs, events, shared services, and integration boundaries. This cluster is coherent because architects must define interaction patterns that preserve decoupling, security, and operability.",
            "slug": "cloud-service-integration-patterns",
            "source": "db"
          },
          "input_skill": "RAG",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "RAG",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "retrieval_augmented_generation",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": true,
            "confused_with": [
              "retrieval",
              "generation",
              "information_retrieval"
            ],
            "reasoning": "RAG is a common acronym for retrieval-augmented generation, but in JDs it can also be read as generic retrieval or generation wording, and sometimes as the unrelated term \u0027rag\u0027 in other contexts. A parser could plausibly misclassify it without surrounding AI context."
          },
          "context_keywords": {
            "context_keywords": [
              "vector database",
              "embeddings",
              "semantic search",
              "chunking",
              "retriever",
              "reranker",
              "prompt engineering",
              "LLM",
              "knowledge base",
              "document ingestion",
              "hybrid search",
              "BM25",
              "FAISS",
              "LangChain",
              "LlamaIndex"
            ]
          },
          "maturity": {
            "confidence": 0.86,
            "maturity": "emerging",
            "reasoning": "RAG appears in many recent AI/ML job descriptions and vendor docs, but it is still not a universal baseline skill like Python or AWS."
          },
          "skill_id": "rag",
          "vendor_license": {
            "confidence": 0.99,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [
          {
            "a_dim_id": "cloud-service-integration-patterns",
            "a_name": "Cloud Service Integration Patterns",
            "a_role": "__skill_focal__",
            "b_dim_id": "cloud-service-integration-patterns",
            "b_name": "Cloud Service Integration Patterns",
            "b_role": "Cloud Architect",
            "pair_kind": "cross_role",
            "reasoning": "Dim A is LLM/RAG-specific: it includes RAG, API-backed retrieval, search service integration, document store integration, and hybrid cloud knowledge access, and its out_of_scope excludes embedding/chunking/reranking/prompting. Dim B is a Cloud Architect pattern for defining service interactions that preserve decoupling, security, and operability. Same label, but different skill clusters and role context.",
            "similarity": 0.7638607123143931
          }
        ],
        "locked_dimensions": [
          {
            "description": "Preparing, selecting, retrieving, summarizing, and packaging information for model calls so outputs stay relevant, grounded, and within the available context window. This includes RAG / retrieval-augmented generation, chunking documents, embedding-based retrieval, vector search, reranking, source grounding, prompt assembly, and other call-time knowledge retrieval and context management techniques.",
            "exemplar_skills": [
              "Context Management, Retrieval, and Grounding for Model Calls"
            ],
            "in_scope": "Skills, tools, and practices that belong under Context Management, Retrieval, and Grounding for Model Calls for the target role, including items implied by the dimension rationale.",
            "name": "Context Management, Retrieval, and Grounding for Model Calls",
            "out_of_scope": "Adjacent clusters explicitly not owned by Context Management, Retrieval, and Grounding for Model Calls, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "d_merge_01"
          },
          {
            "description": "Covers how cloud services and workloads connect through APIs, events, shared services, and integration boundaries. RAG can fit here when the emphasis is on wiring LLM applications to external knowledge services and enterprise systems.",
            "exemplar_skills": [
              "RAG",
              "LLM application integration",
              "search service integration",
              "document store integration",
              "API-backed retrieval",
              "service orchestration"
            ],
            "in_scope": "RAG, LLM application integration, external knowledge services, API-backed retrieval, service-to-service orchestration, search service integration, document store integration, hybrid cloud knowledge access",
            "name": "Cloud Service Integration Patterns",
            "out_of_scope": "Embedding model selection, chunking strategy, reranking, prompt construction, and retrieval algorithms, which belong to context and retrieval design",
            "overlap_flags": [
              {
                "reason": "RAG is primarily a retrieval/context technique, so this dimension is secondary unless the work is centered on integrating external services.",
                "with_dim_id": "context-management-and-retrieval",
                "with_dim_name": null,
                "with_role": "AI Engineer"
              }
            ],
            "tentative_id": "cloud-service-integration-patterns"
          },
          {
            "description": "Covers how cloud services and workloads connect through APIs, events, shared services, and integration boundaries. This cluster is coherent because architects must define interaction patterns that preserve decoupling, security, and operability.",
            "exemplar_skills": [
              "Cloud Service Integration Patterns"
            ],
            "in_scope": "Skills, tools, and practices that belong under Cloud Service Integration Patterns for the target role, including items implied by the dimension rationale.",
            "name": "Cloud Service Integration Patterns",
            "out_of_scope": "Adjacent clusters explicitly not owned by Cloud Service Integration Patterns, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "cloud-service-integration-patterns"
          }
        ],
        "merge_log": [
          {
            "a_dim_id": "context-management-and-retrieval",
            "a_name": "Context Management and Retrieval",
            "a_role": "__skill_focal__",
            "b_dim_id": "context-management-and-retrieval",
            "b_name": "Context Management and Retrieval",
            "b_role": "AI Engineer",
            "into": "d_merge_01",
            "into_name": "Context Management, Retrieval, and Grounding for Model Calls",
            "merged_from": [
              "context-management-and-retrieval",
              "context-management-and-retrieval"
            ],
            "pair_kind": "cross_role",
            "reasoning": "Both dimensions describe the same conceptual cluster: assembling the right information for an LLM at inference time. Dim A explicitly defines this as \"Preparing, selecting, and packaging context for model calls\" and includes concrete retrieval-oriented skills like RAG, chunking documents, embedding-based retrieval, vector search, reranking, and context window management. Dim B uses the same core description verbatim and frames it as the same call-time context selection problem for AI features. There is no evidence of a narrower or different subcluster in B; it is simply a duplicate, cross-role version of A with no distinct exemplar skills. The overlap is therefore substantive, not just lexical.",
            "similarity": 0.8230561433471897
          }
        ],
        "placed": {
          "name": "RAG",
          "placement_confidence": 0.92,
          "primary_dimension": "d_merge_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 3 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [
            "cloud-service-integration-patterns"
          ],
          "skill_id": "rag"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "ml"
          ],
          "related_to": [
            "mlops",
            "ray",
            "agile",
            "git",
            "go",
            "rust",
            "ecs",
            "ec2",
            "mfa"
          ],
          "requires": [
            "faiss"
          ],
          "skill_id": "rag",
          "suppress_on_match": []
        },
        "skill_id": "rag",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "RAG",
          "reasoning": "RAG is fundamentally a named AI/ML knowledge pattern for combining retrieval with generation, so it fits the Concept type rather than a Framework or Tool.",
          "skill_id": "rag",
          "subtype": "retrieval_augmented_generation",
          "type": "Concept"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:41-\u003e3"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": null,
            "display_name": "Context Assembly and Retrieval for Model Calls",
            "id": null,
            "rationale": "Preparing, selecting, retrieving, reranking, and packaging information for model calls so responses stay relevant and grounded. Includes hybrid retrieval, vector and keyword search, chunk selection, context assembly, retrieval-augmented generation, document grounding, and query rewriting when used to build the context supplied to a model.",
            "slug": "d_merge_01",
            "source": "llm"
          },
          "input_skill": "Hybrid Retrieval",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Hybrid Retrieval",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "information_retrieval_approach",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cHybrid Retrieval\u201d is a fairly specific IR approach combining lexical and semantic search; in typical JDs it is unlikely to be mistaken for a different catalog skill."
          },
          "context_keywords": {
            "context_keywords": [
              "BM25",
              "dense retrieval",
              "sparse retrieval",
              "vector search",
              "embeddings",
              "ANN",
              "reranking",
              "cross-encoder",
              "lexical search",
              "semantic search",
              "Elasticsearch",
              "FAISS",
              "Milvus",
              "OpenSearch",
              "query expansion"
            ]
          },
          "maturity": {
            "confidence": 0.84,
            "maturity": "emerging",
            "reasoning": "Hybrid retrieval is increasingly listed in RAG/search job descriptions and vendor docs (e.g., Elasticsearch/OpenSearch support BM25+vector fusion), but it is not yet a universal hiring staple."
          },
          "skill_id": "hybrid-retrieval",
          "vendor_license": {
            "confidence": 0.98,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Preparing, selecting, retrieving, reranking, and packaging information for model calls so responses stay relevant and grounded. Includes hybrid retrieval, vector and keyword search, chunk selection, context assembly, retrieval-augmented generation, document grounding, and query rewriting when used to build the context supplied to a model.",
            "exemplar_skills": [
              "Context Assembly and Retrieval for Model Calls"
            ],
            "in_scope": "Skills, tools, and practices that belong under Context Assembly and Retrieval for Model Calls for the target role, including items implied by the dimension rationale.",
            "name": "Context Assembly and Retrieval for Model Calls",
            "out_of_scope": "Adjacent clusters explicitly not owned by Context Assembly and Retrieval for Model Calls, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "d_merge_01"
          }
        ],
        "merge_log": [
          {
            "a_dim_id": "context-management-and-retrieval",
            "a_name": "Context Management and Retrieval",
            "a_role": "__skill_focal__",
            "b_dim_id": "context-management-and-retrieval",
            "b_name": "Context Management and Retrieval",
            "b_role": "AI Engineer",
            "into": "d_merge_01",
            "into_name": "Context Assembly and Retrieval for Model Calls",
            "merged_from": [
              "context-management-and-retrieval",
              "context-management-and-retrieval"
            ],
            "pair_kind": "cross_role",
            "reasoning": "Both dims define the same cluster: preparing/selecting/packaging context for model calls so outputs stay grounded. Dim A\u2019s in-scope items (hybrid retrieval, vector/keyword search, reranking, chunk selection, RAG, query rewriting) are exactly the concrete techniques implied by Dim B\u2019s description about including, summarizing, or retrieving information at call time. B adds no distinct skills or boundary that would separate it from A.",
            "similarity": 0.8562358950759275
          }
        ],
        "placed": {
          "name": "Hybrid Retrieval",
          "placement_confidence": 0.92,
          "primary_dimension": "d_merge_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "hybrid-retrieval"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "ai-ml",
            "ml",
            "opensearch",
            "elasticsearch",
            "subgraphs",
            "cross-chain-messaging",
            "derived-views",
            "capacity-forecasting",
            "agile"
          ],
          "requires": [],
          "skill_id": "hybrid-retrieval",
          "suppress_on_match": []
        },
        "skill_id": "hybrid-retrieval",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.92,
          "name": "Hybrid Retrieval",
          "reasoning": "Hybrid Retrieval is fundamentally a named retrieval approach/idea rather than a system shape or process, so it fits the Concept type.",
          "skill_id": "hybrid-retrieval",
          "subtype": "information_retrieval_approach",
          "type": "Concept"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:40-\u003e1"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Context Management and Retrieval",
            "id": 264,
            "rationale": "Preparing, selecting, and packaging context for model calls so responses stay relevant and grounded. This is a distinct cluster because AI features often depend on what information is included, summarized, or retrieved at call time.",
            "slug": "context-management-and-retrieval",
            "source": "db"
          },
          "input_skill": "Reranking",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 12,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Context Management and Retrieval",
            "id": 264,
            "rationale": "Preparing, selecting, and packaging context for model calls so responses stay relevant and grounded. This is a distinct cluster because AI features often depend on what information is included, summarized, or retrieved at call time.",
            "slug": "context-management-and-retrieval",
            "source": "db"
          },
          "input_skill": "Reranking",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 12,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Reranking",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "ranking_reordering_concept",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cReranking\u201d is a fairly specific retrieval/ranking concept in JDs and is unlikely to be mistaken for a different catalog skill without additional context."
          },
          "context_keywords": {
            "context_keywords": [
              "cross-encoder",
              "bi-encoder",
              "candidate generation",
              "retrieval pipeline",
              "learning to rank",
              "pairwise ranking",
              "listwise ranking",
              "BM25",
              "dense retrieval",
              "vector search",
              "semantic search",
              "relevance scoring",
              "query-document matching",
              "top-k",
              "LTR"
            ]
          },
          "maturity": {
            "confidence": 0.84,
            "maturity": "emerging",
            "reasoning": "Reranking is increasingly listed in LLM/RAG job descriptions and appears in vendor docs for search/AI stacks, but it is still far less universal than core retrieval or vector search."
          },
          "skill_id": "reranking",
          "vendor_license": {
            "confidence": 0.99,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [
          {
            "a_dim_id": "context-management-and-retrieval",
            "a_name": "Context Management and Retrieval",
            "a_role": "__skill_focal__",
            "b_dim_id": "context-management-and-retrieval",
            "b_name": "Context Management and Retrieval",
            "b_role": "AI Engineer",
            "pair_kind": "cross_role",
            "reasoning": "The labels are similar, but Dim A is a concrete retrieval/ranking cluster: reranking, candidate retrieval, top-k retrieval, semantic search, vector search, document chunk ranking, and query rewriting. Its description also ties reranking to ordering retrieved candidates before an LLM or downstream ranker, and its out_of_scope excludes training/eval/learning-to-rank work. Dim B is only a broad AI-engineering statement about preparing, selecting, and packaging context for model calls, with no exemplars or narrower boundaries. So the overlap is wording-level, not a shared skill cluster.",
            "similarity": 0.7830280118690678
          }
        ],
        "locked_dimensions": [
          {
            "description": "Preparing, selecting, and ordering context for model calls so responses stay relevant and grounded. Reranking belongs here because it is used to reorder retrieved candidates by relevance before passing them to an LLM or downstream ranker.",
            "exemplar_skills": [
              "Reranking",
              "retrieval-augmented generation",
              "semantic search",
              "vector search",
              "top-k retrieval",
              "query rewriting"
            ],
            "in_scope": "Reranking, candidate retrieval, passage selection, query rewriting, context window packing, top-k retrieval, semantic search, vector search, retrieval-augmented generation, document chunk ranking",
            "name": "Context Management and Retrieval",
            "out_of_scope": "Model training objectives, offline evaluation metrics, click-through optimization, learning-to-rank model development, database indexing, which belong to other dimensions",
            "overlap_flags": [
              {
                "reason": "Reranking systems are often evaluated with offline relevance experiments and A/B tests, which can overlap with experiment analysis.",
                "with_dim_id": "experiment-design-and-analysis",
                "with_dim_name": null,
                "with_role": "Data Scientist"
              },
              {
                "reason": "Production rerankers may be deployed as part of inference services, but this dimension focuses on retrieval and ordering logic rather than serving infrastructure.",
                "with_dim_id": "model-serving-architecture",
                "with_dim_name": null,
                "with_role": "Machine Learning Engineer"
              }
            ],
            "tentative_id": "context-management-and-retrieval"
          },
          {
            "description": "Preparing, selecting, and packaging context for model calls so responses stay relevant and grounded. This is a distinct cluster because AI features often depend on what information is included, summarized, or retrieved at call time.",
            "exemplar_skills": [
              "Context Management and Retrieval"
            ],
            "in_scope": "Skills, tools, and practices that belong under Context Management and Retrieval for the target role, including items implied by the dimension rationale.",
            "name": "Context Management and Retrieval",
            "out_of_scope": "Adjacent clusters explicitly not owned by Context Management and Retrieval, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "context-management-and-retrieval"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Reranking",
          "placement_confidence": 0.92,
          "primary_dimension": "context-management-and-retrieval",
          "reasoning": "Deterministic JD placement: locked_dimensions has 2 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "reranking"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "rollback-planning",
            "restore-validation",
            "restore-testing",
            "derived-views",
            "the-graph",
            "subgraphs",
            "quicknode",
            "ai",
            "ml",
            "ai-ml"
          ],
          "requires": [],
          "skill_id": "reranking",
          "suppress_on_match": []
        },
        "skill_id": "reranking",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "Reranking",
          "reasoning": "Reranking is fundamentally a knowledge unit about reordering ranked results, so by the Concept vs Methodology rule it is a Concept rather than a tool or process.",
          "skill_id": "reranking",
          "subtype": "ranking_reordering_concept",
          "type": "Concept"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:41-\u003e2"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Version Control Systems",
            "id": 365,
            "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Vision-Language Models",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Vision-Language Models",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "multimodal_ai_model",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "The term is specific and standard in AI/JD contexts; it is unlikely to be mistaken for a different catalog skill."
          },
          "context_keywords": {
            "context_keywords": [
              "multimodal",
              "image captioning",
              "visual question answering",
              "CLIP",
              "BLIP",
              "LLaVA",
              "OCR",
              "image-text retrieval",
              "cross-modal attention",
              "prompt engineering",
              "fine-tuning",
              "zero-shot",
              "few-shot",
              "embeddings",
              "transformers"
            ]
          },
          "maturity": {
            "confidence": 0.86,
            "maturity": "emerging",
            "reasoning": "Rapidly appearing in job postings for multimodal AI and product teams, and major vendors (OpenAI, Google, Anthropic) have launched VLM APIs/models, but it is not yet a universal hiring staple."
          },
          "skill_id": "vision-language-models",
          "vendor_license": {
            "confidence": 0.98,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Models that jointly process images and text to understand, align, or generate multimodal outputs. This skill belongs here because it centers on architectures and workflows for combining visual and linguistic representations in one system.",
            "exemplar_skills": [
              "Vision-Language Models",
              "multimodal transformers",
              "image-text alignment",
              "visual question answering",
              "image captioning",
              "cross-modal retrieval",
              "CLIP"
            ],
            "in_scope": "Vision-Language Models, multimodal transformers, image-text alignment, visual question answering, image captioning, OCR-aware multimodal models, CLIP-style embedding models, cross-modal retrieval, text-conditioned image understanding",
            "name": "Vision-Language Models",
            "out_of_scope": "Pure computer vision tasks such as object detection and segmentation, text-only NLP models and language modeling, model serving infrastructure and deployment, data pipeline engineering for training or inference",
            "overlap_flags": [
              {
                "reason": "Vision-language models are often deployed through the same inference serving patterns, but this dimension is about the model type itself rather than hosting or scaling it.",
                "with_dim_id": "model-serving-architecture",
                "with_dim_name": null,
                "with_role": "Machine Learning Engineer"
              },
              {
                "reason": "Some multimodal systems retrieve supporting context for prompts, but retrieval and context packaging are separate from the core vision-language modeling skill.",
                "with_dim_id": "context-management-and-retrieval",
                "with_dim_name": null,
                "with_role": "AI Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Vision-Language Models",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "vision-language-models"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "ai-ml",
            "ai",
            "ml"
          ],
          "related_to": [
            "mlflow",
            "mlops",
            "ray",
            "derived-views",
            "threat-modeling",
            "opensearch",
            "capacity-forecasting",
            "state-transitions"
          ],
          "requires": [],
          "skill_id": "vision-language-models",
          "suppress_on_match": []
        },
        "skill_id": "vision-language-models",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.93,
          "name": "Vision-Language Models",
          "reasoning": "Vision-Language Models are a named knowledge unit describing a class of multimodal models, so by the Concept vs Methodology rule they are fundamentally a Concept rather than a tool or framework.",
          "skill_id": "vision-language-models",
          "subtype": "multimodal_ai_model",
          "type": "Concept"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Version Control Systems",
            "id": 365,
            "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Multimodal Document Understanding",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Multimodal Document Understanding",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "multimodal_document_understanding",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "The phrase is specific and descriptive; in typical JDs it would be understood as the ML capability itself, not a different catalog skill."
          },
          "context_keywords": {
            "context_keywords": [
              "OCR",
              "layout analysis",
              "document parsing",
              "table extraction",
              "form understanding",
              "PDF extraction",
              "document classification",
              "entity extraction",
              "reading order",
              "bounding boxes",
              "vision-language models",
              "document AI",
              "scanned documents",
              "key-value extraction",
              "page segmentation"
            ]
          },
          "maturity": {
            "confidence": 0.84,
            "maturity": "emerging",
            "reasoning": "Appears increasingly in JDs for OCR/IDP and LLM vision roles, and vendor roadmaps from OpenAI, Google, and AWS show rapid productization, but it is not yet a universal hiring staple."
          },
          "skill_id": "multimodal-document-understanding",
          "vendor_license": {
            "confidence": 0.99,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Covers systems that extract, interpret, and reason over documents using both text and visual layout signals. This skill belongs here because it involves understanding pages, tables, figures, forms, and scanned content as a combined document representation.",
            "exemplar_skills": [
              "Multimodal Document Understanding",
              "OCR",
              "document layout analysis",
              "form understanding",
              "table extraction",
              "document QA",
              "key-value extraction"
            ],
            "in_scope": "Multimodal Document Understanding, OCR, document layout analysis, form understanding, table extraction, figure and chart interpretation, scanned PDF parsing, document classification, key-value extraction, page segmentation, visual-text fusion, document QA",
            "name": "Multimodal Document Understanding",
            "out_of_scope": "Pure text NLP tasks without layout or image signals, generic computer vision object detection, retrieval-only context packaging, model serving and deployment concerns",
            "overlap_flags": [
              {
                "reason": "Document understanding systems often use retrieval to select relevant pages or chunks before multimodal reasoning.",
                "with_dim_id": "context-management-and-retrieval",
                "with_dim_name": null,
                "with_role": "AI Engineer"
              },
              {
                "reason": "Production document-understanding models are frequently deployed as online or batch inference services.",
                "with_dim_id": "model-serving-architecture",
                "with_dim_name": null,
                "with_role": "Machine Learning Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Multimodal Document Understanding",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "multimodal-document-understanding"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "ai-ml",
            "ml"
          ],
          "related_to": [
            "mlops",
            "metadata-json",
            "derived-views",
            "opensearch",
            "microsoft-sentinel",
            "cross-chain-messaging",
            "merkle-proofs",
            "data-structures",
            "digital-signatures",
            "mlflow"
          ],
          "requires": [],
          "skill_id": "multimodal-document-understanding",
          "suppress_on_match": []
        },
        "skill_id": "multimodal-document-understanding",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.93,
          "name": "Multimodal Document Understanding",
          "reasoning": "This is a named knowledge unit about understanding documents across modalities, so by the Concept vs Methodology rule it is a Concept rather than a tool, framework, or architecture.",
          "skill_id": "multimodal-document-understanding",
          "subtype": "multimodal_document_understanding",
          "type": "Concept"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Version Control Systems",
            "id": 365,
            "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Agentic Systems",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Agentic Systems",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "agentic_systems",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "The term is fairly specific in JDs and usually refers to autonomous/agent-based AI systems, not a common overloaded acronym or short name. Typical extractor confusion with other catalog skills is unlikely."
          },
          "context_keywords": {
            "context_keywords": [
              "LLM agents",
              "tool use",
              "function calling",
              "planning",
              "reasoning",
              "memory",
              "orchestration",
              "multi-agent",
              "ReAct",
              "autonomous workflows",
              "retrieval-augmented generation",
              "prompt chaining",
              "workflow automation",
              "agent framework",
              "task decomposition"
            ]
          },
          "maturity": {
            "confidence": 0.84,
            "maturity": "emerging",
            "reasoning": "Job postings increasingly mention agentic AI/agent orchestration, and major vendors like OpenAI, Microsoft, and AWS have launched agent frameworks, but it is not yet a universal hiring staple."
          },
          "skill_id": "agentic-systems",
          "vendor_license": {
            "confidence": 0.99,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Covers building systems where LLMs or software agents plan, act, observe results, and iterate toward goals. This includes orchestration patterns, tool use, memory, guardrails, and multi-step task execution, which is the core meaning of Agentic Systems.",
            "exemplar_skills": [
              "Agentic Systems",
              "tool-using agents",
              "agent orchestration",
              "planning and replanning loops",
              "multi-step reasoning workflows",
              "goal decomposition",
              "function calling",
              "agent memory design"
            ],
            "in_scope": "Agentic Systems, autonomous task execution, tool-using agents, planning and replanning loops, multi-step reasoning workflows, agent orchestration, memory and scratchpad design, function calling, tool selection, goal decomposition",
            "name": "Agentic System Design",
            "out_of_scope": "Model serving deployment and runtime packaging, context window optimization, retrieval-only pipelines, prompt wording for single-turn chat, UI component design, which belong to other dimensions",
            "overlap_flags": [
              {
                "reason": "Agentic systems often use retrieval and context packaging, but that dimension owns the mechanics of selecting and assembling context.",
                "with_dim_id": "context-management-and-retrieval",
                "with_dim_name": null,
                "with_role": "AI Engineer"
              },
              {
                "reason": "Agentic systems may be deployed as services, but serving and scaling the model runtime is a separate operational concern.",
                "with_dim_id": "model-serving-architecture",
                "with_dim_name": null,
                "with_role": "Machine Learning Engineer"
              },
              {
                "reason": "Both involve multi-step process automation, but workflow automation is deterministic process design rather than autonomous agent behavior.",
                "with_dim_id": "workflow-automation-and-approvals",
                "with_dim_name": null,
                "with_role": "ServiceNOW Developer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Agentic Systems",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "agentic-systems"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "ai-ml",
            "ai",
            "agile",
            "authentication",
            "mfa",
            "state-transitions",
            "ansible",
            "ecs",
            "kinesis",
            "azure-ad"
          ],
          "requires": [],
          "skill_id": "agentic-systems",
          "suppress_on_match": []
        },
        "skill_id": "agentic-systems",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "Agentic Systems",
          "reasoning": "This is best treated as a named knowledge unit about autonomous AI behavior and system design, so under the Concept vs Methodology and Architecture vs Concept rules it is a Concept rather than a specific architecture or methodology.",
          "skill_id": "agentic-systems",
          "subtype": "agentic_systems",
          "type": "Concept"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Automation Scripting and CLI",
            "id": 48,
            "rationale": "Uses scripts and command-line tooling to execute repeatable Azure operations and reduce manual work. This is a practical cluster because the role frequently automates provisioning, checks, and remediation tasks.",
            "slug": "automation-scripting-and-cli",
            "source": "db"
          },
          "input_skill": "Claude Code",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Azure Cloud Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "azure-cloud-engineer",
              "source": "db"
            },
            {
              "display_name": "Cloud Engineer",
              "id": 18,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Automation Scripting and CLI",
            "id": 48,
            "rationale": "Uses scripts and command-line tooling to execute repeatable Azure operations and reduce manual work. This is a practical cluster because the role frequently automates provisioning, checks, and remediation tasks.",
            "slug": "automation-scripting-and-cli",
            "source": "db"
          },
          "input_skill": "Claude Code",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Azure Cloud Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "azure-cloud-engineer",
              "source": "db"
            },
            {
              "display_name": "Cloud Engineer",
              "id": 18,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Claude Code",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Tool",
          "skill_nature": "TOOL",
          "sub_category": "ai_coding_assistant_tool",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "Claude Code is a specific Anthropic coding assistant/CLI tool name and is unlikely to be mistaken for a different catalog skill in typical job descriptions."
          },
          "context_keywords": {
            "context_keywords": [
              "terminal",
              "CLI",
              "shell",
              "bash",
              "zsh",
              "git",
              "GitHub",
              "pull request",
              "code review",
              "refactor",
              "debugging",
              "test generation",
              "repository",
              "VS Code",
              "API"
            ]
          },
          "maturity": {
            "confidence": 0.78,
            "maturity": "emerging",
            "reasoning": "Appears in growing number of developer JDs and tooling discussions, but is not yet a universal hiring staple; market signal is rising adoption alongside other AI coding assistants rather than broad standardization."
          },
          "skill_id": "claude-code",
          "vendor_license": {
            "confidence": 0.93,
            "license": "proprietary",
            "vendor": "Anthropic",
            "year_introduced": 2024
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [
          {
            "a_dim_id": "automation-scripting-and-cli",
            "a_name": "Automation Scripting and CLI",
            "a_role": "__skill_focal__",
            "b_dim_id": "automation-scripting-and-cli",
            "b_name": "Automation Scripting and CLI",
            "b_role": "Azure Cloud Engineer",
            "pair_kind": "cross_role",
            "reasoning": "Although both dimensions share the same label and both involve scripts/CLI for repeatable work, they anchor on different skill clusters. Dim A is explicitly about developer-facing terminal workflows: its description centers on \"interact with development environments,\" and its exemplars include Claude Code, shell commands, bash scripting, PowerShell automation, repository navigation, and code editing from CLI. Dim B is Azure-operations-focused: it is about using scripts and command-line tooling to execute repeatable Azure operations, provisioning, checks, and remediation tasks. Those are cloud administration/automation skills, not general developer terminal workflows. The cross-role similarity is therefore a naming overlap, not a shared conceptual cluster.",
            "similarity": 0.7099153146813622
          }
        ],
        "locked_dimensions": [
          {
            "description": "Uses command-line tools and scripts to automate repeatable engineering tasks and interact with development environments. Claude Code fits here because it is a CLI-based coding assistant used to inspect, edit, and execute code workflows from the terminal.",
            "exemplar_skills": [
              "Claude Code",
              "command-line tooling",
              "bash scripting",
              "PowerShell automation",
              "terminal workflows",
              "developer task automation"
            ],
            "in_scope": "Claude Code, shell commands, terminal workflows, bash scripting, PowerShell automation, repeatable developer tasks, code editing from CLI, repository navigation, command-line tooling",
            "name": "Automation Scripting and CLI",
            "out_of_scope": "GUI-based IDE plugins, cloud infrastructure orchestration, application runtime code generation, model serving tools, which belong to other dimensions",
            "overlap_flags": [
              {
                "reason": "Claude Code often relies on selecting and packaging repository context for effective code assistance.",
                "with_dim_id": "context-management-and-retrieval",
                "with_dim_name": null,
                "with_role": "AI Engineer"
              },
              {
                "reason": "Using Claude Code may involve writing or modifying code in languages, but the dimension is about CLI automation rather than the language itself.",
                "with_dim_id": "analytical-programming-languages",
                "with_dim_name": null,
                "with_role": "Data Analyst, Data Scientist"
              }
            ],
            "tentative_id": "automation-scripting-and-cli"
          },
          {
            "description": "Uses scripts and command-line tooling to execute repeatable Azure operations and reduce manual work. This is a practical cluster because the role frequently automates provisioning, checks, and remediation tasks.",
            "exemplar_skills": [
              "Automation Scripting and CLI"
            ],
            "in_scope": "Skills, tools, and practices that belong under Automation Scripting and CLI for the target role, including items implied by the dimension rationale.",
            "name": "Automation Scripting and CLI",
            "out_of_scope": "Adjacent clusters explicitly not owned by Automation Scripting and CLI, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "automation-scripting-and-cli"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Claude Code",
          "placement_confidence": 0.92,
          "primary_dimension": "automation-scripting-and-cli",
          "reasoning": "Deterministic JD placement: locked_dimensions has 2 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "claude-code"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "go",
            "python",
            "javascript",
            "objective-c",
            "c-c",
            "solidity",
            "certora",
            "faiss",
            "ray",
            "ml"
          ],
          "requires": [
            "git",
            "python",
            "javascript"
          ],
          "skill_id": "claude-code",
          "suppress_on_match": []
        },
        "skill_id": "claude-code",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Platform: ruled out \u2014 it is not a hosted multi-tenant environment with APIs in the sense of a general application platform.",
            "Framework: ruled out \u2014 users do not build applications inside Claude Code."
          ],
          "confidence": 0.93,
          "name": "Claude Code",
          "reasoning": "By the Tool vs Framework rule, Claude Code is software you operate directly as a user to assist coding rather than a codebase you build applications inside.",
          "skill_id": "claude-code",
          "subtype": "ai_coding_assistant_tool",
          "type": "Tool"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:41-\u003e2"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Version Control Systems",
            "id": 365,
            "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Cursor",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Cursor",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Tool",
          "skill_nature": "TOOL",
          "sub_category": "ai_code_editor",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": true,
            "confused_with": [
              "cursor_ai"
            ],
            "reasoning": "\"Cursor\" is a generic term and can refer to the AI code editor or the mouse pointer/cursor in UI contexts. A JD extractor could plausibly confuse it with the related catalog skill \"cursor_ai\"."
          },
          "context_keywords": {
            "context_keywords": [
              "VS Code",
              "AI code editor",
              "code completion",
              "chat with codebase",
              "multi-file edits",
              "refactoring",
              "inline suggestions",
              "GitHub Copilot",
              "Claude",
              "OpenAI",
              "terminal integration",
              "project indexing",
              "diff view",
              "prompting",
              "autocomplete"
            ]
          },
          "maturity": {
            "confidence": 0.84,
            "maturity": "emerging",
            "reasoning": "Cursor appears in a growing number of developer job posts and AI-tooling stacks, but it is not yet a universal hiring staple like VS Code or GitHub Copilot."
          },
          "skill_id": "cursor",
          "vendor_license": {
            "confidence": 0.98,
            "license": "proprietary",
            "vendor": "Anysphere",
            "year_introduced": 2023
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Using AI-powered code editors and assistants to draft, edit, and navigate code faster. Cursor belongs here as a developer tool centered on AI-assisted programming workflows rather than a language or framework itself.",
            "exemplar_skills": [
              "Cursor",
              "GitHub Copilot",
              "Codeium",
              "AI-assisted refactoring",
              "prompt engineering for coding",
              "codebase chat"
            ],
            "in_scope": "Cursor, AI code completion, prompt-driven code edits, codebase chat, refactoring assistance, inline suggestions, agentic coding workflows",
            "name": "AI Coding Assistant Usage",
            "out_of_scope": "text editors without AI assistance, programming language syntax, IDE plugin development, source control workflows, which belong to other dimensions",
            "overlap_flags": [
              {
                "reason": "Cursor can be used alongside CLI automation, but the assistant itself is primarily a coding productivity tool rather than command-line automation.",
                "with_dim_id": "automation-scripting-and-cli",
                "with_dim_name": null,
                "with_role": "Azure Cloud Engineer, Cloud Engineer"
              },
              {
                "reason": "Cursor may help edit frontend code, but framework knowledge is separate from the tool used to author it.",
                "with_dim_id": "component-frameworks-and-rendering",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Developer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Cursor",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "cursor"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "javascript",
            "go",
            "objective-c",
            "ios",
            "android",
            "sql",
            "pinecone",
            "quicknode",
            "slither",
            "snapshot"
          ],
          "requires": [],
          "skill_id": "cursor",
          "suppress_on_match": []
        },
        "skill_id": "cursor",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "Cursor",
          "reasoning": "Cursor is software you run locally as an editor, so by the Tool vs Framework rule it is a Tool rather than a framework or platform.",
          "skill_id": "cursor",
          "subtype": "ai_code_editor",
          "type": "Tool"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Version Control Systems",
            "id": 365,
            "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Codex",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Codex",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Platform",
          "skill_nature": "PLATFORM",
          "sub_category": "ai_code_generation_platform",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cCodex\u201d in a JD would usually refer to OpenAI\u2019s code-generation platform; it\u2019s not a common overloaded skill name in this catalog context."
          },
          "context_keywords": {
            "context_keywords": [
              "prompt engineering",
              "code completion",
              "IDE integration",
              "API access",
              "sandbox",
              "chat-based coding",
              "repository context",
              "unit tests",
              "refactoring",
              "pair programming",
              "natural language to code",
              "GitHub",
              "VS Code",
              "autocomplete",
              "code review"
            ]
          },
          "maturity": {
            "confidence": 0.78,
            "maturity": "emerging",
            "reasoning": "OpenAI Codex is increasingly referenced in AI-assisted coding JDs and product stacks, but it is not yet a universal hiring staple like Python or AWS."
          },
          "skill_id": "codex",
          "vendor_license": {
            "confidence": 0.98,
            "license": "proprietary",
            "vendor": "OpenAI",
            "year_introduced": 2021
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Tools and workflows for AI-assisted code generation, editing, and refactoring. Codex belongs here because it is a code-focused assistant used to produce and transform source code from natural-language prompts.",
            "exemplar_skills": [
              "Codex",
              "AI code generation",
              "code completion",
              "refactoring assistance",
              "prompt-to-code",
              "repository-aware coding assistant"
            ],
            "in_scope": "Codex, AI code generation, prompt-to-code workflows, code completion, refactoring assistance, repository-aware coding assistants, IDE copilots, natural-language programming",
            "name": "Code Generation Assistants",
            "out_of_scope": "Model serving deployment, inference pipelines, context retrieval for general LLM apps, test automation frameworks, backend API design, which belong to other dimensions",
            "overlap_flags": [
              {
                "reason": "Code assistants often depend on retrieval and context packaging, but this dimension is about the coding workflow rather than the retrieval subsystem.",
                "with_dim_id": "context-management-and-retrieval",
                "with_dim_name": null,
                "with_role": "AI Engineer"
              },
              {
                "reason": "Some code-assistant usage overlaps with scripting automation, but Codex is centered on AI-assisted programming rather than operational scripting.",
                "with_dim_id": "automation-scripting-and-cli",
                "with_dim_name": null,
                "with_role": "Azure Cloud Engineer, Cloud Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Codex",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "codex"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "git",
            "argo-cd",
            "alchemy",
            "certora",
            "solidity",
            "the-graph",
            "arbitrum",
            "polygon",
            "cosmwasm",
            "dex"
          ],
          "requires": [],
          "skill_id": "codex",
          "suppress_on_match": []
        },
        "skill_id": "codex",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Service: ruled out \u2014 the name refers to the broader hosted product rather than a single managed capability inside another platform.",
            "Tool: ruled out \u2014 it is typically consumed as a hosted service/API, not run as user-operated software."
          ],
          "confidence": 0.72,
          "name": "Codex",
          "reasoning": "By the Vendor SaaS = Platform rule, Codex is best treated as a hosted AI product/API environment rather than software users run locally.",
          "skill_id": "codex",
          "subtype": "ai_code_generation_platform",
          "type": "Platform"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    }
  ],
  "unmatched_skills": [
    "LLM",
    "Prompting",
    "Context Management",
    "Structured Outputs",
    "VLMs",
    "OCR",
    "Layout Parsing",
    "Containers",
    "Evaluation",
    "Observability",
    "Failure Analysis",
    "RAG",
    "Hybrid Retrieval",
    "Reranking",
    "Vision-Language Models",
    "Multimodal Document Understanding",
    "Agentic Systems",
    "Claude Code",
    "Cursor",
    "Codex"
  ]
}

{
  "chosen_role": {
    "display_name": "AI Engineer",
    "id": 12,
    "rationale": "This role leverages multiple primary skills including Python, TypeScript, and AI workflows.",
    "role_archetype": null,
    "slug": "ai-engineer",
    "source": "db"
  },
  "chosen_role_resolution": "in_db",
  "final_input_skills": [
    {
      "skill": "Python",
      "tag": "in_db"
    },
    {
      "skill": "TypeScript",
      "tag": "in_db"
    },
    {
      "skill": "LLM",
      "tag": "new"
    },
    {
      "skill": "Prompting",
      "tag": "new"
    },
    {
      "skill": "Context Management",
      "tag": "new"
    },
    {
      "skill": "Structured Outputs",
      "tag": "new"
    },
    {
      "skill": "VLMs",
      "tag": "new"
    },
    {
      "skill": "OCR",
      "tag": "new"
    },
    {
      "skill": "Layout Parsing",
      "tag": "new"
    },
    {
      "skill": "Containers",
      "tag": "new"
    },
    {
      "skill": "CI/CD",
      "tag": "in_db"
    },
    {
      "skill": "Azure",
      "tag": "in_db"
    },
    {
      "skill": "GCP",
      "tag": "in_db"
    },
    {
      "skill": "Evaluation",
      "tag": "new"
    },
    {
      "skill": "Observability",
      "tag": "new"
    },
    {
      "skill": "Failure Analysis",
      "tag": "new"
    },
    {
      "skill": "RAG",
      "tag": "new"
    },
    {
      "skill": "Hybrid Retrieval",
      "tag": "new"
    },
    {
      "skill": "Reranking",
      "tag": "new"
    },
    {
      "skill": "Vision-Language Models",
      "tag": "new"
    },
    {
      "skill": "Multimodal Document Understanding",
      "tag": "new"
    },
    {
      "skill": "Agentic Systems",
      "tag": "new"
    },
    {
      "skill": "Claude Code",
      "tag": "new"
    },
    {
      "skill": "Cursor",
      "tag": "new"
    },
    {
      "skill": "Codex",
      "tag": "new"
    }
  ],
  "persistence": {
    "items": [
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Analytical Programming Languages",
          "id": 82,
          "rationale": "Languages used to clean, transform, analyze, and prototype models in notebooks and scripts. This is the core coding surface for expressing statistical logic and data manipulation in a reproducible way.",
          "slug": "analytical-programming-languages",
          "source": "db"
        },
        "dimension_id": 82,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Data Analyst",
            "id": 20,
            "rationale": null,
            "role_archetype": null,
            "slug": "data-analyst",
            "source": "db"
          },
          {
            "display_name": "Data Scientist",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "data-scientist",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 393,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Automation Scripting and CLI",
          "id": 48,
          "rationale": "Uses scripts and command-line tooling to execute repeatable Azure operations and reduce manual work. This is a practical cluster because the role frequently automates provisioning, checks, and remediation tasks.",
          "slug": "automation-scripting-and-cli",
          "source": "db"
        },
        "dimension_id": 48,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Azure Cloud Engineer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "azure-cloud-engineer",
            "source": "db"
          },
          {
            "display_name": "Cloud Engineer",
            "id": 18,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 393,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Automation and Scripting for Operations",
          "id": 361,
          "rationale": "Scripts and lightweight automation used to execute repetitive virtualization tasks and enforce operational consistency. This is the practical glue that reduces manual host and VM administration.",
          "slug": "automation-and-scripting-for-operations",
          "source": "db"
        },
        "dimension_id": 361,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Virtualization Engineer",
            "id": 26,
            "rationale": null,
            "role_archetype": null,
            "slug": "virtualization-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 393,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Network Automation and Scripting",
          "id": 285,
          "rationale": "Covers scripts and automation used to configure, validate, and audit network devices and services. This cluster is coherent because repeatable network operations increasingly depend on programmatic changes and checks.",
          "slug": "network-automation-and-scripting",
          "source": "db"
        },
        "dimension_id": 285,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Network Engineer",
            "id": 21,
            "rationale": null,
            "role_archetype": null,
            "slug": "network-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 393,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for AI Workflows",
          "id": 261,
          "rationale": "Languages used to implement AI feature logic, orchestration, and response handling inside product code. This is the core coding surface for turning prompts and model calls into reliable application behavior.",
          "slug": "programming-languages-for-ai-workflows",
          "source": "db"
        },
        "dimension_id": 261,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "AI Engineer",
            "id": 12,
            "rationale": null,
            "role_archetype": null,
            "slug": "ai-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 393,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for Backend Systems",
          "id": 140,
          "rationale": "Languages used to implement server-side business logic, request handlers, workers, and service integrations. This is the core coding surface for backend feature delivery and maintenance.",
          "slug": "programming-languages-for-backend-systems",
          "source": "db"
        },
        "dimension_id": 140,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Engineer",
            "id": 14,
            "rationale": null,
            "role_archetype": null,
            "slug": "backend-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 393,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for Data Work",
          "id": 67,
          "rationale": "Languages used to implement data pipelines, transformations, and operational utilities. This is the code layer for expressing extraction, parsing, validation, and orchestration logic in data engineering workflows.",
          "slug": "programming-languages-for-data-work",
          "source": "db"
        },
        "dimension_id": 67,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Data Engineer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "data-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 393,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for ML Systems",
          "id": 113,
          "rationale": "Languages used to implement model integration code, inference services, and feature-processing logic. This is the core coding surface for turning trained models into product-facing software components.",
          "slug": "programming-languages-for-ml-systems",
          "source": "db"
        },
        "dimension_id": 113,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Machine Learning Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "machine-learning-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 393,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for Security Work",
          "id": 328,
          "rationale": "Languages used to automate security tasks, write detection logic, and build analysis or remediation tooling. This is the core coding surface for a cybersecurity engineer across scripts, queries, and small utilities.",
          "slug": "programming-languages-for-security-work",
          "source": "db"
        },
        "dimension_id": 328,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cybersecurity Engineer",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 393,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for Test Automation",
          "id": 193,
          "rationale": "Languages used to implement automated checks, helper utilities, and test harness code. This is the core coding surface for turning test ideas into maintainable automation.",
          "slug": "programming-languages-for-test-automation",
          "source": "db"
        },
        "dimension_id": 193,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Automation Tester",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "automation-tester",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 393,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Security Automation and Scripting",
          "id": 258,
          "rationale": "Automating repeatable security checks, enrichment, and remediation workflows. This cluster is coherent because the role often needs lightweight automation to scale analysis and response.",
          "slug": "security-automation-and-scripting",
          "source": "db"
        },
        "dimension_id": 258,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cybersecurity Engineer",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 393,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Frontend Programming Languages",
          "id": 1,
          "rationale": "Languages used to implement browser-side application logic, component behavior, and UI state. This is the core code layer for frontend features and interactive experiences.",
          "slug": "frontend-programming-languages",
          "source": "db"
        },
        "dimension_id": 1,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Frontend Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": "Frontend Engineers design and build the user-facing parts of applications, translating product and design requirements into interactive experiences. They focus on how the application looks, behaves, and responds in the browser, ensuring usability, accessibility, and consistency across the interface.",
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Full Stack Developer",
            "id": 2,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for AI Workflows",
          "id": 261,
          "rationale": "Languages used to implement AI feature logic, orchestration, and response handling inside product code. This is the core coding surface for turning prompts and model calls into reliable application behavior.",
          "slug": "programming-languages-for-ai-workflows",
          "source": "db"
        },
        "dimension_id": 261,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "AI Engineer",
            "id": 12,
            "rationale": null,
            "role_archetype": null,
            "slug": "ai-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for ML Systems",
          "id": 113,
          "rationale": "Languages used to implement model integration code, inference services, and feature-processing logic. This is the core coding surface for turning trained models into product-facing software components.",
          "slug": "programming-languages-for-ml-systems",
          "source": "db"
        },
        "dimension_id": 113,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Machine Learning Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "machine-learning-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for Test Automation",
          "id": 193,
          "rationale": "Languages used to implement automated checks, helper utilities, and test harness code. This is the core coding surface for turning test ideas into maintainable automation.",
          "slug": "programming-languages-for-test-automation",
          "source": "db"
        },
        "dimension_id": 193,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Automation Tester",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "automation-tester",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Version Control Systems",
          "id": 365,
          "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 365,
        "input_skill": "CI/CD",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2579,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platform Operations",
          "id": 26,
          "rationale": "Uses cloud provider services to support delivery and runtime environments. The focus is on consumer-level operation of cloud services rather than deep cloud architecture ownership.",
          "slug": "cloud-platform-operations",
          "source": "db"
        },
        "dimension_id": 26,
        "input_skill": "Azure",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "DevOps Engineer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A DevOps Engineer enables reliable, repeatable delivery of software by designing and operating the processes that connect development and production. They focus on improving deployment flow, operational stability, and collaboration between teams through automation, standardization, and monitoring of delivery and runtime practices.",
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 164,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Security Platforms",
          "id": 332,
          "rationale": "Cloud-native security products used to assess posture, detect misconfigurations, and monitor workloads across AWS, Azure, and GCP. This is a distinct product family because the role often works across multiple CNAPP/CSPM/CWPP offerings and cloud-native detectors.",
          "slug": "cloud-security-platforms",
          "source": "db"
        },
        "dimension_id": 332,
        "input_skill": "Azure",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cybersecurity Engineer",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 164,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Security Platforms",
          "id": 332,
          "rationale": "Cloud-native security products used to assess posture, detect misconfigurations, and monitor workloads across AWS, Azure, and GCP. This is a distinct product family because the role often works across multiple CNAPP/CSPM/CWPP offerings and cloud-native detectors.",
          "slug": "cloud-security-platforms",
          "source": "db"
        },
        "dimension_id": 332,
        "input_skill": "GCP",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cybersecurity Engineer",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2304,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Version Control Systems",
          "id": 365,
          "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 365,
        "input_skill": "LLM",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2648,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Version Control Systems",
          "id": 365,
          "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 365,
        "input_skill": "Prompting",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2649,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Context Management and Retrieval",
          "id": 264,
          "rationale": "Preparing, selecting, and packaging context for model calls so responses stay relevant and grounded. This is a distinct cluster because AI features often depend on what information is included, summarized, or retrieved at call time.",
          "slug": "context-management-and-retrieval",
          "source": "db"
        },
        "dimension_id": 264,
        "input_skill": "Context Management",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "AI Engineer",
            "id": 12,
            "rationale": null,
            "role_archetype": null,
            "slug": "ai-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2650,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Version Control Systems",
          "id": 365,
          "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 365,
        "input_skill": "Context Management",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2650,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": null,
          "display_name": "Context Management, Retrieval, and Response Shaping",
          "id": null,
          "rationale": "Preparing, selecting, retrieving, and packaging the right context for model calls so responses are relevant, grounded, and usable. Includes prompt context selection, retrieval-augmented generation, context window management, schema-constrained generation, Structured Outputs, JSON schema prompting, tool-call argument shaping, and other response-grounding techniques that control what information the model sees and how its output is structured.",
          "slug": "d_merge_01",
          "source": "llm"
        },
        "dimension_id": 264,
        "input_skill": "Structured Outputs",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (reconciliation merge) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2651,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Version Control Systems",
          "id": 365,
          "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 365,
        "input_skill": "VLMs",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2652,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Version Control Systems",
          "id": 365,
          "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 365,
        "input_skill": "OCR",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2653,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Project Delivery and Coordination",
          "id": 366,
          "rationale": "Coordination practices for organizing work, tracking progress, and aligning stakeholders across a delivery effort. Agile fits here when used as a team execution framework for managing scope, cadence, and collaboration.",
          "slug": "d_init_02",
          "source": "db"
        },
        "dimension_id": 366,
        "input_skill": "OCR",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2653,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Version Control Systems",
          "id": 365,
          "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 365,
        "input_skill": "Layout Parsing",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2654,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Version Control Systems",
          "id": 365,
          "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 365,
        "input_skill": "Containers",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2655,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Model Evaluation and Validation",
          "id": 86,
          "rationale": "Techniques for assessing model quality, robustness, and uncertainty before recommendations are made. This includes choosing metrics, validating generalization, and understanding error tradeoffs.",
          "slug": "model-evaluation-and-validation",
          "source": "db"
        },
        "dimension_id": 86,
        "input_skill": "Evaluation",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Data Scientist",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "data-scientist",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2656,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Version Control Systems",
          "id": 365,
          "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 365,
        "input_skill": "Observability",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2657,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Test Evidence, Defect Reporting, and Triage",
          "id": 241,
          "rationale": "Capturing and organizing clear evidence from manual testing, including what was tested, what was observed, and how to reproduce issues, then communicating defect severity, impact, and triage notes so teams can prioritize fixes and make release decisions. This includes test notes, screenshots, screen recordings, execution logs, reproduction steps, bug reports, severity/priority assessment, and concise status or coverage summaries.",
          "slug": "test-evidence-defect-reporting-and-triage",
          "source": "db"
        },
        "dimension_id": 241,
        "input_skill": "Failure Analysis",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Manual Tester",
            "id": 17,
            "rationale": null,
            "role_archetype": null,
            "slug": "manual-tester",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2658,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "MySQL Operational Monitoring, Logging, and Diagnostics",
          "id": 166,
          "rationale": "Covers the DBA practice of monitoring MySQL production health and using MySQL-native logs and diagnostic views to detect, investigate, and explain incidents or performance anomalies. Includes routine health checks, alerting, replication and availability monitoring, resource and connection monitoring, and use of error logs, slow query logs, SHOW PROCESSLIST, performance_schema, status variables, and diagnostic queries to understand behavior and support recovery decisions.",
          "slug": "mysql-operational-monitoring-logging-and-diagnostics",
          "source": "db"
        },
        "dimension_id": 166,
        "input_skill": "Failure Analysis",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "MySQL DBA",
            "id": 23,
            "rationale": null,
            "role_archetype": null,
            "slug": "mysql-dba",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2658,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": null,
          "display_name": "Context Management, Retrieval, and Grounding for Model Calls",
          "id": null,
          "rationale": "Preparing, selecting, retrieving, summarizing, and packaging information for model calls so outputs stay relevant, grounded, and within the available context window. This includes RAG / retrieval-augmented generation, chunking documents, embedding-based retrieval, vector search, reranking, source grounding, prompt assembly, and other call-time knowledge retrieval and context management techniques.",
          "slug": "d_merge_01",
          "source": "llm"
        },
        "dimension_id": 264,
        "input_skill": "RAG",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (reconciliation merge) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2659,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Service Integration Patterns",
          "id": 188,
          "rationale": "Covers how cloud services and workloads connect through APIs, events, shared services, and integration boundaries. This cluster is coherent because architects must define interaction patterns that preserve decoupling, security, and operability.",
          "slug": "cloud-service-integration-patterns",
          "source": "db"
        },
        "dimension_id": 188,
        "input_skill": "RAG",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cloud Architect",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2659,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": null,
          "display_name": "Context Assembly and Retrieval for Model Calls",
          "id": null,
          "rationale": "Preparing, selecting, retrieving, reranking, and packaging information for model calls so responses stay relevant and grounded. Includes hybrid retrieval, vector and keyword search, chunk selection, context assembly, retrieval-augmented generation, document grounding, and query rewriting when used to build the context supplied to a model.",
          "slug": "d_merge_01",
          "source": "llm"
        },
        "dimension_id": 264,
        "input_skill": "Hybrid Retrieval",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (reconciliation merge) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2660,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Context Management and Retrieval",
          "id": 264,
          "rationale": "Preparing, selecting, and packaging context for model calls so responses stay relevant and grounded. This is a distinct cluster because AI features often depend on what information is included, summarized, or retrieved at call time.",
          "slug": "context-management-and-retrieval",
          "source": "db"
        },
        "dimension_id": 264,
        "input_skill": "Reranking",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "AI Engineer",
            "id": 12,
            "rationale": null,
            "role_archetype": null,
            "slug": "ai-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2661,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Version Control Systems",
          "id": 365,
          "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 365,
        "input_skill": "Vision-Language Models",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2662,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Version Control Systems",
          "id": 365,
          "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 365,
        "input_skill": "Multimodal Document Understanding",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2663,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Version Control Systems",
          "id": 365,
          "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 365,
        "input_skill": "Agentic Systems",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2664,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Automation Scripting and CLI",
          "id": 48,
          "rationale": "Uses scripts and command-line tooling to execute repeatable Azure operations and reduce manual work. This is a practical cluster because the role frequently automates provisioning, checks, and remediation tasks.",
          "slug": "automation-scripting-and-cli",
          "source": "db"
        },
        "dimension_id": 48,
        "input_skill": "Claude Code",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Azure Cloud Engineer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "azure-cloud-engineer",
            "source": "db"
          },
          {
            "display_name": "Cloud Engineer",
            "id": 18,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2665,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Version Control Systems",
          "id": 365,
          "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 365,
        "input_skill": "Cursor",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2666,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Version Control Systems",
          "id": 365,
          "rationale": "Tools and workflows for tracking source changes, branching, merging, and collaborating on code history. Git belongs here because it is the canonical distributed version control system used to manage revisions and coordinate team development.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 365,
        "input_skill": "Codex",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2667,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Model Evaluation and Validation",
          "id": null,
          "rationale": "Covers assessing model quality, reliability, and fit for purpose using offline and online validation methods. This skill belongs here because evaluation is the core activity for measuring whether a model or system meets expected performance criteria.",
          "slug": "d_init_01",
          "source": "llm"
        },
        "dimension_id": 86,
        "input_skill": "Evaluation",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (embedding dedup) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2656,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 12,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Test Evidence, Defect Reporting, and Triage",
          "id": null,
          "rationale": "Capturing and organizing evidence from testing to investigate failures, reproduce issues, and communicate clear defect reports for triage. Includes documenting what was tested and observed, collecting logs/screenshots/screen recordings, writing reproduction steps and bug reports, assessing severity/priority or release impact, and providing concise notes that help teams prioritize fixes.",
          "slug": "d_merge_01",
          "source": "llm"
        },
        "dimension_id": 241,
        "input_skill": "Failure Analysis",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "New skill saved \u00b7 Existing dimension (reconciliation merge) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 2658,
        "skill_tag": "in_db",
        "skipped_reason": null
      }
    ],
    "new_skills_created": 20,
    "role_dimension_saved": 0,
    "skill_dimension_saved": 24,
    "skipped": 0
  },
  "planner_output": null,
  "run_id": "62310ed0-c8e6-4590-a4e8-edafce525331"
}