Pipeline run

4d35418a-3821-4fe3-8cbc-48910b959cf5

Pipeline LLM cost (USD)

API 1: $0.0051 API 2: $0.4430 API 3: $0.0000 Total: $0.4481

Client output enrichment

v2 Skill cluster · Nature of work · AI index · Tech stack maturity · Evidence · KRA description

role baseline loaded sources · ai_index: jd · nature_of_work: jd · tech_stack_maturity: jd

Nature of work · Local storage and app stability

Build and ship production Flutter apps end-to-end, focusing on clean architecture, offline-first state/data flows, API integrations, native Kotlin/Swift bridges, and performance tuning to remove jank and harden releases.

"High-performance engineering: Profile and eliminate jank, memory leaks, and frame drops"

Tech stack maturity

Mainstream Modern

The skill set centers on contemporary mobile development across iOS, Android, and Flutter with platform integration, which aligns with widely adopted modern engineering stacks rather than legacy or bleeding-edge niche tooling.

AI index (0 = no AI use, 5 = totally AI-dependent · v2.1)

0.00 / 5

· Title match

· Has AI skill

· AI skill (primary)

· AI skill (secondary)

· On AI team

· Builds AI products

vocab breakdown (legacy)

Assistants (×1): —

Frameworks (×2): —

Models / concepts (×3): —

Evidence — skills matched in JD (42)

Flutter iOS Android Kotlin Swift Platform Channels API Integration Riverpod Agora Twilio WebRTC MVVM MVI Clean Architecture Dependency Injection Offline-first Caching Sync Secure Storage Sockets Push Notifications Image Caching Profiling Authentication Pagination +17

Skill cluster (17 dimension groups, role-scoped)

App Architecture and Dependency Injection

MVVM MVI Dependency Injection

Networking and API Integration

API Integration Sockets Reconnection Logic

Crash Reporting and Observability

Crash Analytics Recording

Performance and Stability Tuning

Image Caching Bandwidth Adaptation

Screen Navigation and State

Riverpod Sync

Testing and Quality Assurance

Integration Testing Mocks

API Design and Contracts

Idempotency

API Integration and Data Fetching

Pagination

Authentication and Session Handling

Authentication

Background Execution and Lifecycle

Push Notifications

Feature Flags and Release Control

Feature Flags

Flutter UI Framework

Flutter

Native Mobile App Architecture and Dependency Injection

Clean Architecture

Native Mobile Languages

Kotlin

Performance and Resource Tuning

Profiling

Swift and Objective-C

Swift

Cross-cutting / unaligned

iOS Android Platform Channels Agora Twilio WebRTC Offline-first Caching Secure Storage Unit Testing Widget Testing Golden Tests Fakes A/B Testing CI/CD Lazy Lists Screen Sharing Echo Cancellation

Show KRA description ↓

• Own app architecture end-to-end: Design, build, and ship scalable Flutter apps for iOS & Android, with clean layered architecture, modular code, and strong production discipline. • High-performance engineering: Profile and eliminate jank, memory leaks, and frame drops; optimize rendering pipelines; deliver buttery-smooth experiences at 60/120fps across devices. • Advanced state & data systems: Architect offline-first data flows, reliable caching/sync strategies, secure storage, and maintainable state patterns (Riverpod preferred) for real-world constraints. • Deep native integrations: Use platform channels and native code (Kotlin/Swift) for audio/video SDKs (Agora/Twilio/WebRTC), background tasks, notifications, and OS-level capabilities. • Production robustness & release excellence: Implement crash analytics, A/B testing, feature flags, CI/CD automation, and progressive rollouts; rapidly debug and harden apps at scale. Must haves: • 4+ years of mobile development experience with at least 2+ years in Flutter shipping production apps used by real users. • Strong problem-solving mindset: you don’t stop at ‘it works’, you ask why and fix the root cause. • Shipped at least one complex Flutter app end-to-end (architecture and tradeoffs). • Solid grasp of app architectures (MVVM/MVI/Clean), dependency injection, layering, and testability. • Demonstrated offline-first patterns and efficient local data modelling (indexes, pagination, partial sync). • Real-time features experience: sockets, background updates, push notifications, reconnection logic. • Pro at performance: render pipeline basics, avoiding rebuilds, isolating heavy work, lazy lists, image caching/decoding, and profiling tools. • Comfortable dropping to Kotlin/Swift for platform-specific capabilities. • Strong with API integration (auth, retries, idempotency, pagination, caching) and secure secrets handling. • Testing mindset: unit, widget, and integration tests; golden tests; mocks/fakes; coverage where it counts. • Hands-on experience integrating native libraries/SDKs (e.g., Agora, Twilio, WebRTC) into Flutter apps for real-time communication features. • Deep familiarity call setup, echo cancellation, bandwidth adaptation, screen share, recording, and session lifecycle management. • Experience bridging Flutter ↔ native SDKs when no official plugin exists. • Clear, maintainable code with excellent documentation and PR discipline.

Signals

Skill backend-engineer

0.17

Alias hybrid-mobile-developer

0.81

KRA ios-engineer

0.39

Post-classification

Centroidupdated · n=16

Alias collision log—

New-role queue—

New skills captured28

New KRA capturedyes

Captured for admin review

iOS primary ↔ Ios engineer pending

Android primary ↔ Ios engineer pending

Riverpod ↔ Ios engineer pending

Platform Channels primary ↔ Ios engineer pending

Agora ↔ Ios engineer pending

Twilio ↔ Ios engineer pending

WebRTC ↔ Ios engineer pending

Offline-first ↔ Ios engineer pending

Caching ↔ Ios engineer pending

Sync ↔ Ios engineer pending

Secure Storage ↔ Ios engineer pending

Sockets ↔ Ios engineer pending

Push Notifications ↔ Ios engineer pending

Image Caching ↔ Ios engineer pending

API Integration primary ↔ Ios engineer pending

Authentication ↔ Ios engineer pending

Widget Testing ↔ Ios engineer pending

Golden Tests ↔ Ios engineer pending

Mocks ↔ Ios engineer pending

Fakes ↔ Ios engineer pending

A/B Testing ↔ Ios engineer pending

Crash Analytics ↔ Ios engineer pending

Lazy Lists ↔ Ios engineer pending

Reconnection Logic ↔ Ios engineer pending

Screen Sharing ↔ Ios engineer pending

Echo Cancellation ↔ Ios engineer pending

Bandwidth Adaptation ↔ Ios engineer pending

Recording ↔ Ios engineer pending

R&R fragment (sim 0.39) ↔ Ios engineer pending

Status: completed Created: 2026-05-19T19:49:10.527539Z Updated: 2026-05-19T19:51:38.192656Z API 3 duration: 23621 ms

Flow Current 3-step pipeline

1 POST /skills/extract-from-jd

2 POST /skills/extract-details

3 POST /skills/final-role-output

Role Chosen role & resolution

Hybrid Mobile Developer

CASE A

slug: hybrid-mobile-developer · id: 11 · source: db

The primary skills focus on cross-platform development including Flutter, iOS, and Android, which align with the Hybrid Mobile Developer role.

Resolution: in_db — role exists in library; skill↔dim and role↔dim links saved when applicable.

New skills

Skill↔dim saved

Role↔dim saved

Skipped

Job description

About the Role

We’re looking for a Senior Mobile Engineer (Flutter) who can help us build world-class mobile applications (iOS + Android) that are smooth, scalable, and built to last. This is not just a “widget implementation” role - you’ll be owning the entire mobile engineering stack, from architecture to performance, to making sure every tap feels buttery-smooth.

Tech you’ll touch

Flutter & Dart, Riverpod (preferred) / Provider / BLoC, Kotlin, Swift, Platform Channels, SDKs, SQLite/Drift, ObjectBox, Hive, Socket.IO/WebSockets, WebRTC, REST/GraphQL/gRPC, Firebase, Crashlytics/Sentry, WorkManager, Background tasks (iOS), GitHub Actions/Codemagic, Play Console & App Store Connect.

Key Responsibilities
• Own app architecture end-to-end: Design, build, and ship scalable Flutter apps for iOS & Android, with clean layered architecture, modular code, and strong production discipline.
• High-performance engineering: Profile and eliminate jank, memory leaks, and frame drops; optimize rendering pipelines; deliver buttery-smooth experiences at 60/120fps across devices.
• Advanced state & data systems: Architect offline-first data flows, reliable caching/sync strategies, secure storage, and maintainable state patterns (Riverpod preferred) for real-world constraints.
• Deep native integrations: Use platform channels and native code (Kotlin/Swift) for audio/video SDKs (Agora/Twilio/WebRTC), background tasks, notifications, and OS-level capabilities.
• Production robustness & release excellence: Implement crash analytics, A/B testing, feature flags, CI/CD automation, and progressive rollouts; rapidly debug and harden apps at scale.

What makes you a great fit?

Must haves:
• 4+ years of mobile development experience with at least 2+ years in Flutter shipping production apps used by real users.
• Strong problem-solving mindset: you don’t stop at ‘it works’, you ask why and fix the root cause.
• Shipped at least one complex Flutter app end-to-end (architecture and tradeoffs).
• Solid grasp of app architectures (MVVM/MVI/Clean), dependency injection, layering, and testability.
• Demonstrated offline-first patterns and efficient local data modelling (indexes, pagination, partial sync).
• Real-time features experience: sockets, background updates, push notifications, reconnection logic.
• Pro at performance: render pipeline basics, avoiding rebuilds, isolating heavy work, lazy lists, image caching/decoding, and profiling tools.
• Comfortable dropping to Kotlin/Swift for platform-specific capabilities.
• Strong with API integration (auth, retries, idempotency, pagination, caching) and secure secrets handling.
• Testing mindset: unit, widget, and integration tests; golden tests; mocks/fakes; coverage where it counts.
• Hands-on experience integrating native libraries/SDKs (e.g., Agora, Twilio, WebRTC) into Flutter apps for real-time communication features.
• Deep familiarity call setup, echo cancellation, bandwidth adaptation, screen share, recording, and session lifecycle management.
• Experience bridging Flutter ↔ native SDKs when no official plugin exists.
• Clear, maintainable code with excellent documentation and PR discipline.

Skills from this JD

Each row merges API 1 extraction, API 2 library match / v3 orchestration (dimensions + locked dims), and API 3 persistence tags.

Flutter Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)

Canonical: Flutter id=1041 · flutter

Aliases — catalog

Flutter (CANONICAL) primary
Flutter 3 (VERSION)
Flutter 3.x (VERSION)
Flutter3 (VERSION)
flutter (VERSION)
flutter 3 (VERSION)
flutter 3.x (VERSION)
flutter3 (VERSION)

Context tags (catalog)

Animation Animations BuildContext Cross-Platform Cupertino Dart Firebase Integration Flutter CLI Flutter Desktop Flutter DevTools Flutter Packages Flutter SDK Flutter Web Hot Reload Material Design Pub.dev Responsive Design State Management Widget Tree Widgets

Stored enrichment (catalog DB)

Category: Framework
Sub-category: Ui Framework
Vendor: Google
License: bsd
Year introduced: 2015
Confidence: 0.99
Version strategy: SEPARATE_ENTITY
Version tag: 3.x

Maturity reasoning: Flutter appears in many mobile/full-stack job postings and is a common cross-platform UI framework; Google continues active releases and ecosystem growth, indicating broad adoption rather than niche use.

Skill profile (library / DB)

Skill nature: FRAMEWORK
Volatility: STABLE
Typical lifespan: EVERGREEN
Category id: 5
Sub-category id: 341
Extractable: True
Also category: False

Dimensions (API 2 worklist)

UI Frameworks and Rendering Catalog dimension db id 115

Library dimension (catalog)

Roles linked in library: Frontend Engineer, Full Stack Engineer, Hybrid Mobile Developer

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
UI Frameworks and Rendering ui-frameworks-and-rendering	✓	✓	Existing dimension (library) · Role↔dimension saved

iOS Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.98

iOS is a mainstream mobile platform with high JD volume for Swift/iOS roles across consumer and enterprise apps; Apple continues active platform support and releases, indicating broad adoption rather than niche use.

Vendor & license

Apple Inc. ·proprietary ·since 2007 (0.95)

Context keywords

Swift UIKit Core Data Xcode Cocoa Touch SwiftUI Objective-C App Store CocoaPods MVVM RESTful APIs Auto Layout TestFlight iCloud Push Notifications

Ambiguity low

“iOS” is a specific mobile operating system; unlikely to be confused with other catalog skills.

Versioning

Not versioned

Type assignment

Platform ·mobile_operating_platform confidence 0.93

By the Platform vs Tool rule, iOS is a hosted operating platform/ecosystem for apps and services rather than software you run yourself, so it fits Platform best.

Derived legacy fields

Category: Platform
Sub-category: mobile_operating_platform
Skill nature: PLATFORM
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

React Frontend Development Catalog dimension db id 96

Library dimension (catalog)

Locked dimensions (v3 placement)

iOS App Development
Pipeline tentative id

Core skills for building native iPhone and iPad applications with Apple's platform APIs and app lifecycle model. iOS fits here because it names the platform itself, which spans UI, device integration, and app behavior on Apple devices.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Android Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.98

Android appears in large volumes of mobile job postings and remains a standard platform in hiring pipelines; Google continues active platform releases and OEM ecosystem support, indicating broad adoption.

Vendor & license

Google ·apache_2 ·since 2008 (0.95)

Context keywords

Kotlin Java Android Studio Gradle XML Jetpack RecyclerView MVVM LiveData Room Retrofit Firebase Material Design API Level Android SDK

Ambiguity low

“Android” in JDs typically refers specifically to the Android mobile platform; it’s unlikely to be confused with another distinct catalog skill.

Versioning

Not versioned

Type assignment

Platform ·mobile_platform confidence 0.95

Android is a hosted mobile ecosystem with APIs and managed services for app distribution and device integration, so by the Platform vs Tool rule it is a Platform rather than software you run yourself.

Derived legacy fields

Category: Platform
Sub-category: mobile_platform
Skill nature: PLATFORM
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

React Frontend Development Catalog dimension db id 96

Library dimension (catalog)

Locked dimensions (v3 placement)

Android App Development
Pipeline tentative id

Core skills for building native Android applications, including platform APIs, app structure, and device-specific behavior. Android belongs here because it is the primary operating system and development surface for Android mobile engineering.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Kotlin Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)

Canonical: Kotlin id=2 · kotlin

Aliases — catalog

Kotlin (CANONICAL) primary
kotlin 1.9 (VERSION)
kotlin 1.9.0 (VERSION)
kotlin 1.9.1 (VERSION)
kotlin 1.9.10 (VERSION)
kotlin 1.9.x (VERSION)
kotlin-1.9 (VERSION)

Context tags (catalog)

Android Anko Coroutines DSL Dagger Data classes Extension functions Flow Gradle Hilt JUnit Jetpack Jetpack Compose Kotlin DSL Kotlin Native Kotlinx Ktor MVI MVVM Mockito Multiplatform Null safety Retrofit Room RxKotlin Sealed classes Spring Type inference

Stored enrichment (catalog DB)

Category: Language
Sub-category: Programming Language
Vendor: JetBrains
License: apache_2
Year introduced: 2011
Confidence: 0.99
Version strategy: NOT_APPLICABLE

Maturity reasoning: Kotlin appears in many Android, backend, and multiplatform job postings, and JetBrains reports strong ecosystem growth; it’s a mainstream hiring skill rather than niche.

Skill profile (library / DB)

Skill nature: LANGUAGE
Volatility: STABLE
Typical lifespan: EVERGREEN
Category id: 6
Sub-category id: 96
Extractable: True
Also category: False

Dimensions (API 2 worklist)

Kotlin and Java Catalog dimension db id 161

Library dimension (catalog)

Roles linked in library: Android Engineer
Programming Languages Catalog dimension db id 1

Library dimension (catalog)

Roles linked in library: Backend Engineer, Full Stack Engineer

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Kotlin and Java kotlin-and-java	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages programming-languages	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Swift Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)

Canonical: Swift id=440 · swift

Aliases — catalog

Swift (CANONICAL) primary
Swift 2.0 (VERSION)
Swift 2.x (VERSION)
Swift 3.0 (VERSION)
Swift 3.x (VERSION)
Swift 4.0 (VERSION)
Swift 4.x (VERSION)
Swift 5.0 (VERSION)
Swift 5.x (VERSION)
Swift 6.0 (VERSION)
Swift 6.x (VERSION)

Context tags (catalog)

ARC Cocoa Cocoa Touch CocoaPods Combine Core Data Grand Central Dispatch MVVM Objective-C Optionals SPM Swift Package Manager SwiftUI UIKit Xcode async/await asynchronous programming closure closures error handling iOS Development protocol-oriented programming type safety

Stored enrichment (catalog DB)

Category: Language
Sub-category: Programming Language
Vendor: Apple
License: apache_2
Year introduced: 2014
Confidence: 0.99
Version strategy: NOT_APPLICABLE

Maturity reasoning: Swift is broadly used for iOS/macOS hiring; job postings commonly list it alongside UIKit/SwiftUI, and Apple continues to invest in it as the primary language for new app development.

Skill profile (library / DB)

Skill nature: LANGUAGE
Volatility: STABLE
Typical lifespan: EVERGREEN
Category id: 6
Sub-category id: 96
Extractable: True
Also category: False

Dimensions (API 2 worklist)

Swift and Objective-C Catalog dimension db id 81

Library dimension (catalog)

Roles linked in library: Ios engineer

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Swift and Objective-C swift-and-objective-c	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Riverpod Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity emerging confidence 0.84

Riverpod appears in growing Flutter job postings and package adoption, but it is still far less universal than Provider/BLoC in JDs and hiring pipelines.

Vendor & license

Remi Rousselet ·mit ·since 2020 (0.90)

Context keywords

Flutter Provider StateNotifier ChangeNotifier ScopedReader AutoDispose AsyncValue Riverpod 2.0 hooks_riverpod Dependency Injection Global State State Management Immutable State Reactivity Widget Tree

Ambiguity low

Riverpod is a specific Flutter/Dart state-management framework; unlikely to be confused with other catalog skills.

Versioning

Versioned 2

{
  "flutter_riverpod": "2",
  "flutter_riverpod 2": "2",
  "flutter_riverpod v2": "2",
  "riverpod 2": "2",
  "riverpod v2": "2",
  "riverpod2": "2"
}

Type assignment

Framework ·state_management_framework confidence 0.90

Riverpod is a Flutter/Dart state-management framework that developers build applications with, so it fits the Tool vs Framework rule as a Framework rather than a library or tool.

Derived legacy fields

Category: Framework
Sub-category: state_management_framework
Skill nature: FRAMEWORK
Volatility: EMERGING
Typical lifespan: EVERGREEN
Version strategy: SEPARATE_ENTITY

Dimensions (API 2 worklist)

Screen Navigation and State Catalog dimension db id 83

Library dimension (catalog)

Roles linked in library: Android Engineer, Full Stack Engineer, Hybrid Mobile Developer, Ios engineer

Locked dimensions (v3 placement)

Flutter State Management
Reuses catalog slug

Patterns and libraries for managing UI state, dependency injection, and reactive updates in Flutter apps. Riverpod belongs here because it is a core Flutter state-management solution used to expose app state to widgets and coordinate feature logic.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Screen Navigation and State screen-navigation-and-state	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved

Platform Channels Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity niche confidence 0.86

Platform Channels is a Flutter-specific bridge API; job postings usually ask for Flutter/Dart rather than this API by name, and market demand is limited to cross-platform mobile teams using native interop.

Vendor & license

Google ·apache_2 ·since 2018 (0.90)

Context keywords

messaging webhooks API integration chatbots notifications real-time event-driven user engagement cross-platform service-oriented data synchronization scalability platform integration third-party services cloud messaging

Ambiguity low

“Platform Channels” is a specific platform/communication-channel concept; unlikely to be confused with another distinct catalog skill in typical JDs.

Versioning

Not versioned

Type assignment

Platform ·communication_platform confidence 0.78

By the Platform vs Tool rule, "Platform Channels" reads as a hosted multi-tenant communication environment with APIs rather than software you run yourself, so Platform is the best fit.

Derived legacy fields

Category: Platform
Sub-category: communication_platform
Skill nature: PLATFORM
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

React Frontend Development Catalog dimension db id 96

Library dimension (catalog)

Locked dimensions (v3 placement)

Platform Channels
Pipeline tentative id

Platform Channels covers the native communication bridge between Flutter/Dart code and host platform code. It includes defining method, event, and basic message channels used to call iOS/Android APIs or receive callbacks from native code.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Agora Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity niche confidence 0.86

Agora appears in some real-time video/voice SDK job postings, but JD volume is far below mainstream cloud or frontend stacks; market demand is concentrated in communications/media products rather than broad hiring pipelines.

Vendor & license

Agora.io ·other_open ·since 2014 (0.90)

Context keywords

real-time video conferencing WebRTC SDK API streaming interactive broadcasting low latency multiplayer chat integration mobile SDK voice calls screen sharing live streaming event hosting

Ambiguity low

“Agora” as a communications platform name is distinctive; unlikely to be confused with other catalog skills.

Versioning

Not versioned

Type assignment

Platform ·communications_platform confidence 0.88

By the Platform vs Tool rule, Agora is a hosted multi-tenant communications environment with APIs rather than software you run yourself.

Derived legacy fields

Category: Platform
Sub-category: communications_platform
Skill nature: PLATFORM
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

React Frontend Development Catalog dimension db id 96

Library dimension (catalog)

Locked dimensions (v3 placement)

Real-Time Communication SDKs
Pipeline tentative id

Client and server SDKs used for live audio, video, and interactive messaging in apps. Agora belongs here because it is a communications platform commonly used to add real-time calling and streaming features.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Twilio Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.93

Twilio appears frequently in job postings for SMS/voice/OTP integrations and is a standard CPaaS vendor in hiring pipelines; no vendor sunset indicates deprecation.

Vendor & license

Twilio Inc. ·other_open ·since 2008 (0.95)

Context keywords

SMS MMS Voice API Twilio Functions Twilio Flex Programmable Video Webhook Twilio Studio API integration Call tracking Two-factor authentication Chatbot Real-time messaging Twilio CLI Twilio Console

Ambiguity low

Twilio is a specific communications API/vendor name; unlikely to be confused with other catalog skills.

Versioning

Not versioned

Type assignment

Platform ·communications_platform confidence 0.97

Twilio is a commercial vendor SaaS with hosted APIs and managed communications capabilities, so by the Vendor SaaS = Platform rule it is a Platform rather than a Tool or Service.

Derived legacy fields

Category: Platform
Sub-category: communications_platform
Skill nature: PLATFORM
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

React Frontend Development Catalog dimension db id 96

Library dimension (catalog)

Locked dimensions (v3 placement)

Communications API Integration
Pipeline tentative id

Integration with third-party communications platforms used to send and receive SMS, voice, and messaging traffic. Twilio belongs here because it is commonly used as the application-facing API for phone verification, notifications, and call/message workflows.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

WebRTC Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.86

WebRTC appears in many job descriptions for real-time video/audio apps and is a standard browser API; it’s broadly adopted rather than niche or sunsetted.

Vendor & license

Google ·other_open ·since 2011 (0.90)

Context keywords

peer-to-peer media streaming STUN TURN ICE WebSocket SDP JavaScript video conferencing audio processing real-time data NAT traversal browser compatibility signaling server WebRTC API

Ambiguity low

WebRTC is a specific real-time communication protocol/stack; typical JDs won’t confuse it with other common networking or streaming skills.

Versioning

Not versioned

Type assignment

Protocol ·real_time_communication_protocol confidence 0.93

WebRTC is fundamentally a communication standard for real-time media and data exchange between systems, so it fits the Protocol type rather than a tool or framework.

Derived legacy fields

Category: Protocol
Sub-category: real_time_communication_protocol
Skill nature: PROTOCOL
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

React Frontend Development Catalog dimension db id 96

Library dimension (catalog)

Locked dimensions (v3 placement)

Real-Time Media Communication
Pipeline tentative id

Protocols and APIs for low-latency audio, video, and data exchange between clients. WebRTC belongs here because it provides the core browser and mobile primitives for peer-to-peer media sessions, signaling-adjacent transport, and interactive communication.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

MVVM Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)

Canonical: MVVM id=504 · mvvm

Aliases — catalog

MVVM (CANONICAL) primary

Context tags (catalog)

Activity Android Architecture Components Caliburn.Micro Data Binding Fragment ICommand Jetpack Compose Kotlin LiveData MVVM Light Observable ObservableCollection ReactiveUI RecyclerView StateFlow SwiftUI Two-way binding UI framework ViewModel WPF XAML command binding command pattern data binding dependency injection event aggregation navigation service platform independence property change notification testability testable UI unit testing view model

Stored enrichment (catalog DB)

Category: Architecture
Sub-category: Presentation Architecture
Confidence: 0.95
Version strategy: NOT_APPLICABLE

Maturity reasoning: MVVM is widely used in mobile and desktop JDs, especially Android, WPF, and SwiftUI ecosystems; it remains a common hiring keyword rather than a sunset pattern.

Skill profile (library / DB)

Skill nature: PATTERN
Volatility: STABLE
Typical lifespan: EVERGREEN
Category id: 1
Sub-category id: 735
Extractable: True
Also category: False

Dimensions (API 2 worklist)

App Architecture and Dependency Injection Catalog dimension db id 94

Library dimension (catalog)

Roles linked in library: Android Engineer, Ios engineer
Mobile Architecture and Code Organization Catalog dimension db id 170

Library dimension (catalog)

Roles linked in library: Hybrid Mobile Developer

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
App Architecture and Dependency Injection app-architecture-and-dependency-injection	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Mobile Architecture and Code Organization mobile-architecture-and-code-organization	✓	✓	Existing dimension (library) · Role↔dimension saved

MVI Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)

Canonical: MVI id=986 · mvi

Aliases — catalog

MVI (CANONICAL) primary

Context tags (catalog)

Architecture patterns Data binding Dependency injection Event handling Framework integration Functional programming Immutable state MVVM Model-View-Intent Reactive programming State management Testing strategies UI components Unidirectional data flow User interactions

Stored enrichment (catalog DB)

Category: Architecture
Sub-category: Presentation Architecture
Confidence: 0.98
Version strategy: NOT_APPLICABLE

Maturity reasoning: MVI appears in some Android/Compose and Kotlin job posts, but JD volume is far below MVVM/Redux and it’s mostly used in specialized mobile UI architectures rather than broadly across teams.

Skill profile (library / DB)

Skill nature: PATTERN
Volatility: STABLE
Typical lifespan: EVERGREEN
Category id: 1
Sub-category id: 662
Extractable: True
Also category: False

Dimensions (API 2 worklist)

App Architecture and Dependency Injection Catalog dimension db id 94

Library dimension (catalog)

Roles linked in library: Android Engineer, Ios engineer

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
App Architecture and Dependency Injection app-architecture-and-dependency-injection	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Clean Architecture Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)

Canonical: clean architecture id=1078 · clean-architecture

Aliases — catalog

clean architecture (CANONICAL) primary
Clean Architecture (CANONICAL)
Clean architecture (CANONICAL)

Context tags (catalog)

API design CQRS SOLID principles application layer application services bounded context business logic component-based data layer data mappers dependency inversion design patterns domain-driven design entities event-driven architecture framework independence hexagonal architecture infrastructure infrastructure layer interface adapters interface segregation interfaces inversion of control layered architecture maintainability microservices modularity presentation layer repository pattern scalability separation of concerns service layer service-oriented architecture testability unit testing use cases

Stored enrichment (catalog DB)

Category: Architecture
Sub-category: Clean Architecture
Confidence: 0.99
Version strategy: NOT_APPLICABLE

Maturity reasoning: Commonly requested in software JDs and architecture interviews; widely referenced in books, blogs, and enterprise codebases as a standard design approach rather than a niche framework.

Skill profile (library / DB)

Skill nature: PATTERN
Volatility: EMERGING
Typical lifespan: EVERGREEN
Category id: 1
Sub-category id: 733
Extractable: True
Also category: False

Dimensions (API 2 worklist)

Mobile Architecture and Code Organization Catalog dimension db id 170

Library dimension (catalog)

Roles linked in library: Hybrid Mobile Developer

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Mobile Architecture and Code Organization mobile-architecture-and-code-organization	✓	✓	Existing dimension (library) · Role↔dimension saved

Dependency Injection Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)

Canonical: dependency injection id=88 · dependency-injection

Aliases — catalog

dependency injection (CANONICAL) primary
Dependency Injection (CANONICAL)
Dependency injection (CANONICAL)

Context tags (catalog)

AOP ASP.NET Core Angular Aspect-Oriented Programming Autowiring Binding Code Reusability Configuration Configuration Management Constructor Injection Dagger Dependency Graph Design Patterns Guice Interface Injection Interface Segregation Inversion of Control IoC IoC Container IoC container Lifecycle Management Lifecycles Loose Coupling Mocking Modularity Module Ninject Scope Service Locator Setter Injection Spring Spring Framework Testability Unit Testing aspect-oriented programming composition root configuration management constructor injection design patterns interface injection interface segregation inversion of control lifecycle management lifetime scope loose coupling mocking mocking frameworks modular architecture modularity object graph object lifecycle scoped service container service locator setter injection singleton testability transient unit testing

Stored enrichment (catalog DB)

Category: Concept
Sub-category: Dependency Injection
Confidence: 0.95
Version strategy: NOT_APPLICABLE

Maturity reasoning: Common in JDs for Java/.NET/TypeScript roles and supported by major frameworks like Spring, ASP.NET Core, and Angular; it’s a standard architectural pattern rather than a niche tool.

Skill profile (library / DB)

Skill nature: CONCEPT
Volatility: STABLE
Typical lifespan: EVERGREEN
Category id: 2
Sub-category id: 18
Extractable: True
Also category: False

Dimensions (API 2 worklist)

App Architecture and Dependency Injection Catalog dimension db id 94

Library dimension (catalog)

Roles linked in library: Android Engineer, Ios engineer
Application Architecture and Code Organization Catalog dimension db id 220

Library dimension (catalog)

Roles linked in library: Full Stack Engineer
Mobile Architecture and Code Organization Catalog dimension db id 170

Library dimension (catalog)

Roles linked in library: Hybrid Mobile Developer
Service Architecture and Design Patterns Catalog dimension db id 18

Library dimension (catalog)

Roles linked in library: Backend Engineer

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
App Architecture and Dependency Injection app-architecture-and-dependency-injection	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Application Architecture and Code Organization application-architecture-and-code-organization	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Mobile Architecture and Code Organization mobile-architecture-and-code-organization	✓	✓	Existing dimension (library) · Role↔dimension saved
Service Architecture and Design Patterns service-architecture-and-design-patterns	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Offline-first Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity emerging confidence 0.78

Appears increasingly in mobile/PWA job descriptions and product docs, but JD volume is still far below mainstream architecture skills like REST or cloud-native.

Vendor & license

(0.90)

Context keywords

service worker local storage PWA cache strategy data synchronization background sync offline capabilities progressive enhancement user experience network resilience event-driven data persistence API fallback client-side rendering sync conflicts

Ambiguity low

“Offline-first” is a specific product/architecture pattern; unlikely to be confused with other distinct catalog skills in typical JDs.

Versioning

Not versioned

Type assignment

Architecture ·offline_first_architecture confidence 0.90

Offline-first is fundamentally a system-shape pattern for how applications are designed to operate with local-first behavior and later synchronization, so it fits the Architecture category.

Derived legacy fields

Category: Architecture
Sub-category: offline_first_architecture
Skill nature: PATTERN
Volatility: EMERGING
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

React Frontend Development Catalog dimension db id 96

Library dimension (catalog)

Locked dimensions (v3 placement)

Offline-First App Architecture
Pipeline tentative id

Patterns for building apps that continue working without reliable network access and later reconcile state. This covers local persistence, sync, conflict handling, and resilient UX, which is exactly what offline-first mobile features require.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Caching Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)

Canonical: response caching id=1285 · response-caching

Aliases — catalog

response caching (CANONICAL) primary

Context tags (catalog)

CDN HTTP caching Memcached Redis TTL Varnish cache hit cache invalidation cache miss data persistence load balancing performance optimization proxy caching scalability session storage

Stored enrichment (catalog DB)

Category: Tool
Sub-category: Caching Tool
Vendor: Varnish Software
License: bsd
Year introduced: 2006
Confidence: 0.67
Version strategy: NOT_APPLICABLE

Maturity reasoning: Commonly requested in JDs for web/API performance via CDNs, reverse proxies, and app caches; vendor docs and cloud offerings (Cloudflare, Redis, Varnish) show broad production adoption.

Skill profile (library / DB)

Skill nature: TOOL
Volatility: STABLE
Typical lifespan: EVERGREEN
Category id: 13
Sub-category id: 1010
Extractable: True
Also category: False

Dimensions (API 2 worklist)

Latency and Cost Optimization Catalog dimension db id 205

Library dimension (catalog)

Roles linked in library: AI Engineer

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Latency and Cost Optimization latency-and-cost-optimization	—	—	Skipped — no persistable v3 meta for new skill skill_not_in_db_v3_proposed

Sync Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity niche confidence 0.78

“Sync” as a file synchronization tool shows low JD volume and limited GitHub/community activity compared with mainstream DevOps tools; it’s used in specialized workflows rather than broadly requested in hiring.

Vendor & license

Microsoft ·proprietary ·since 2001 (0.90)

Context keywords

file transfer real-time sync cloud storage data backup version control collaboration tools synchronization protocols file sharing network latency data integrity multi-device support offline access incremental sync user permissions conflict resolution

Ambiguity flagged

Could be confused with: sync-aws, sync-database

“Sync” is a generic term in JDs and can refer to different sync tools or concepts (e.g., AWS sync services or database/data synchronization) beyond file sync.

Versioning

Not versioned

Type assignment

Tool ·file_synchronization_tool confidence 0.88

Sync is best treated as a user-operated software utility rather than a hosted environment or code package, so it fits the Tool rule.

Derived legacy fields

Category: Tool
Sub-category: file_synchronization_tool
Skill nature: TOOL
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

Screen Navigation and State Catalog dimension db id 83

Library dimension (catalog)

Roles linked in library: Android Engineer, Full Stack Engineer, Hybrid Mobile Developer, Ios engineer
Screen Navigation and State Catalog dimension db id 83

Library dimension (catalog)

Roles linked in library: Android Engineer, Full Stack Engineer, Hybrid Mobile Developer, Ios engineer

Locked dimensions (v3 placement)

Screen Navigation and State
Reuses catalog slug

Patterns for moving users through app flows and keeping client state consistent across screens and app lifecycle events. Sync belongs here when it refers to keeping UI state, local models, and remote data aligned in a mobile app.
Screen Navigation and State
Reuses catalog slug

Patterns for moving users through app flows and keeping client state consistent across screens, refreshes, and app transitions. This is central to feature work because iOS engineers own the in-app request flow and UI logic.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Screen Navigation and State screen-navigation-and-state	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved

Secure Storage Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.86

Commonly required in JDs for mobile/backend roles (e.g., keychain/keystore, encrypted secrets, KMS); broad vendor docs and cloud security guidance show it as a standard practice, not a niche tool.

Vendor & license

(1.00)

Context keywords

encryption key management data integrity access control cloud storage tokenization compliance data at rest data in transit secure vault multi-factor authentication audit trails zero trust secure backup privacy regulations

Ambiguity low

“Secure Storage” is a broad, distinct concept and is unlikely to be confused with another specific catalog skill in typical JDs.

Versioning

Not versioned

Type assignment

Concept ·secure_storage confidence 0.88

Secure Storage is best treated as a Concept because it names a security knowledge unit about protecting stored data rather than a specific product, protocol, or methodology.

Derived legacy fields

Category: Concept
Sub-category: secure_storage
Skill nature: CONCEPT
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

React Frontend Development Catalog dimension db id 96

Library dimension (catalog)

Locked dimensions (v3 placement)

Secure Storage
Pipeline tentative id

Security practices for storing sensitive data at rest on a device or in a backend storage layer. This fits the target skill because it covers protecting secrets, credentials, and private app data from unauthorized access, extraction, and leakage.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Sockets Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.96

Core OS/networking API used across backend and systems roles; appears routinely in job descriptions for network programming and is foundational in Python, Java, C/C++, and Go ecosystems.

Vendor & license

(0.95)

Context keywords

TCP UDP socket programming bind listen accept send recv select poll non-blocking socket options address family socket types network protocols client-server model

Ambiguity low

“Sockets” in a JD typically refers to network socket programming/APIs, not another distinct catalog skill.

Versioning

Not versioned

Type assignment

Protocol ·network_socket_api confidence 0.90

Sockets are a communication interface for exchanging data between processes, so by the Protocol rule they fit Protocol rather than a tool or library.

Derived legacy fields

Category: Protocol
Sub-category: network_socket_api
Skill nature: PROTOCOL
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

Networking and API Integration Catalog dimension db id 84

Library dimension (catalog)

Roles linked in library: Android Engineer, Hybrid Mobile Developer, Ios engineer

Locked dimensions (v3 placement)

Socket-Based Networking
Reuses catalog slug

Client-side network communication over sockets, including connection setup, message exchange, and handling low-level transport behavior. Sockets belong here because they are the primitive used beneath higher-level HTTP and API clients.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Networking and API Integration networking-and-api-integration	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved

Push Notifications Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.93

Common in mobile/web JDs and supported by major vendors (APNs, FCM, Web Push); broad hiring-pipeline staple for user engagement and lifecycle messaging.

Vendor & license

(0.80)

Context keywords

APNs Firebase Cloud Messaging web push service workers notification payload user engagement opt-in delivery tracking scheduling rich notifications A/B testing notification center background updates user segmentation analytics

Ambiguity low

“Push Notifications” is a specific, common product/feature term and is unlikely to be confused with other distinct catalog skills.

Versioning

Not versioned

Type assignment

Service ·notification_service confidence 0.88

Push Notifications is best treated as a hosted managed capability delivered by a platform rather than software you run yourself, matching the Service vs Platform rule.

Derived legacy fields

Category: Service
Sub-category: notification_service
Skill nature: CLOUD_SERVICE
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

Background Execution and Lifecycle Catalog dimension db id 87

Library dimension (catalog)

Roles linked in library: Hybrid Mobile Developer, Ios engineer
Background Execution and Lifecycle Catalog dimension db id 87

Library dimension (catalog)

Roles linked in library: Hybrid Mobile Developer, Ios engineer

Locked dimensions (v3 placement)

Background App Delivery and Lifecycle
Reuses catalog slug

App lifecycle and deferred-work mechanisms that let mobile apps receive, process, and present events while backgrounded or relaunched. Push notifications belong here because they are tightly coupled to app wake-up behavior, background handling, and user-visible delivery timing.
Background Execution and Lifecycle
Reuses catalog slug

App lifecycle handling and deferred work mechanisms that keep iOS behavior reliable when the app is backgrounded, suspended, or relaunched. This is important for sync, refresh, and user-visible continuity.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Background Execution and Lifecycle background-execution-and-lifecycle	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved

Image Caching Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.86

Common performance topic in web/mobile JDs and docs; CDN/image optimization vendors like Cloudflare and Fastly prominently market image caching as a standard practice.

Vendor & license

(1.00)

Context keywords

cache invalidation CDN image optimization lazy loading browser caching cache hit ratio thumbnail generation asset management HTTP caching content delivery cache storage image preloading performance tuning data retrieval response time

Ambiguity low

“Image Caching” is a specific caching concept focused on images; unlikely to be confused with other distinct skills in typical JDs.

Versioning

Not versioned

Type assignment

Concept ·caching_concept confidence 0.91

Image Caching is fundamentally a knowledge unit about storing and reusing images efficiently, so it fits the Concept category rather than a tool, datastore, or architecture.

Derived legacy fields

Category: Concept
Sub-category: caching_concept
Skill nature: CONCEPT
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

Performance and Stability Tuning Catalog dimension db id 92

Library dimension (catalog)

Roles linked in library: Android Engineer, Ios engineer

Locked dimensions (v3 placement)

App Performance Optimization
Reuses catalog slug

Techniques for improving responsiveness, memory use, and perceived speed in client apps. Image caching belongs here because it reduces repeated decoding, network fetches, and UI jank when rendering images.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Performance and Stability Tuning performance-and-stability-tuning	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Profiling Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)

Canonical: profiling id=51 · profiling

Aliases — catalog

profiling (CANONICAL) primary
Profiling (CANONICAL)

Context tags (catalog)

CPU profiling CPU usage CPU_usage application performance benchmarking bottleneck bottleneck analysis bottleneck identification call graph call stack call_graph code instrumentation code optimization debugging execution time execution_time flame graph gprof heap dump hot path hotspots instrumentation latency load testing memory allocation memory profiling memory usage memory_leak optimization optimization techniques overhead analysis performance analysis performance bottlenecks performance metrics performance tuning performance_bottlenecks performance_metrics performance_tuning profiling frameworks profiling metrics profiling tools profiling_tools resource allocation resource monitoring resource utilization resource_usage runtime analysis sampling throughput tracing valgrind visualization

Stored enrichment (catalog DB)

Category: Concept
Sub-category: Profiling
Confidence: 0.88
Version strategy: NOT_APPLICABLE

Maturity reasoning: Profiling is a standard performance-engineering skill; it appears in many software JDs alongside debugging and optimization, and major tools like perf, pprof, and Visual Studio Profiler are widely used.

Skill profile (library / DB)

Skill nature: CONCEPT
Volatility: STABLE
Typical lifespan: EVERGREEN
Category id: 2
Sub-category id: 385
Extractable: True
Also category: False

Dimensions (API 2 worklist)

Debugging and Performance Tuning Catalog dimension db id 219

Library dimension (catalog)

Roles linked in library: Full Stack Engineer
Performance and Scalability Tuning Catalog dimension db id 11

Library dimension (catalog)

Roles linked in library: Backend Engineer

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Debugging and Performance Tuning debugging-and-performance-tuning	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Performance and Scalability Tuning performance-and-scalability-tuning	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

API Integration Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.96

API integration appears in a large share of software engineering JDs and is a standard requirement across backend, frontend, and platform roles; it is a core hiring-pipeline skill rather than a niche tool.

Vendor & license

(1.00)

Context keywords

REST SOAP OAuth JSON XML Webhooks API Gateway Postman Swagger GraphQL Microservices Endpoint Data Mapping Authentication Rate Limiting

Ambiguity low

“API Integration” is a specific, common phrase referring to connecting systems via APIs; it’s unlikely to be confused with other distinct catalog skills.

Versioning

Not versioned

Type assignment

Concept ·api_integration confidence 0.90

API Integration is fundamentally a knowledge unit about connecting systems via APIs, so it fits the Concept category rather than a tool, protocol, or methodology.

Derived legacy fields

Category: Concept
Sub-category: api_integration
Skill nature: CONCEPT
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

API Integration and Data Fetching Catalog dimension db id 127

Library dimension (catalog)

Roles linked in library: Frontend Engineer, Full Stack Engineer
Networking and API Integration Catalog dimension db id 84

Library dimension (catalog)

Roles linked in library: Android Engineer, Hybrid Mobile Developer, Ios engineer
Cross-Platform App Languages Catalog dimension db id 167

Library dimension (catalog)

Roles linked in library: Hybrid Mobile Developer
API Integration and Data Fetching Catalog dimension db id 127

Library dimension (catalog)

Roles linked in library: Frontend Engineer, Full Stack Engineer
Networking and API Integration Catalog dimension db id 84

Library dimension (catalog)

Roles linked in library: Android Engineer, Hybrid Mobile Developer, Ios engineer
Cross-Platform App Languages Catalog dimension db id 167

Library dimension (catalog)

Roles linked in library: Hybrid Mobile Developer

Locked dimensions (v3 placement)

API Integration and Data Fetching
Reuses catalog slug

Client-side integration with backend and third-party APIs, including request construction, response parsing, error handling, and state synchronization. API Integration belongs here because it is the core skill of connecting an app to remote services and consuming their data reliably.
Networking and API Integration
Reuses catalog slug

Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. API Integration fits here because it is a direct example of consuming remote services from a mobile client.
Cross-Platform App Languages
Reuses catalog slug

Languages used to implement shared mobile features across iOS and Android from a common codebase. API Integration can appear here when the skill is expressed through shared Flutter/Dart app code that calls remote services.
API Integration and Data Fetching
Reuses catalog slug

Client-side integration with backend endpoints and third-party services, including request shaping, response handling, and synchronization with UI state. This is central to frontend work because most screens depend on remote data.
Networking and API Integration
Reuses catalog slug

Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.
Cross-Platform App Languages
Reuses catalog slug

Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
API Integration and Data Fetching api-integration-and-data-fetching	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Networking and API Integration networking-and-api-integration	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved
Cross-Platform App Languages cross-platform-app-languages	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved

Authentication Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.96

Authentication is a core requirement in most software JDs and security roles; it appears broadly across job postings and vendor docs for OAuth/OIDC, SSO, and MFA rather than as a niche specialty.

Vendor & license

(1.00)

Context keywords

OAuth JWT SAML OpenID Connect multi-factor authentication session management identity provider access tokens authorization secure cookies single sign-on user credentials token validation LDAP PKI

Ambiguity low

“Authentication” is a distinct security concept; typical JDs won’t confuse it with other catalog skills like authorization, sessions, or OAuth-specific items.

Versioning

Not versioned

Type assignment

Concept ·authentication confidence 0.96

Authentication is a named knowledge unit about verifying identity, so by the Concept vs Methodology rule it is a Concept rather than a tool, protocol, or standard.

Derived legacy fields

Category: Concept
Sub-category: authentication
Skill nature: CONCEPT
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

Authentication and Session Handling Catalog dimension db id 86

Library dimension (catalog)

Roles linked in library: Android Engineer, Frontend Engineer, Full Stack Engineer, Hybrid Mobile Developer, Ios engineer
Authentication and Session Handling Catalog dimension db id 86

Library dimension (catalog)

Roles linked in library: Android Engineer, Frontend Engineer, Full Stack Engineer, Hybrid Mobile Developer, Ios engineer

Locked dimensions (v3 placement)

Authentication and Session Handling
Reuses catalog slug

Client-side identity flows and secure session management used to sign users in and keep them authenticated. Authentication belongs here because mobile apps commonly implement login, token refresh, logout, and protected-session UX.
Authentication and Session Handling
Reuses catalog slug

Client-side identity flows and secure session management used to sign users in and keep them authenticated. This includes token handling, login UX, and protecting secrets on device.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Authentication and Session Handling authentication-and-session-handling	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved

Pagination Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)

Canonical: pagination id=684 · pagination

Aliases — catalog

pagination (CANONICAL) primary
Pagination (CANONICAL)

Context tags (catalog)

API API design API response API responses REST RESTful RESTful API RESTful services UI components UI design batch processing client-side client-side pagination client-side rendering content loading content management continuation token cursor cursor-based cursor-based pagination data chunking data fetching data loading data retrieval data slicing data visualization database indexing database queries database query frontend frameworks infinite scroll infinite scrolling keyset pagination lazy loading limit load more navigation next page offset offset-based pagination page number page size page token pagination controls pagination strategy pagination tokens performance optimization previous page query parameters response format results per page scrolling scrolling behavior server-side server-side pagination state management total count user experience

Stored enrichment (catalog DB)

Category: Concept
Sub-category: Api Pagination
Confidence: 0.70
Version strategy: NOT_APPLICABLE

Maturity reasoning: Common API design requirement in job descriptions for REST/GraphQL backends; widely implemented via page/limit or cursor patterns across major platforms and SDKs.

Skill profile (library / DB)

Skill nature: CONCEPT
Volatility: STABLE
Typical lifespan: EVERGREEN
Category id: 2
Sub-category id: 1048
Extractable: True
Also category: False

Dimensions (API 2 worklist)

API Design and Contracts Catalog dimension db id 3

Library dimension (catalog)

Roles linked in library: Backend Engineer, Full Stack Engineer
API Integration and Data Fetching Catalog dimension db id 127

Library dimension (catalog)

Roles linked in library: Frontend Engineer, Full Stack Engineer

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
API Design and Contracts api-design-and-contracts	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
API Integration and Data Fetching api-integration-and-data-fetching	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Idempotency Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)

Canonical: idempotency id=902 · idempotency

Aliases — catalog

idempotency (CANONICAL) primary
Idempotency (CANONICAL)

Context tags (catalog)

API API design DELETE GET HTTP methods PUT REST RESTful APIs cache invalidation caching caching strategies client-server concurrency concurrency control consistency consistency models data consistency data integrity distributed transactions error handling event sourcing failure recovery fault tolerance idempotent operations load balancing message queues microservices network reliability request retries retries retry logic service design service orchestration service reliability service-oriented architecture side effects state management stateless statelessness system design system resilience transactional integrity transactional systems

Stored enrichment (catalog DB)

Category: Concept
Sub-category: Distributed Systems Concept
Confidence: 0.98
Version strategy: NOT_APPLICABLE

Maturity reasoning: Common in backend/distributed-systems JDs and API design docs; often listed alongside retries, webhooks, and payment APIs to prevent duplicate processing.

Skill profile (library / DB)

Skill nature: CONCEPT
Volatility: STABLE
Typical lifespan: EVERGREEN
Category id: 2
Sub-category id: 1053
Extractable: True
Also category: False

Dimensions (API 2 worklist)

API Design and Contracts Catalog dimension db id 3

Library dimension (catalog)

Roles linked in library: Backend Engineer, Full Stack Engineer
Delivery Workflow Reliability Catalog dimension db id 159

Library dimension (catalog)

Roles linked in library: DevOps Engineer

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
API Design and Contracts api-design-and-contracts	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Delivery Workflow Reliability delivery-workflow-reliability	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Unit Testing Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)

Canonical: Unit Testing id=517 · unit-testing

Aliases — catalog

Unit Testing (CANONICAL)

Context tags (catalog)

JUnit NUnit TDD arrange-act-assert assertions code coverage fixtures mocking pytest regression stubs test cases test doubles test runner xUnit

Stored enrichment (catalog DB)

Category: Methodology
Sub-category: Testing Methodology
Confidence: 0.98
Version strategy: NOT_APPLICABLE

Maturity reasoning: Unit testing is a standard hiring requirement across software JDs and appears in mainstream frameworks/docs; GitHub and Stack Overflow usage remain consistently high, with no successor replacing it.

Skill profile (library / DB)

Skill nature: METHODOLOGY
Volatility: STABLE
Typical lifespan: EVERGREEN
Category id: 8
Sub-category id: 44
Extractable: True
Also category: False

Dimensions (API 2 worklist)

React Frontend Development Catalog dimension db id 96

Library dimension (catalog)

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
React Frontend Development d_init_01	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Widget Testing Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.84

Widget testing is a common QA practice in Flutter/React Native JDs and docs, often listed alongside unit and integration testing; no sunset signal, and it remains a standard hiring-pipeline skill.

Vendor & license

(1.00)

Context keywords

unit tests integration tests test cases test automation test frameworks mocking assertions test-driven development continuous integration bug tracking regression testing quality assurance test coverage performance testing user acceptance testing

Ambiguity low

“Widget Testing” is a specific testing methodology term and is unlikely to be confused with other distinct catalog skills.

Versioning

Not versioned

Type assignment

Methodology ·testing_methodology confidence 0.90

Widget Testing is fundamentally a way of working for validating UI components, so by the Concept vs Methodology rule it fits Methodology rather than a tool or framework.

Derived legacy fields

Category: Methodology
Sub-category: testing_methodology
Skill nature: METHODOLOGY
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

React Frontend Development Catalog dimension db id 96

Library dimension (catalog)

Locked dimensions (v3 placement)

Widget Testing
Pipeline tentative id

Testing individual UI widgets in isolation to verify rendering, interactions, and state changes. In Flutter, this covers the standard widget test layer used to validate component behavior without running a full device app.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Integration Testing Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)

Canonical: integration testing id=56 · integration-testing

Aliases — catalog

Integration testing (CANONICAL) primary
integration testing (CANONICAL)

Context tags (catalog)

API testing CI/CD Cucumber JUnit Selenium behavior-driven development continuous integration contract testing end-to-end end-to-end testing fixtures mocking pytest quality assurance regression testing smoke testing stubs system testing test automation test cases test coverage test data test frameworks test harness test strategy test suite test-driven development

Stored enrichment (catalog DB)

Category: Methodology
Sub-category: Testing Methodology
Confidence: 0.97
Version strategy: NOT_APPLICABLE

Maturity reasoning: Integration testing is a standard QA skill in job descriptions across backend, frontend, and DevOps roles; it’s commonly paired with CI/CD and tools like Jest, Cypress, and Testcontainers.

Skill profile (library / DB)

Skill nature: METHODOLOGY
Volatility: STABLE
Typical lifespan: EVERGREEN
Category id: 8
Sub-category id: 44
Extractable: True
Also category: False

Dimensions (API 2 worklist)

Testing and Quality Assurance Catalog dimension db id 12

Library dimension (catalog)

Roles linked in library: Backend Engineer

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Testing and Quality Assurance testing-and-quality-assurance	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Golden Tests Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity emerging confidence 0.78

Appears in growing numbers of engineering JDs and testing guides, especially for snapshot/regression testing in UI and compiler/tooling work, but it is not yet a universal hiring staple.

Vendor & license

(0.95)

Context keywords

test-driven development regression testing test automation behavior-driven development unit tests integration tests test coverage mocking assertions continuous integration quality assurance test strategy code reviews test cases test frameworks

Ambiguity low

“Golden Tests” is a specific testing methodology (golden/master snapshots) and is unlikely to be confused with other catalog skills.

Versioning

Not versioned

Type assignment

Methodology ·testing_methodology confidence 0.88

Golden Tests are a way of working for verifying outputs against approved snapshots, so by the Concept vs Methodology rule they are best classified as a methodology rather than a tool or framework.

Derived legacy fields

Category: Methodology
Sub-category: testing_methodology
Skill nature: METHODOLOGY
Volatility: EMERGING
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

React Frontend Development Catalog dimension db id 96

Library dimension (catalog)

Locked dimensions (v3 placement)

Snapshot and Golden Testing
Pipeline tentative id

Testing approach that verifies UI output against approved reference images or rendered artifacts. Golden tests catch unintended visual regressions in widgets, screens, and component rendering, which fits Flutter mobile work directly.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Mocks Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.93

Mocks are a standard test-double concept in mainstream unit-testing JDs and docs across Python, Java, JavaScript, and .NET; they’re widely used in CI/testing stacks rather than a niche tool.

Vendor & license

(1.00)

Context keywords

stubbing fakes test doubles unit testing dependency injection mocking framework Mockito Jest RSpec test isolation behavior verification assertions spy verification test-driven development

Ambiguity low

“Mocks” in a JD typically refers to test doubles (mocking) rather than another catalog skill.

Versioning

Not versioned

Type assignment

Concept ·test_double_concept confidence 0.90

Mocks are a named testing concept describing a kind of test double, so they fit the Concept category rather than Tool or Framework.

Derived legacy fields

Category: Concept
Sub-category: test_double_concept
Skill nature: CONCEPT
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

React Frontend Development Catalog dimension db id 96

Library dimension (catalog)

Locked dimensions (v3 placement)

Test Doubles and Mocking
Pipeline tentative id

Techniques for isolating code under test by replacing dependencies with mocks, stubs, spies, and fakes. This skill belongs here because it is specifically about controlling behavior and verifying interactions in unit and component tests.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Fakes Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity niche confidence 0.86

Fakes are a testing-double concept used in unit tests, but job postings rarely list "Fakes" explicitly; JDs more often mention mocks/stubs or specific frameworks like Mockito, Sinon, or unittest.mock.

Vendor & license

(1.00)

Context keywords

test doubles mocks stubs spy dependency injection unit testing integration testing behavior verification test isolation mocking frameworks fake objects assertions test-driven development code coverage automated testing

Ambiguity low

“Fakes” in testing typically refers to test doubles (fake implementations), not a commonly conflated separate catalog skill.

Versioning

Not versioned

Type assignment

Concept ·testing_double_concept confidence 0.90

Fakes are a named testing double pattern, so by the Concept vs Methodology rule they are a knowledge unit rather than a tool or framework.

Derived legacy fields

Category: Concept
Sub-category: testing_double_concept
Skill nature: CONCEPT
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

React Frontend Development Catalog dimension db id 96

Library dimension (catalog)

Locked dimensions (v3 placement)

Test Doubles and Mock Objects
Pipeline tentative id

Techniques for replacing real dependencies with controlled stand-ins during testing. This includes fakes, mocks, stubs, and spies used to isolate behavior, make tests deterministic, and verify interactions.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

A/B Testing Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.93

Commonly listed in product, growth, and analytics job descriptions; major platforms like Optimizely and Google Optimize popularized it, and it remains a standard experimentation practice across SaaS and e-commerce.

Vendor & license

(0.95)

Context keywords

split testing conversion rate statistical significance control group variant hypothesis testing user segmentation multivariate testing sample size data analysis performance metrics click-through rate landing page experiment framework result interpretation

Ambiguity low

A/B Testing is a specific experimentation methodology; typical JDs won’t confuse it with other distinct skills in the catalog.

Versioning

Not versioned

Type assignment

Methodology ·experiment_design_methodology confidence 0.97

A/B Testing is a way of working for comparing variants through controlled experiments, so by the Concept vs Methodology rule it is a Methodology.

Derived legacy fields

Category: Methodology
Sub-category: experiment_design_methodology
Skill nature: METHODOLOGY
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

React Frontend Development Catalog dimension db id 96

Library dimension (catalog)
Systems Programming Catalog dimension db id 166

Library dimension (catalog)

Locked dimensions (v3 placement)

Experiment Design and Analysis
Pipeline tentative id

Designing controlled experiments to compare variants and measure causal impact. This covers A/B testing because it is the core method for assigning users to variants, defining success metrics, and interpreting results.
Product Analytics Measurement
Pipeline tentative id

Measurement practices used to evaluate product changes through user behavior data. A/B Testing belongs here when the focus is on tracking conversion, retention, engagement, and other product metrics across variants.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Systems Programming d_init_02	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Feature Flags Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)

Canonical: feature flags id=64 · feature-flags

Aliases — catalog

feature flags (CANONICAL) primary

Context tags (catalog)

A/B testing blue-green deployment canary release canary releases configuration as code configuration management continuous delivery continuous deployment controlled rollout dark launch dark launches deployment deployment strategies deployment strategy dynamic configuration dynamic feature flags dynamic toggling experiment flags experimentation feature lifecycle feature management feature rollout feature rollouts feature toggle feature toggling gradual exposure gradual rollout kill switch launch darkly observability percentage rollout product experimentation progressive delivery release gating release management release toggles remote config risk mitigation rollback rollout rollout percentage rollout strategy runtime configuration toggle toggle management toggle service user segmentation version control versioning

Stored enrichment (catalog DB)

Category: Concept
Sub-category: Release Control Concept
Confidence: 0.95
Version strategy: NOT_APPLICABLE

Maturity reasoning: Feature flags are widely listed in engineering JDs and supported by major vendors like LaunchDarkly, Split, and cloud platforms, reflecting broad adoption for progressive delivery and A/B testing.

Skill profile (library / DB)

Skill nature: CONCEPT
Volatility: STABLE
Typical lifespan: EVERGREEN
Category id: 2
Sub-category id: 1054
Extractable: True
Also category: False

Dimensions (API 2 worklist)

Deployment Automation and Rollouts Catalog dimension db id 151

Library dimension (catalog)

Roles linked in library: DevOps Engineer
Deployment and Runtime Configuration Catalog dimension db id 13

Library dimension (catalog)

Roles linked in library: Backend Engineer
Feature Flags and Release Control Catalog dimension db id 218

Library dimension (catalog)

Roles linked in library: Full Stack Engineer
Release Readiness and Browser Compatibility Catalog dimension db id 129

Library dimension (catalog)

Roles linked in library: Frontend Engineer

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Deployment Automation and Rollouts deployment-automation-and-rollouts	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Deployment and Runtime Configuration deployment-and-runtime-configuration	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Feature Flags and Release Control feature-flags-and-release-control	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Release Readiness and Browser Compatibility release-readiness-and-browser-compatibility	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

CI/CD Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)

Canonical: CI/CD id=1190 · ci-cd

Aliases — catalog

CI/CD (CANONICAL)

Context tags (catalog)

Ansible CircleCI Docker GitLab CI Jenkins Kubernetes Terraform Travis CI automated testing build automation continuous deployment continuous integration deployment pipelines monitoring version control

Stored enrichment (catalog DB)

Category: Methodology
Sub-category: Ci Cd Process
Confidence: 0.93
Version strategy: NOT_APPLICABLE

Maturity reasoning: CI/CD appears in a large share of software engineering JDs and is a standard requirement across DevOps, platform, and backend roles; major vendors like GitHub, GitLab, and AWS all center product roadmaps on CI/CD pipelines.

Skill profile (library / DB)

Skill nature: METHODOLOGY
Volatility: STABLE
Typical lifespan: EVERGREEN
Category id: 8
Sub-category id: 900
Extractable: True
Also category: False

Dimensions (API 2 worklist)

CI/CD Pipeline Platforms Catalog dimension db id 150

Library dimension (catalog)

Roles linked in library: DevOps Engineer
CI/CD for Machine Learning Catalog dimension db id 56

Library dimension (catalog)

Roles linked in library: ML Engineer

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
CI/CD Pipeline Platforms ci-cd-pipeline-platforms	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD for Machine Learning ci-cd-for-machine-learning	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Crash Analytics Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.90

Crash analytics is a standard mobile/web observability requirement; tools like Firebase Crashlytics and Sentry appear frequently in job postings and vendor docs, indicating broad adoption.

Vendor & license

Firebase ·proprietary ·since 2016 (0.90)

Context keywords

bug tracking error reporting real-time monitoring user feedback data visualization mobile analytics session replay performance metrics root cause analysis event logging A/B testing analytics dashboard SDK integration user behavior crash logs

Ambiguity low

“Crash Analytics” is a fairly specific term tied to crash reporting/diagnostics, not commonly confused with other distinct catalog skills.

Versioning

Not versioned

Type assignment

Tool ·crash_analytics_tool confidence 0.90

Crash Analytics is best treated as software you operate to inspect and diagnose app crashes, so by the Tool vs Platform rule it is a user-run tool rather than a hosted multi-tenant platform or a datastore.

Derived legacy fields

Category: Tool
Sub-category: crash_analytics_tool
Skill nature: TOOL
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

Crash Reporting and Observability Catalog dimension db id 91

Library dimension (catalog)

Roles linked in library: Android Engineer, Hybrid Mobile Developer, Ios engineer
Crash Reporting and Observability Catalog dimension db id 91

Library dimension (catalog)

Roles linked in library: Android Engineer, Hybrid Mobile Developer, Ios engineer

Locked dimensions (v3 placement)

Crash Reporting and Observability
Reuses catalog slug

Client-side telemetry used to capture crashes, hangs, and stability signals from mobile apps in the field. Crash Analytics belongs here because it is used to diagnose failure patterns, prioritize fixes, and verify whether releases improve app stability.
Crash Reporting and Observability
Reuses catalog slug

Client-side telemetry used to diagnose crashes, hangs, performance regressions, and field issues in iOS apps. iOS engineers use these tools to understand production behavior and prioritize fixes.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Crash Reporting and Observability crash-reporting-and-observability	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved

Lazy Lists Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity niche confidence 0.84

Lazy lists appear in functional-language JDs and docs, but job postings rarely list them as a standalone requirement; market demand is mostly indirect via Haskell/Scala/F# roles rather than broad hiring pipelines.

Vendor & license

(0.95)

Context keywords

streaming generator iterator yield functional programming comprehensions memory efficiency deferred execution lazy evaluation collections data pipelines asynchronous processing performance optimization data structures reactive programming

Ambiguity low

“Lazy Lists” is a specific concept/subtype (lazy evaluation of lists) and is unlikely to be confused with other catalog skills.

Versioning

Not versioned

Type assignment

Concept ·lazy_evaluation_lists confidence 0.90

This is a knowledge unit about deferred evaluation of list elements, so by the Concept vs Methodology rule it is a Concept rather than a tool or architecture.

Derived legacy fields

Category: Concept
Sub-category: lazy_evaluation_lists
Skill nature: CONCEPT
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

Cross-Platform App Languages Catalog dimension db id 167

Library dimension (catalog)

Roles linked in library: Hybrid Mobile Developer
Cross-Platform App Languages Catalog dimension db id 167

Library dimension (catalog)

Roles linked in library: Hybrid Mobile Developer

Locked dimensions (v3 placement)

Cross-Platform App Languages
Reuses catalog slug

Languages and language features used to implement shared mobile app logic and UI in cross-platform frameworks. Lazy Lists belongs here because it is a language-level collection construct commonly used in Flutter/Dart code for deferred, on-demand item generation.
Cross-Platform App Languages
Reuses catalog slug

Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Cross-Platform App Languages cross-platform-app-languages	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved

Reconnection Logic Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.86

Common requirement in JDs for WebSocket, gRPC, and mobile/networked apps; widely implemented in SDKs and client libraries as a standard resilience pattern.

Vendor & license

(0.95)

Context keywords

network resilience connection timeout failover retry mechanism session persistence heartbeat reconnection strategy error handling network latency API stability state management connection pooling timeout settings asynchronous recovery circuit breaker load balancing

Ambiguity low

“Reconnection Logic” is a specific connection recovery concept; it’s unlikely to be confused with other distinct catalog skills.

Versioning

Not versioned

Type assignment

Concept ·connection_recovery_logic confidence 0.92

This is a named technical knowledge unit about handling dropped connections, so it fits the Concept category rather than a tool, framework, or methodology.

Derived legacy fields

Category: Concept
Sub-category: connection_recovery_logic
Skill nature: CONCEPT
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

Networking and API Integration Catalog dimension db id 84

Library dimension (catalog)

Roles linked in library: Android Engineer, Hybrid Mobile Developer, Ios engineer
Networking and API Integration Catalog dimension db id 84

Library dimension (catalog)

Roles linked in library: Android Engineer, Hybrid Mobile Developer, Ios engineer

Locked dimensions (v3 placement)

Networking and API Integration
Reuses catalog slug

Client-side communication with backend services, including request construction, response parsing, retries, and recovery from transient failures. Reconnection logic belongs here because it governs how an app restores network sessions and resumes API traffic after disconnects.
Networking and API Integration
Reuses catalog slug

Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Networking and API Integration networking-and-api-integration	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved

Screen Sharing Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.93

Common collaboration requirement in remote-work JDs and standard in Zoom/Teams/Meet usage; no successor or sunset signal, just broadly expected in hiring pipelines.

Vendor & license

(0.95)

Context keywords

video conferencing remote collaboration virtual meetings screen capture presentation tools real-time sharing collaborative editing file sharing webinars digital whiteboard team collaboration online workshops interactive sessions remote support user interface sharing

Ambiguity low

“Screen Sharing” is a specific collaboration feature and isn’t commonly confused with another distinct catalog skill.

Versioning

Not versioned

Type assignment

SoftSkill ·collaboration_skill confidence 0.88

Screen Sharing is best treated as a non-technical interpersonal capability used to collaborate and communicate visually, so it fits the SoftSkill category rather than a tool or platform.

Derived legacy fields

Category: SoftSkill
Sub-category: collaboration_skill
Skill nature: PRACTICE
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

React Frontend Development Catalog dimension db id 96

Library dimension (catalog)

Locked dimensions (v3 placement)

Screen Sharing
Pipeline tentative id

Client-side and platform-level support for sharing a device or app screen during live calls or collaboration sessions. This covers starting, stopping, and managing the shared view, which is distinct from general navigation or media playback.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Echo Cancellation Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity niche confidence 0.86

Appears in audio/VoIP and WebRTC roles, but JD volume is low versus general software skills; market demand is concentrated in telecom, conferencing, and DSP teams.

Vendor & license

(1.00)

Context keywords

adaptive filtering noise reduction digital signal processing acoustic echo real-time processing feedback cancellation echo path estimation nonlinear echo cancellation speech enhancement audio processing signal-to-noise ratio multi-channel processing echo suppression voice over IP teleconferencing

Ambiguity low

“Echo Cancellation” is a specific signal-processing concept (AEC) with a clear meaning; unlikely to be confused with other catalog skills.

Versioning

Not versioned

Type assignment

Concept ·signal_processing_concept confidence 0.93

Echo Cancellation is a named signal-processing knowledge unit, so by the Concept vs Methodology rule it is a Concept rather than a tool or architecture.

Derived legacy fields

Category: Concept
Sub-category: signal_processing_concept
Skill nature: CONCEPT
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

React Frontend Development Catalog dimension db id 96

Library dimension (catalog)

Locked dimensions (v3 placement)

Audio Signal Processing
Pipeline tentative id

Techniques for analyzing and modifying audio streams to improve clarity, intelligibility, and user experience. Echo cancellation belongs here because it is a core speech/audio processing algorithm used in real-time communication and recording pipelines.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Bandwidth Adaptation Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity niche confidence 0.84

Rarely appears as a standalone skill in job descriptions; market demand is usually folded into CDN/streaming or QoS roles rather than listed directly.

Vendor & license

(0.95)

Context keywords

dynamic adjustment throughput optimization adaptive bitrate network congestion QoS latency management streaming protocols buffering techniques packet loss bandwidth estimation real-time communication video streaming load balancing traffic shaping protocol adaptation

Ambiguity low

“Bandwidth Adaptation” is a specific network/performance concept; unlikely to be confused with other distinct catalog skills in typical JDs.

Versioning

Not versioned

Type assignment

Concept ·network_bandwidth_adaptation confidence 0.91

Bandwidth Adaptation is a named technical principle about adjusting transmission behavior to available network capacity, so it fits the Concept rule rather than a tool, protocol, or methodology.

Derived legacy fields

Category: Concept
Sub-category: network_bandwidth_adaptation
Skill nature: CONCEPT
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

Performance and Stability Tuning Catalog dimension db id 92

Library dimension (catalog)

Roles linked in library: Android Engineer, Ios engineer
Performance and Stability Tuning Catalog dimension db id 92

Library dimension (catalog)

Roles linked in library: Android Engineer, Ios engineer

Locked dimensions (v3 placement)

Performance and Stability Tuning
Reuses catalog slug

Techniques for keeping client apps responsive under changing device and network conditions. Bandwidth adaptation belongs here because it is a performance optimization that adjusts media, data, or request behavior to preserve smooth user experience.
Performance and Stability Tuning
Reuses catalog slug

Techniques for improving responsiveness, startup time, memory use, and overall app stability on iOS devices. This cluster is important because client performance directly affects user experience and release readiness.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Performance and Stability Tuning performance-and-stability-tuning	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Recording Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity niche confidence 0.84

Job postings rarely list "recording" as a standalone skill; it appears mainly inside observability/telemetry stacks (e.g., session replay, screen/audio capture) rather than as a hiring-pipeline keyword.

Vendor & license

(1.00)

Context keywords

audio capture screen recording video editing live streaming post-production audio mixing metadata tagging file formats codec sampling rate bitrate OBS Studio screen sharing recording software audio interface

Ambiguity low

“Recording” is too generic but, in this catalog context (crash-reporting-and-observability), it’s unlikely to be confused with another specific skill name.

Versioning

Not versioned

Type assignment

Concept ·recording confidence 0.78

Recording is best treated as a named knowledge unit about capturing information, and it does not fit the Tool/Platform/Format rules because the input is just the concept name rather than a specific software or specification.

Derived legacy fields

Category: Concept
Sub-category: recording
Skill nature: CONCEPT
Volatility: STABLE
Typical lifespan: EVERGREEN
Version strategy: NOT_APPLICABLE

Dimensions (API 2 worklist)

Crash Reporting and Observability Catalog dimension db id 91

Library dimension (catalog)

Roles linked in library: Android Engineer, Hybrid Mobile Developer, Ios engineer
React Frontend Development Catalog dimension db id 96

Library dimension (catalog)
Crash Reporting and Observability Catalog dimension db id 91

Library dimension (catalog)

Roles linked in library: Android Engineer, Hybrid Mobile Developer, Ios engineer

Locked dimensions (v3 placement)

Crash Reporting and Observability
Reuses catalog slug

Client-side telemetry used to capture crashes, logs, and runtime signals from mobile apps. Recording belongs here when it refers to recording app events or diagnostics for later analysis and troubleshooting.
Media Recording Capture
Pipeline tentative id

Capture of audio, video, or screen content on a device or in an app. Recording fits here when the skill refers to producing media assets rather than diagnostics or telemetry.
Crash Reporting and Observability
Reuses catalog slug

Client-side telemetry used to diagnose crashes, hangs, performance regressions, and field issues in iOS apps. iOS engineers use these tools to understand production behavior and prioritize fixes.

API 3 link attempts (this skill)

Dimension	Skill↔dim	Role↔dim	Outcome
Crash Reporting and Observability crash-reporting-and-observability	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved
React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

All API 3 persistence rows

Same grid as the skill-extractor “Persistence items” table: one row per (skill × dimension) work item.

Skill	Tag	Dimension	Skill↔dim	Role↔dim	Outcome	Notes
Flutter	in_db	UI Frameworks and Rendering ui-frameworks-and-rendering	✓	✓	Existing dimension (library) · Role↔dimension saved
Kotlin	in_db	Kotlin and Java kotlin-and-java	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kotlin	in_db	Programming Languages programming-languages	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Swift	in_db	Swift and Objective-C swift-and-objective-c	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
MVVM	in_db	App Architecture and Dependency Injection app-architecture-and-dependency-injection	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
MVVM	in_db	Mobile Architecture and Code Organization mobile-architecture-and-code-organization	✓	✓	Existing dimension (library) · Role↔dimension saved
MVI	in_db	App Architecture and Dependency Injection app-architecture-and-dependency-injection	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Clean Architecture	in_db	Mobile Architecture and Code Organization mobile-architecture-and-code-organization	✓	✓	Existing dimension (library) · Role↔dimension saved
Dependency Injection	in_db	App Architecture and Dependency Injection app-architecture-and-dependency-injection	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Dependency Injection	in_db	Application Architecture and Code Organization application-architecture-and-code-organization	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Dependency Injection	in_db	Mobile Architecture and Code Organization mobile-architecture-and-code-organization	✓	✓	Existing dimension (library) · Role↔dimension saved
Dependency Injection	in_db	Service Architecture and Design Patterns service-architecture-and-design-patterns	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Caching	new	Latency and Cost Optimization latency-and-cost-optimization	—	—	Skipped — no persistable v3 meta for new skill	skill_not_in_db_v3_proposed
Profiling	in_db	Debugging and Performance Tuning debugging-and-performance-tuning	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Profiling	in_db	Performance and Scalability Tuning performance-and-scalability-tuning	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Pagination	in_db	API Design and Contracts api-design-and-contracts	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Pagination	in_db	API Integration and Data Fetching api-integration-and-data-fetching	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Idempotency	in_db	API Design and Contracts api-design-and-contracts	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Idempotency	in_db	Delivery Workflow Reliability delivery-workflow-reliability	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Unit Testing	in_db	React Frontend Development d_init_01	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Integration Testing	in_db	Testing and Quality Assurance testing-and-quality-assurance	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Feature Flags	in_db	Deployment Automation and Rollouts deployment-automation-and-rollouts	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Feature Flags	in_db	Deployment and Runtime Configuration deployment-and-runtime-configuration	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Feature Flags	in_db	Feature Flags and Release Control feature-flags-and-release-control	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Feature Flags	in_db	Release Readiness and Browser Compatibility release-readiness-and-browser-compatibility	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD	in_db	CI/CD Pipeline Platforms ci-cd-pipeline-platforms	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD	in_db	CI/CD for Machine Learning ci-cd-for-machine-learning	✓	—	Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
iOS	in_db	React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Android	in_db	React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Riverpod	in_db	Screen Navigation and State screen-navigation-and-state	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved
Platform Channels	in_db	React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Agora	in_db	React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Twilio	in_db	React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
WebRTC	in_db	React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Offline-first	in_db	React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Sync	in_db	Screen Navigation and State screen-navigation-and-state	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved
Secure Storage	in_db	React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Sockets	in_db	Networking and API Integration networking-and-api-integration	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved
Push Notifications	in_db	Background Execution and Lifecycle background-execution-and-lifecycle	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved
Image Caching	in_db	Performance and Stability Tuning performance-and-stability-tuning	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
API Integration	in_db	API Integration and Data Fetching api-integration-and-data-fetching	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
API Integration	in_db	Networking and API Integration networking-and-api-integration	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved
API Integration	in_db	Cross-Platform App Languages cross-platform-app-languages	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved
Authentication	in_db	Authentication and Session Handling authentication-and-session-handling	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved
Widget Testing	in_db	React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Golden Tests	in_db	React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Mocks	in_db	React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Fakes	in_db	React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
A/B Testing	in_db	React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
A/B Testing	in_db	Systems Programming d_init_02	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Crash Analytics	in_db	Crash Reporting and Observability crash-reporting-and-observability	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved
Lazy Lists	in_db	Cross-Platform App Languages cross-platform-app-languages	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved
Reconnection Logic	in_db	Networking and API Integration networking-and-api-integration	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved
Screen Sharing	in_db	React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Echo Cancellation	in_db	React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Bandwidth Adaptation	in_db	Performance and Stability Tuning performance-and-stability-tuning	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Recording	in_db	Crash Reporting and Observability crash-reporting-and-observability	✓	✓	New skill saved · Existing dimension (library) · Role↔dimension saved
Recording	in_db	React Frontend Development d_init_01	✓	—	New skill saved · Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Library artifacts (this run)

Kind	Detail	DB id
canonical_skill_added	iOS	1594
canonical_skill_added	Android	1595
canonical_skill_added	Riverpod	1596
canonical_skill_added	Platform Channels	1597
canonical_skill_added	Agora	1598
canonical_skill_added	Twilio	1599
canonical_skill_added	WebRTC	1600
canonical_skill_added	Offline-first	1601
canonical_skill_added	Sync	1602
canonical_skill_added	Secure Storage	1603
canonical_skill_added	Sockets	1604
canonical_skill_added	Push Notifications	1605
canonical_skill_added	Image Caching	1606
canonical_skill_added	API Integration	1607
canonical_skill_added	Authentication	1608
canonical_skill_added	Widget Testing	1609
canonical_skill_added	Golden Tests	1610
canonical_skill_added	Mocks	1611
canonical_skill_added	Fakes	1612
canonical_skill_added	A/B Testing	1613
canonical_skill_added	Crash Analytics	1614
canonical_skill_added	Lazy Lists	1615
canonical_skill_added	Reconnection Logic	1616
canonical_skill_added	Screen Sharing	1617
canonical_skill_added	Echo Cancellation	1618
canonical_skill_added	Bandwidth Adaptation	1619
canonical_skill_added	Recording	1620
dimension_skill_link_proposed	Caching ↔ Latency and Cost Optimization
dimension_skill_link	iOS ↔ React Frontend Development	96
dimension_skill_link	Android ↔ React Frontend Development	96
dimension_skill_link	Riverpod ↔ Screen Navigation and State	83
dimension_skill_link	Platform Channels ↔ React Frontend Development	96
dimension_skill_link	Agora ↔ React Frontend Development	96
dimension_skill_link	Twilio ↔ React Frontend Development	96
dimension_skill_link	WebRTC ↔ React Frontend Development	96
dimension_skill_link	Offline-first ↔ React Frontend Development	96
dimension_skill_link	Sync ↔ Screen Navigation and State	83
dimension_skill_link	Secure Storage ↔ React Frontend Development	96
dimension_skill_link	Sockets ↔ Networking and API Integration	84
dimension_skill_link	Push Notifications ↔ Background Execution and Lifecycle	87
dimension_skill_link	Image Caching ↔ Performance and Stability Tuning	92
dimension_skill_link	API Integration ↔ API Integration and Data Fetching	127
dimension_skill_link	API Integration ↔ Networking and API Integration	84
dimension_skill_link	API Integration ↔ Cross-Platform App Languages	167
dimension_skill_link	Authentication ↔ Authentication and Session Handling	86
dimension_skill_link	Widget Testing ↔ React Frontend Development	96
dimension_skill_link	Golden Tests ↔ React Frontend Development	96
dimension_skill_link	Mocks ↔ React Frontend Development	96
dimension_skill_link	Fakes ↔ React Frontend Development	96
dimension_skill_link	A/B Testing ↔ React Frontend Development	96
dimension_skill_link	A/B Testing ↔ Systems Programming	166
dimension_skill_link	Crash Analytics ↔ Crash Reporting and Observability	91
dimension_skill_link	Lazy Lists ↔ Cross-Platform App Languages	167
dimension_skill_link	Reconnection Logic ↔ Networking and API Integration	84
dimension_skill_link	Screen Sharing ↔ React Frontend Development	96
dimension_skill_link	Echo Cancellation ↔ React Frontend Development	96
dimension_skill_link	Bandwidth Adaptation ↔ Performance and Stability Tuning	92
dimension_skill_link	Recording ↔ Crash Reporting and Observability	91
dimension_skill_link	Recording ↔ React Frontend Development	96

nano JD Parser — gpt-4.1-nano click to toggle

RoleSenior Mobile Engineer (Flutter)

Experience4+ years of mobile development experience with at least 2+ years in Flutter shipping production apps used by real users.

DomainSoftware & SaaS Products

JD type pass

Show raw JSON

{
  "JD_type": "pass",
  "about_company": null,
  "certifications": [],
  "company_name": null,
  "ctc": null,
  "domain": {
    "primary": {
      "aliases": [
        "SaaS",
        "Product Companies"
      ],
      "domain": "Software \u0026 SaaS Products"
    },
    "secondary": null
  },
  "education": [],
  "experience": {
    "max": null,
    "min": 4,
    "raw": "4+ years of mobile development experience with at least 2+ years in Flutter shipping production apps used by real users."
  },
  "job_locations": [],
  "role": "Senior Mobile Engineer (Flutter)",
  "role_aliases": [
    "Mobile Engineer",
    "Flutter Developer",
    "Mobile Developer"
  ],
  "role_archetype": "Engineering",
  "roles_and_responsibilities": [
    {
      "bullet_count": 5,
      "heading": "Key Responsibilities",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "\u2022 Own app architecture end-to-end:",
        "last_5_words": "debug and harden apps at scale."
      },
      "text": "\u2022 Own app architecture end-to-end: Design, build, and ship scalable Flutter apps for iOS \u0026 Android, with clean layered architecture, modular code, and strong production discipline.\n\u2022 High-performance engineering: Profile and eliminate jank, memory leaks, and frame drops; optimize rendering pipelines; deliver buttery-smooth experiences at 60/120fps across devices.\n\u2022 Advanced state \u0026 data systems: Architect offline-first data flows, reliable caching/sync strategies, secure storage, and maintainable state patterns (Riverpod preferred) for real-world constraints.\n\u2022 Deep native integrations: Use platform channels and native code (Kotlin/Swift) for audio/video SDKs (Agora/Twilio/WebRTC), background tasks, notifications, and OS-level capabilities.\n\u2022 Production robustness \u0026 release excellence: Implement crash analytics, A/B testing, feature flags, CI/CD automation, and progressive rollouts; rapidly debug and harden apps at scale.",
      "word_count": 134
    },
    {
      "bullet_count": 13,
      "heading": "What makes you a great fit?",
      "heading_was_present": false,
      "source_marker": {
        "first_5_words": "Must haves:\n\u2022 4+ years of",
        "last_5_words": "excellent documentation and PR discipline."
      },
      "text": "Must haves:\n\u2022 4+ years of mobile development experience with at least 2+ years in Flutter shipping production apps used by real users.\n\u2022 Strong problem-solving mindset: you don\u2019t stop at \u2018it works\u2019, you ask why and fix the root cause.\n\u2022 Shipped at least one complex Flutter app end-to-end (architecture and tradeoffs).\n\u2022 Solid grasp of app architectures (MVVM/MVI/Clean), dependency injection, layering, and testability.\n\u2022 Demonstrated offline-first patterns and efficient local data modelling (indexes, pagination, partial sync).\n\u2022 Real-time features experience: sockets, background updates, push notifications, reconnection logic.\n\u2022 Pro at performance: render pipeline basics, avoiding rebuilds, isolating heavy work, lazy lists, image caching/decoding, and profiling tools.\n\u2022 Comfortable dropping to Kotlin/Swift for platform-specific capabilities.\n\u2022 Strong with API integration (auth, retries, idempotency, pagination, caching) and secure secrets handling.\n\u2022 Testing mindset: unit, widget, and integration tests; golden tests; mocks/fakes; coverage where it counts.\n\u2022 Hands-on experience integrating native libraries/SDKs (e.g., Agora, Twilio, WebRTC) into Flutter apps for real-time communication features.\n\u2022 Deep familiarity call setup, echo cancellation, bandwidth adaptation, screen share, recording, and session lifecycle management.\n\u2022 Experience bridging Flutter \u2194 native SDKs when no official plugin exists.\n\u2022 Clear, maintainable code with excellent documentation and PR discipline.",
      "word_count": 266
    }
  ],
  "urls": []
}

API 1 — extract-from-jd click to toggle

{
  "final_skills": [
    {
      "is_primary": true,
      "skill_name": "Flutter"
    },
    {
      "is_primary": true,
      "skill_name": "iOS"
    },
    {
      "is_primary": true,
      "skill_name": "Android"
    },
    {
      "is_primary": true,
      "skill_name": "Kotlin"
    },
    {
      "is_primary": true,
      "skill_name": "Swift"
    },
    {
      "is_primary": false,
      "skill_name": "Riverpod"
    },
    {
      "is_primary": true,
      "skill_name": "Platform Channels"
    },
    {
      "is_primary": false,
      "skill_name": "Agora"
    },
    {
      "is_primary": false,
      "skill_name": "Twilio"
    },
    {
      "is_primary": false,
      "skill_name": "WebRTC"
    },
    {
      "is_primary": false,
      "skill_name": "MVVM"
    },
    {
      "is_primary": false,
      "skill_name": "MVI"
    },
    {
      "is_primary": false,
      "skill_name": "Clean Architecture"
    },
    {
      "is_primary": false,
      "skill_name": "Dependency Injection"
    },
    {
      "is_primary": false,
      "skill_name": "Offline-first"
    },
    {
      "is_primary": false,
      "skill_name": "Caching"
    },
    {
      "is_primary": false,
      "skill_name": "Sync"
    },
    {
      "is_primary": false,
      "skill_name": "Secure Storage"
    },
    {
      "is_primary": false,
      "skill_name": "Sockets"
    },
    {
      "is_primary": false,
      "skill_name": "Push Notifications"
    },
    {
      "is_primary": false,
      "skill_name": "Image Caching"
    },
    {
      "is_primary": false,
      "skill_name": "Profiling"
    },
    {
      "is_primary": true,
      "skill_name": "API Integration"
    },
    {
      "is_primary": false,
      "skill_name": "Authentication"
    },
    {
      "is_primary": false,
      "skill_name": "Pagination"
    },
    {
      "is_primary": false,
      "skill_name": "Idempotency"
    },
    {
      "is_primary": false,
      "skill_name": "Unit Testing"
    },
    {
      "is_primary": false,
      "skill_name": "Widget Testing"
    },
    {
      "is_primary": false,
      "skill_name": "Integration Testing"
    },
    {
      "is_primary": false,
      "skill_name": "Golden Tests"
    },
    {
      "is_primary": false,
      "skill_name": "Mocks"
    },
    {
      "is_primary": false,
      "skill_name": "Fakes"
    },
    {
      "is_primary": false,
      "skill_name": "A/B Testing"
    },
    {
      "is_primary": false,
      "skill_name": "Feature Flags"
    },
    {
      "is_primary": false,
      "skill_name": "CI/CD"
    },
    {
      "is_primary": false,
      "skill_name": "Crash Analytics"
    },
    {
      "is_primary": false,
      "skill_name": "Lazy Lists"
    },
    {
      "is_primary": false,
      "skill_name": "Reconnection Logic"
    },
    {
      "is_primary": false,
      "skill_name": "Screen Sharing"
    },
    {
      "is_primary": false,
      "skill_name": "Echo Cancellation"
    },
    {
      "is_primary": false,
      "skill_name": "Bandwidth Adaptation"
    },
    {
      "is_primary": false,
      "skill_name": "Recording"
    }
  ],
  "jd_role": {
    "display_name": "Senior Mobile Engineer (Flutter)",
    "rationale": null,
    "role_aliases": [
      "Mobile Engineer",
      "Flutter Developer",
      "Mobile Developer"
    ],
    "role_archetype": "Engineering",
    "slug": ""
  },
  "nano_parsed": {
    "JD_type": "pass",
    "about_company": null,
    "certifications": [],
    "company_name": null,
    "ctc": null,
    "domain": {
      "primary": {
        "aliases": [
          "SaaS",
          "Product Companies"
        ],
        "domain": "Software \u0026 SaaS Products"
      },
      "secondary": null
    },
    "education": [],
    "experience": {
      "max": null,
      "min": 4,
      "raw": "4+ years of mobile development experience with at least 2+ years in Flutter shipping production apps used by real users."
    },
    "job_locations": [],
    "role": "Senior Mobile Engineer (Flutter)",
    "role_aliases": [
      "Mobile Engineer",
      "Flutter Developer",
      "Mobile Developer"
    ],
    "role_archetype": "Engineering",
    "roles_and_responsibilities": [
      {
        "bullet_count": 5,
        "heading": "Key Responsibilities",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "\u2022 Own app architecture end-to-end:",
          "last_5_words": "debug and harden apps at scale."
        },
        "text": "\u2022 Own app architecture end-to-end: Design, build, and ship scalable Flutter apps for iOS \u0026 Android, with clean layered architecture, modular code, and strong production discipline.\n\u2022 High-performance engineering: Profile and eliminate jank, memory leaks, and frame drops; optimize rendering pipelines; deliver buttery-smooth experiences at 60/120fps across devices.\n\u2022 Advanced state \u0026 data systems: Architect offline-first data flows, reliable caching/sync strategies, secure storage, and maintainable state patterns (Riverpod preferred) for real-world constraints.\n\u2022 Deep native integrations: Use platform channels and native code (Kotlin/Swift) for audio/video SDKs (Agora/Twilio/WebRTC), background tasks, notifications, and OS-level capabilities.\n\u2022 Production robustness \u0026 release excellence: Implement crash analytics, A/B testing, feature flags, CI/CD automation, and progressive rollouts; rapidly debug and harden apps at scale.",
        "word_count": 134
      },
      {
        "bullet_count": 13,
        "heading": "What makes you a great fit?",
        "heading_was_present": false,
        "source_marker": {
          "first_5_words": "Must haves:\n\u2022 4+ years of",
          "last_5_words": "excellent documentation and PR discipline."
        },
        "text": "Must haves:\n\u2022 4+ years of mobile development experience with at least 2+ years in Flutter shipping production apps used by real users.\n\u2022 Strong problem-solving mindset: you don\u2019t stop at \u2018it works\u2019, you ask why and fix the root cause.\n\u2022 Shipped at least one complex Flutter app end-to-end (architecture and tradeoffs).\n\u2022 Solid grasp of app architectures (MVVM/MVI/Clean), dependency injection, layering, and testability.\n\u2022 Demonstrated offline-first patterns and efficient local data modelling (indexes, pagination, partial sync).\n\u2022 Real-time features experience: sockets, background updates, push notifications, reconnection logic.\n\u2022 Pro at performance: render pipeline basics, avoiding rebuilds, isolating heavy work, lazy lists, image caching/decoding, and profiling tools.\n\u2022 Comfortable dropping to Kotlin/Swift for platform-specific capabilities.\n\u2022 Strong with API integration (auth, retries, idempotency, pagination, caching) and secure secrets handling.\n\u2022 Testing mindset: unit, widget, and integration tests; golden tests; mocks/fakes; coverage where it counts.\n\u2022 Hands-on experience integrating native libraries/SDKs (e.g., Agora, Twilio, WebRTC) into Flutter apps for real-time communication features.\n\u2022 Deep familiarity call setup, echo cancellation, bandwidth adaptation, screen share, recording, and session lifecycle management.\n\u2022 Experience bridging Flutter \u2194 native SDKs when no official plugin exists.\n\u2022 Clear, maintainable code with excellent documentation and PR discipline.",
        "word_count": 266
      }
    ],
    "urls": []
  },
  "rejected": false,
  "rejection_reason": null,
  "run_id": "4d35418a-3821-4fe3-8cbc-48910b959cf5",
  "stage3_signals": {
    "alias_found": true,
    "alias_match_roles": [
      {
        "display_name": "Hybrid Mobile Developer",
        "matched_count": null,
        "role_id": 11,
        "score": 0.8095,
        "slug": "hybrid-mobile-developer",
        "total_count": null
      },
      {
        "display_name": "Ios engineer",
        "matched_count": null,
        "role_id": 6,
        "score": 0.8,
        "slug": "ios-engineer",
        "total_count": null
      },
      {
        "display_name": "Android Engineer",
        "matched_count": null,
        "role_id": 4,
        "score": 0.6667,
        "slug": "android-engineer",
        "total_count": null
      },
      {
        "display_name": "ML Engineer",
        "matched_count": null,
        "role_id": 3,
        "score": 0.5556,
        "slug": "ml-engineer",
        "total_count": null
      },
      {
        "display_name": "AI Engineer",
        "matched_count": null,
        "role_id": 13,
        "score": 0.5,
        "slug": "ai-engineer",
        "total_count": null
      }
    ],
    "kra_match_roles": [
      {
        "display_name": "Ios engineer",
        "matched_count": null,
        "role_id": 6,
        "score": 0.3866,
        "slug": "ios-engineer",
        "total_count": null
      },
      {
        "display_name": "Frontend Engineer",
        "matched_count": null,
        "role_id": 7,
        "score": 0.3594,
        "slug": "frontend-engineer",
        "total_count": null
      },
      {
        "display_name": "DevOps Engineer",
        "matched_count": null,
        "role_id": 10,
        "score": 0.3571,
        "slug": "devops-engineer",
        "total_count": null
      },
      {
        "display_name": "Android Engineer",
        "matched_count": null,
        "role_id": 4,
        "score": 0.3394,
        "slug": "android-engineer",
        "total_count": null
      },
      {
        "display_name": "Hybrid Mobile Developer",
        "matched_count": null,
        "role_id": 11,
        "score": 0.3266,
        "slug": "hybrid-mobile-developer",
        "total_count": null
      }
    ],
    "skill_match_roles": [
      {
        "display_name": "Backend Engineer",
        "matched_count": 7,
        "role_id": 1,
        "score": 0.1667,
        "slug": "backend-engineer",
        "total_count": 42
      },
      {
        "display_name": "Full Stack Engineer",
        "matched_count": 7,
        "role_id": 15,
        "score": 0.1667,
        "slug": "full-stack-engineer",
        "total_count": 42
      },
      {
        "display_name": "Android Engineer",
        "matched_count": 4,
        "role_id": 4,
        "score": 0.0952,
        "slug": "android-engineer",
        "total_count": 42
      },
      {
        "display_name": "Ios engineer",
        "matched_count": 4,
        "role_id": 6,
        "score": 0.0952,
        "slug": "ios-engineer",
        "total_count": 42
      },
      {
        "display_name": "Hybrid Mobile Developer",
        "matched_count": 4,
        "role_id": 11,
        "score": 0.0952,
        "slug": "hybrid-mobile-developer",
        "total_count": 42
      }
    ]
  },
  "stage4_decision": {
    "alias_collision_detected": false,
    "case": "A",
    "chosen_role": {
      "display_name": "Ios engineer",
      "matched_count": null,
      "role_id": 6,
      "score": 1.0,
      "slug": "ios-engineer",
      "total_count": null
    },
    "confidence": 0.8,
    "llm2_fired": false,
    "llm2_reasoning": null,
    "queued": false,
    "reasoning": "Stage 1 title \u0027Ios engineer\u0027 (embedding match, sim 0.74); KRA inconclusive"
  },
  "stage5_updates": {
    "centroid_n_after": 16,
    "centroid_updated": true,
    "collision_log_id": null,
    "new_kra_attached": {
      "best_kra_similarity": 0.3866,
      "queue_id": 35,
      "r_and_r_preview": "\u2022 Own app architecture end-to-end: Design, build, and ship scalable Flutter apps for iOS \u0026 Android, with clean layered architecture, modular code, and strong production discipline.\n\u2022 High-performance ",
      "role_display_name": "Ios engineer",
      "role_slug": "ios-engineer",
      "status": "pending"
    },
    "new_skills_attached": [
      {
        "is_primary": true,
        "queue_id": 1317,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "iOS",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 1318,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Android",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1319,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Riverpod",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 1320,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Platform Channels",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1321,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Agora",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1322,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Twilio",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1323,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "WebRTC",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1324,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Offline-first",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1325,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Caching",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1326,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Sync",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1327,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Secure Storage",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1328,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Sockets",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1329,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Push Notifications",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1330,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Image Caching",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 1331,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "API Integration",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1332,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Authentication",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1333,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Widget Testing",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1334,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Golden Tests",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1335,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Mocks",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1336,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Fakes",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1337,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "A/B Testing",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1338,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Crash Analytics",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1339,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Lazy Lists",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1340,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Reconnection Logic",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1341,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Screen Sharing",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1342,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Echo Cancellation",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1343,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Bandwidth Adaptation",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1344,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Recording",
        "status": "pending"
      }
    ],
    "queue_entry_id": null,
    "v3_pipeline_triggered": false,
    "v3_role_slug": null,
    "v3_run_id": null
  }
}

API 2 — extract-details

{
  "alias_matches": [
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1658,
      "existing_alias_text": "Flutter",
      "input_term": "Flutter",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "Flutter",
        "id": 1041,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "flutter",
        "sub_category_id": 341,
        "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": 24,
      "existing_alias_text": "Kotlin",
      "input_term": "Kotlin",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "Kotlin",
        "id": 2,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "kotlin",
        "sub_category_id": 96,
        "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": 756,
      "existing_alias_text": "Swift",
      "input_term": "Swift",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "Swift",
        "id": 440,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "swift",
        "sub_category_id": 96,
        "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": 830,
      "existing_alias_text": "MVVM",
      "input_term": "MVVM",
      "matched_canonical": {
        "category_id": 1,
        "display_name": "MVVM",
        "id": 504,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PATTERN",
        "slug": "mvvm",
        "sub_category_id": 735,
        "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": 1596,
      "existing_alias_text": "MVI",
      "input_term": "MVI",
      "matched_canonical": {
        "category_id": 1,
        "display_name": "MVI",
        "id": 986,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PATTERN",
        "slug": "mvi",
        "sub_category_id": 662,
        "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": 1704,
      "existing_alias_text": "clean architecture",
      "input_term": "Clean Architecture",
      "matched_canonical": {
        "category_id": 1,
        "display_name": "clean architecture",
        "id": 1078,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PATTERN",
        "slug": "clean-architecture",
        "sub_category_id": 733,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 229,
      "existing_alias_text": "dependency injection",
      "input_term": "Dependency Injection",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "dependency injection",
        "id": 88,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "dependency-injection",
        "sub_category_id": 18,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "TODO: REMOVE AFTER TESTING \u2014 alias DB write disabled",
      "alias_persisted": false,
      "existing_alias_id": 1921,
      "existing_alias_text": "response caching",
      "input_term": "Caching",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "response caching",
        "id": 1285,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "response-caching",
        "sub_category_id": 1010,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "embedding_alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 188,
      "existing_alias_text": "profiling",
      "input_term": "Profiling",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "profiling",
        "id": 51,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "profiling",
        "sub_category_id": 385,
        "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": 1189,
      "existing_alias_text": "pagination",
      "input_term": "Pagination",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "pagination",
        "id": 684,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "pagination",
        "sub_category_id": 1048,
        "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": 1464,
      "existing_alias_text": "idempotency",
      "input_term": "Idempotency",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "idempotency",
        "id": 902,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "idempotency",
        "sub_category_id": 1053,
        "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": 865,
      "existing_alias_text": "Unit Testing",
      "input_term": "Unit Testing",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "Unit Testing",
        "id": 517,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "unit-testing",
        "sub_category_id": 44,
        "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": 193,
      "existing_alias_text": "integration testing",
      "input_term": "Integration Testing",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "integration testing",
        "id": 56,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "integration-testing",
        "sub_category_id": 44,
        "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": 205,
      "existing_alias_text": "feature flags",
      "input_term": "Feature Flags",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "feature flags",
        "id": 64,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "feature-flags",
        "sub_category_id": 1054,
        "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": 1826,
      "existing_alias_text": "CI/CD",
      "input_term": "CI/CD",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "CI/CD",
        "id": 1190,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "ci-cd",
        "sub_category_id": 900,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    }
  ],
  "candidate_roles": [
    {
      "display_name": "Frontend Engineer",
      "id": 7,
      "rationale": null,
      "role_archetype": null,
      "slug": "frontend-engineer",
      "source": "db"
    },
    {
      "display_name": "Full Stack Engineer",
      "id": 15,
      "rationale": null,
      "role_archetype": null,
      "slug": "full-stack-engineer",
      "source": "db"
    },
    {
      "display_name": "Hybrid Mobile Developer",
      "id": 11,
      "rationale": null,
      "role_archetype": null,
      "slug": "hybrid-mobile-developer",
      "source": "db"
    },
    {
      "display_name": "Android Engineer",
      "id": 4,
      "rationale": null,
      "role_archetype": null,
      "slug": "android-engineer",
      "source": "db"
    },
    {
      "display_name": "Backend Engineer",
      "id": 1,
      "rationale": null,
      "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
      "slug": "backend-engineer",
      "source": "db"
    },
    {
      "display_name": "Ios engineer",
      "id": 6,
      "rationale": null,
      "role_archetype": null,
      "slug": "ios-engineer",
      "source": "db"
    },
    {
      "display_name": "AI Engineer",
      "id": 13,
      "rationale": null,
      "role_archetype": null,
      "slug": "ai-engineer",
      "source": "db"
    },
    {
      "display_name": "DevOps Engineer",
      "id": 10,
      "rationale": null,
      "role_archetype": null,
      "slug": "devops-engineer",
      "source": "db"
    },
    {
      "display_name": "ML Engineer",
      "id": 3,
      "rationale": null,
      "role_archetype": null,
      "slug": "ml-engineer",
      "source": "db"
    }
  ],
  "chosen_role": {
    "display_name": "Hybrid Mobile Developer",
    "id": 11,
    "rationale": "The primary skills focus on cross-platform development including Flutter, iOS, and Android, which align with the Hybrid Mobile Developer role.",
    "role_archetype": null,
    "slug": "hybrid-mobile-developer",
    "source": "db"
  },
  "dimensions": [
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "UI Frameworks and Rendering",
        "id": 115,
        "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
        "slug": "ui-frameworks-and-rendering",
        "source": "db"
      },
      "input_skill": "Flutter",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Engineer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Kotlin and Java",
        "id": 161,
        "rationale": "Primary implementation languages for Android app features, platform integration, and client-side business logic. Android engineers use these languages to build screens, state flows, service adapters, and device-aware behavior.",
        "slug": "kotlin-and-java",
        "source": "db"
      },
      "input_skill": "Kotlin",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages",
        "id": 1,
        "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
        "slug": "programming-languages",
        "source": "db"
      },
      "input_skill": "Kotlin",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Swift and Objective-C",
        "id": 81,
        "rationale": "Primary implementation languages for native iOS app features, platform APIs, and client-side business logic. This is the core coding surface for building and maintaining iPhone and iPad experiences.",
        "slug": "swift-and-objective-c",
        "source": "db"
      },
      "input_skill": "Swift",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "App Architecture and Dependency Injection",
        "id": 94,
        "rationale": "Structural patterns used to organize iOS code into testable, maintainable feature modules and layers. iOS engineers use these patterns to separate UI, state, and service integration concerns.",
        "slug": "app-architecture-and-dependency-injection",
        "source": "db"
      },
      "input_skill": "MVVM",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Mobile Architecture and Code Organization",
        "id": 170,
        "rationale": "Structural patterns used to organize shared mobile code into maintainable modules, layers, and feature boundaries. Senior hybrid developers often own these patterns to keep cross-platform code testable and adaptable to platform exceptions.",
        "slug": "mobile-architecture-and-code-organization",
        "source": "db"
      },
      "input_skill": "MVVM",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "App Architecture and Dependency Injection",
        "id": 94,
        "rationale": "Structural patterns used to organize iOS code into testable, maintainable feature modules and layers. iOS engineers use these patterns to separate UI, state, and service integration concerns.",
        "slug": "app-architecture-and-dependency-injection",
        "source": "db"
      },
      "input_skill": "MVI",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Mobile Architecture and Code Organization",
        "id": 170,
        "rationale": "Structural patterns used to organize shared mobile code into maintainable modules, layers, and feature boundaries. Senior hybrid developers often own these patterns to keep cross-platform code testable and adaptable to platform exceptions.",
        "slug": "mobile-architecture-and-code-organization",
        "source": "db"
      },
      "input_skill": "Clean Architecture",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "App Architecture and Dependency Injection",
        "id": 94,
        "rationale": "Structural patterns used to organize iOS code into testable, maintainable feature modules and layers. iOS engineers use these patterns to separate UI, state, and service integration concerns.",
        "slug": "app-architecture-and-dependency-injection",
        "source": "db"
      },
      "input_skill": "Dependency Injection",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Application Architecture and Code Organization",
        "id": 220,
        "rationale": "Structural patterns for organizing product code into maintainable modules, layers, and feature boundaries. Full stack engineers need this to keep cross-layer feature work understandable as the product grows.",
        "slug": "application-architecture-and-code-organization",
        "source": "db"
      },
      "input_skill": "Dependency Injection",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Mobile Architecture and Code Organization",
        "id": 170,
        "rationale": "Structural patterns used to organize shared mobile code into maintainable modules, layers, and feature boundaries. Senior hybrid developers often own these patterns to keep cross-platform code testable and adaptable to platform exceptions.",
        "slug": "mobile-architecture-and-code-organization",
        "source": "db"
      },
      "input_skill": "Dependency Injection",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Service Architecture and Design Patterns",
        "id": 18,
        "rationale": "Reusable backend design patterns used to structure service code and boundaries. Covers layering, dependency management, domain modeling, and maintainable service organization.",
        "slug": "service-architecture-and-design-patterns",
        "source": "db"
      },
      "input_skill": "Dependency Injection",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Latency and Cost Optimization",
        "id": 205,
        "rationale": "Techniques for making AI features fast and affordable enough for production use. This cluster is coherent because model choice, prompt length, caching, batching, and routing directly affect user experience and unit economics.",
        "slug": "latency-and-cost-optimization",
        "source": "db"
      },
      "input_skill": "Caching",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 13,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Debugging and Performance Tuning",
        "id": 219,
        "rationale": "Feature-level troubleshooting and optimization across client-server interactions. Full stack engineers use this to diagnose latency, correctness, and reliability issues that span multiple layers.",
        "slug": "debugging-and-performance-tuning",
        "source": "db"
      },
      "input_skill": "Profiling",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Performance and Scalability Tuning",
        "id": 11,
        "rationale": "Techniques for improving throughput, latency, and resource efficiency in backend services. Focuses on profiling, concurrency, load behavior, and bottleneck elimination.",
        "slug": "performance-and-scalability-tuning",
        "source": "db"
      },
      "input_skill": "Profiling",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "API Design and Contracts",
        "id": 3,
        "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
        "slug": "api-design-and-contracts",
        "source": "db"
      },
      "input_skill": "Pagination",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "API Integration and Data Fetching",
        "id": 127,
        "rationale": "Client-side integration with backend endpoints and third-party services, including request shaping, response handling, and synchronization with UI state. This is central to frontend work because most screens depend on remote data.",
        "slug": "api-integration-and-data-fetching",
        "source": "db"
      },
      "input_skill": "Pagination",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Engineer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "API Design and Contracts",
        "id": 3,
        "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
        "slug": "api-design-and-contracts",
        "source": "db"
      },
      "input_skill": "Idempotency",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Delivery Workflow Reliability",
        "id": 159,
        "rationale": "Practices for keeping build and release pipelines dependable under failure, load, and change. This cluster is coherent because the role is judged on reducing flaky releases, broken promotions, and recovery time.",
        "slug": "delivery-workflow-reliability",
        "source": "db"
      },
      "input_skill": "Idempotency",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Unit Testing",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Testing and Quality Assurance",
        "id": 12,
        "rationale": "Backend-specific test strategies used to validate service behavior and integration points. Covers automated test layers, contract checks, fixtures, and regression prevention.",
        "slug": "testing-and-quality-assurance",
        "source": "db"
      },
      "input_skill": "Integration Testing",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Deployment Automation and Rollouts",
        "id": 151,
        "rationale": "Mechanisms for promoting releases across environments, coordinating approvals, and executing safe rollouts or rollbacks. This is central to the role because it covers the path from merged code to production deployment.",
        "slug": "deployment-automation-and-rollouts",
        "source": "db"
      },
      "input_skill": "Feature Flags",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Deployment and Runtime Configuration",
        "id": 13,
        "rationale": "Configuration and release artifacts that control how backend services run in environments. Includes environment variables, manifests, feature flags, and release-safe configuration management.",
        "slug": "deployment-and-runtime-configuration",
        "source": "db"
      },
      "input_skill": "Feature Flags",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Feature Flags and Release Control",
        "id": 218,
        "rationale": "Mechanisms for safely shipping incremental product changes and controlling exposure. This cluster is coherent because full stack engineers frequently coordinate feature rollout, experimentation, and rollback across layers.",
        "slug": "feature-flags-and-release-control",
        "source": "db"
      },
      "input_skill": "Feature Flags",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Release Readiness and Browser Compatibility",
        "id": 129,
        "rationale": "Practices for verifying frontend changes across browsers, environments, and release stages. This cluster is coherent because frontend engineers often own the last-mile quality checks before shipping UI changes.",
        "slug": "release-readiness-and-browser-compatibility",
        "source": "db"
      },
      "input_skill": "Feature Flags",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Engineer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD Pipeline Platforms",
        "id": 150,
        "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
        "slug": "ci-cd-pipeline-platforms",
        "source": "db"
      },
      "input_skill": "CI/CD",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD for Machine Learning",
        "id": 56,
        "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
        "slug": "ci-cd-for-machine-learning",
        "source": "db"
      },
      "input_skill": "CI/CD",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "iOS",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Android",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Screen Navigation and State",
        "id": 83,
        "rationale": "Patterns for moving users through app flows and keeping client state consistent across screens, refreshes, and app transitions. This is central to feature work because iOS engineers own the in-app request flow and UI logic.",
        "slug": "screen-navigation-and-state",
        "source": "db"
      },
      "input_skill": "Riverpod",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Platform Channels",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Agora",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Twilio",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "WebRTC",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Offline-first",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Screen Navigation and State",
        "id": 83,
        "rationale": "Patterns for moving users through app flows and keeping client state consistent across screens, refreshes, and app transitions. This is central to feature work because iOS engineers own the in-app request flow and UI logic.",
        "slug": "screen-navigation-and-state",
        "source": "db"
      },
      "input_skill": "Sync",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Screen Navigation and State",
        "id": 83,
        "rationale": "Patterns for moving users through app flows and keeping client state consistent across screens, refreshes, and app transitions. This is central to feature work because iOS engineers own the in-app request flow and UI logic.",
        "slug": "screen-navigation-and-state",
        "source": "db"
      },
      "input_skill": "Sync",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Secure Storage",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Networking and API Integration",
        "id": 84,
        "rationale": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
        "slug": "networking-and-api-integration",
        "source": "db"
      },
      "input_skill": "Sockets",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Background Execution and Lifecycle",
        "id": 87,
        "rationale": "App lifecycle handling and deferred work mechanisms that keep iOS behavior reliable when the app is backgrounded, suspended, or relaunched. This is important for sync, refresh, and user-visible continuity.",
        "slug": "background-execution-and-lifecycle",
        "source": "db"
      },
      "input_skill": "Push Notifications",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Background Execution and Lifecycle",
        "id": 87,
        "rationale": "App lifecycle handling and deferred work mechanisms that keep iOS behavior reliable when the app is backgrounded, suspended, or relaunched. This is important for sync, refresh, and user-visible continuity.",
        "slug": "background-execution-and-lifecycle",
        "source": "db"
      },
      "input_skill": "Push Notifications",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Performance and Stability Tuning",
        "id": 92,
        "rationale": "Techniques for improving responsiveness, startup time, memory use, and overall app stability on iOS devices. This cluster is important because client performance directly affects user experience and release readiness.",
        "slug": "performance-and-stability-tuning",
        "source": "db"
      },
      "input_skill": "Image Caching",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "API Integration and Data Fetching",
        "id": 127,
        "rationale": "Client-side integration with backend endpoints and third-party services, including request shaping, response handling, and synchronization with UI state. This is central to frontend work because most screens depend on remote data.",
        "slug": "api-integration-and-data-fetching",
        "source": "db"
      },
      "input_skill": "API Integration",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Engineer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Networking and API Integration",
        "id": 84,
        "rationale": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
        "slug": "networking-and-api-integration",
        "source": "db"
      },
      "input_skill": "API Integration",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cross-Platform App Languages",
        "id": 167,
        "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
        "slug": "cross-platform-app-languages",
        "source": "db"
      },
      "input_skill": "API Integration",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "API Integration and Data Fetching",
        "id": 127,
        "rationale": "Client-side integration with backend endpoints and third-party services, including request shaping, response handling, and synchronization with UI state. This is central to frontend work because most screens depend on remote data.",
        "slug": "api-integration-and-data-fetching",
        "source": "db"
      },
      "input_skill": "API Integration",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Engineer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Networking and API Integration",
        "id": 84,
        "rationale": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
        "slug": "networking-and-api-integration",
        "source": "db"
      },
      "input_skill": "API Integration",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cross-Platform App Languages",
        "id": 167,
        "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
        "slug": "cross-platform-app-languages",
        "source": "db"
      },
      "input_skill": "API Integration",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Authentication and Session Handling",
        "id": 86,
        "rationale": "Client-side identity flows and secure session management used to sign users in and keep them authenticated. This includes token handling, login UX, and protecting secrets on device.",
        "slug": "authentication-and-session-handling",
        "source": "db"
      },
      "input_skill": "Authentication",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Frontend Engineer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Authentication and Session Handling",
        "id": 86,
        "rationale": "Client-side identity flows and secure session management used to sign users in and keep them authenticated. This includes token handling, login UX, and protecting secrets on device.",
        "slug": "authentication-and-session-handling",
        "source": "db"
      },
      "input_skill": "Authentication",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Frontend Engineer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Widget Testing",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Golden Tests",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Mocks",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Fakes",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "A/B Testing",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Systems Programming",
        "id": 166,
        "rationale": "Systems programming covers low-level software development where performance, memory safety, and direct control over resources matter. Rust fits here because it is commonly used for OS-adjacent services, infrastructure components, and other performance-sensitive systems code.",
        "slug": "d_init_02",
        "source": "db"
      },
      "input_skill": "A/B Testing",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Crash Reporting and Observability",
        "id": 91,
        "rationale": "Client-side telemetry used to diagnose crashes, hangs, performance regressions, and field issues in iOS apps. iOS engineers use these tools to understand production behavior and prioritize fixes.",
        "slug": "crash-reporting-and-observability",
        "source": "db"
      },
      "input_skill": "Crash Analytics",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Crash Reporting and Observability",
        "id": 91,
        "rationale": "Client-side telemetry used to diagnose crashes, hangs, performance regressions, and field issues in iOS apps. iOS engineers use these tools to understand production behavior and prioritize fixes.",
        "slug": "crash-reporting-and-observability",
        "source": "db"
      },
      "input_skill": "Crash Analytics",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cross-Platform App Languages",
        "id": 167,
        "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
        "slug": "cross-platform-app-languages",
        "source": "db"
      },
      "input_skill": "Lazy Lists",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cross-Platform App Languages",
        "id": 167,
        "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
        "slug": "cross-platform-app-languages",
        "source": "db"
      },
      "input_skill": "Lazy Lists",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Networking and API Integration",
        "id": 84,
        "rationale": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
        "slug": "networking-and-api-integration",
        "source": "db"
      },
      "input_skill": "Reconnection Logic",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Networking and API Integration",
        "id": 84,
        "rationale": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
        "slug": "networking-and-api-integration",
        "source": "db"
      },
      "input_skill": "Reconnection Logic",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Screen Sharing",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Echo Cancellation",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Performance and Stability Tuning",
        "id": 92,
        "rationale": "Techniques for improving responsiveness, startup time, memory use, and overall app stability on iOS devices. This cluster is important because client performance directly affects user experience and release readiness.",
        "slug": "performance-and-stability-tuning",
        "source": "db"
      },
      "input_skill": "Bandwidth Adaptation",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Performance and Stability Tuning",
        "id": 92,
        "rationale": "Techniques for improving responsiveness, startup time, memory use, and overall app stability on iOS devices. This cluster is important because client performance directly affects user experience and release readiness.",
        "slug": "performance-and-stability-tuning",
        "source": "db"
      },
      "input_skill": "Bandwidth Adaptation",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Crash Reporting and Observability",
        "id": 91,
        "rationale": "Client-side telemetry used to diagnose crashes, hangs, performance regressions, and field issues in iOS apps. iOS engineers use these tools to understand production behavior and prioritize fixes.",
        "slug": "crash-reporting-and-observability",
        "source": "db"
      },
      "input_skill": "Recording",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Recording",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Crash Reporting and Observability",
        "id": 91,
        "rationale": "Client-side telemetry used to diagnose crashes, hangs, performance regressions, and field issues in iOS apps. iOS engineers use these tools to understand production behavior and prioritize fixes.",
        "slug": "crash-reporting-and-observability",
        "source": "db"
      },
      "input_skill": "Recording",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    }
  ],
  "input_final_skills": [
    "Flutter",
    "iOS",
    "Android",
    "Kotlin",
    "Swift",
    "Riverpod",
    "Platform Channels",
    "Agora",
    "Twilio",
    "WebRTC",
    "MVVM",
    "MVI",
    "Clean Architecture",
    "Dependency Injection",
    "Offline-first",
    "Caching",
    "Sync",
    "Secure Storage",
    "Sockets",
    "Push Notifications",
    "Image Caching",
    "Profiling",
    "API Integration",
    "Authentication",
    "Pagination",
    "Idempotency",
    "Unit Testing",
    "Widget Testing",
    "Integration Testing",
    "Golden Tests",
    "Mocks",
    "Fakes",
    "A/B Testing",
    "Feature Flags",
    "CI/CD",
    "Crash Analytics",
    "Lazy Lists",
    "Reconnection Logic",
    "Screen Sharing",
    "Echo Cancellation",
    "Bandwidth Adaptation",
    "Recording"
  ],
  "input_llm_skills": [
    "Flutter",
    "iOS",
    "Android",
    "Kotlin",
    "Swift",
    "Riverpod",
    "Platform Channels",
    "Agora",
    "Twilio",
    "WebRTC",
    "MVVM",
    "MVI",
    "Clean Architecture",
    "Dependency Injection",
    "Offline-first",
    "Caching",
    "Sync",
    "Secure Storage",
    "Sockets",
    "Push Notifications",
    "Image Caching",
    "Profiling",
    "API Integration",
    "Authentication",
    "Pagination",
    "Idempotency",
    "Unit Testing",
    "Widget Testing",
    "Integration Testing",
    "Golden Tests",
    "Mocks",
    "Fakes",
    "A/B Testing",
    "Feature Flags",
    "CI/CD",
    "Crash Analytics",
    "Lazy Lists",
    "Reconnection Logic",
    "Screen Sharing",
    "Echo Cancellation",
    "Bandwidth Adaptation",
    "Recording"
  ],
  "new_aliases_persisted": 0,
  "run_id": "4d35418a-3821-4fe3-8cbc-48910b959cf5",
  "skills_detail": [
    {
      "aliases_in_db": [
        {
          "alias_text": "Flutter",
          "alias_type": "CANONICAL",
          "id": 1658,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "flutter",
          "alias_type": "VERSION",
          "id": 1659,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "flutter 3",
          "alias_type": "VERSION",
          "id": 1661,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "flutter 3.x",
          "alias_type": "VERSION",
          "id": 1662,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "flutter3",
          "alias_type": "VERSION",
          "id": 1660,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "Flutter",
        "id": 1041,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "flutter",
        "sub_category_id": 341,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "UI Frameworks and Rendering",
            "id": 115,
            "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
            "slug": "ui-frameworks-and-rendering",
            "source": "db"
          },
          "input_skill": "Flutter",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Engineer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Flutter",
      "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": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "iOS",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "iOS",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Platform",
          "skill_nature": "PLATFORM",
          "sub_category": "mobile_operating_platform",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201ciOS\u201d is a specific mobile operating system; unlikely to be confused with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "Swift",
              "UIKit",
              "Core Data",
              "Xcode",
              "Cocoa Touch",
              "SwiftUI",
              "Objective-C",
              "App Store",
              "CocoaPods",
              "MVVM",
              "RESTful APIs",
              "Auto Layout",
              "TestFlight",
              "iCloud",
              "Push Notifications"
            ]
          },
          "maturity": {
            "confidence": 0.98,
            "maturity": "well_known",
            "reasoning": "iOS is a mainstream mobile platform with high JD volume for Swift/iOS roles across consumer and enterprise apps; Apple continues active platform support and releases, indicating broad adoption rather than niche use."
          },
          "skill_id": "ios",
          "vendor_license": {
            "confidence": 0.95,
            "license": "proprietary",
            "vendor": "Apple Inc.",
            "year_introduced": 2007
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Core skills for building native iPhone and iPad applications with Apple\u0027s platform APIs and app lifecycle model. iOS fits here because it names the platform itself, which spans UI, device integration, and app behavior on Apple devices.",
            "exemplar_skills": [
              "iOS",
              "Swift",
              "Objective-C",
              "UIKit",
              "SwiftUI",
              "Xcode"
            ],
            "in_scope": "iOS, Swift, Objective-C, UIKit, SwiftUI, Xcode, iOS app lifecycle, app sandboxing, device permissions, Apple Human Interface Guidelines",
            "name": "iOS App Development",
            "out_of_scope": "Android app development, web frontend frameworks, backend API design, cross-platform shared codebases, cloud infrastructure",
            "overlap_flags": [
              {
                "reason": "iOS app work often includes navigation and state management, but that catalog dimension is narrower and focuses on flow/state patterns rather than the platform itself.",
                "with_dim_id": "screen-navigation-and-state",
                "with_dim_name": null,
                "with_role": "Android Engineer, Full Stack Engineer, Hybrid Mobile Developer, Ios engineer"
              },
              {
                "reason": "App lifecycle and background behavior are part of iOS development, but this is a specialized sub-area within the broader iOS platform dimension.",
                "with_dim_id": "background-execution-and-lifecycle",
                "with_dim_name": null,
                "with_role": "Hybrid Mobile Developer, Ios engineer"
              },
              {
                "reason": "iOS apps commonly consume APIs, but networking is a cross-cutting client skill rather than the platform-wide iOS dimension.",
                "with_dim_id": "networking-and-api-integration",
                "with_dim_name": null,
                "with_role": "Android Engineer, Hybrid Mobile Developer, Ios engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "iOS",
          "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": "ios"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "ui-development",
            "api",
            "react",
            "angular",
            "vue",
            "javascript",
            "css",
            "localstorage"
          ],
          "requires": [],
          "skill_id": "ios",
          "suppress_on_match": []
        },
        "skill_id": "ios",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Runtime: ruled out \u2014 iOS is not primarily an execution runtime like JVM or Node.js.",
            "Tool: ruled out \u2014 it is not user-operated software installed to perform a task."
          ],
          "confidence": 0.93,
          "name": "iOS",
          "reasoning": "By the Platform vs Tool rule, iOS is a hosted operating platform/ecosystem for apps and services rather than software you run yourself, so it fits Platform best.",
          "skill_id": "ios",
          "subtype": "mobile_operating_platform",
          "type": "Platform"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Android",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Android",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Platform",
          "skill_nature": "PLATFORM",
          "sub_category": "mobile_platform",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cAndroid\u201d in JDs typically refers specifically to the Android mobile platform; it\u2019s unlikely to be confused with another distinct catalog skill."
          },
          "context_keywords": {
            "context_keywords": [
              "Kotlin",
              "Java",
              "Android Studio",
              "Gradle",
              "XML",
              "Jetpack",
              "RecyclerView",
              "MVVM",
              "LiveData",
              "Room",
              "Retrofit",
              "Firebase",
              "Material Design",
              "API Level",
              "Android SDK"
            ]
          },
          "maturity": {
            "confidence": 0.98,
            "maturity": "well_known",
            "reasoning": "Android appears in large volumes of mobile job postings and remains a standard platform in hiring pipelines; Google continues active platform releases and OEM ecosystem support, indicating broad adoption."
          },
          "skill_id": "android",
          "vendor_license": {
            "confidence": 0.95,
            "license": "apache_2",
            "vendor": "Google",
            "year_introduced": 2008
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Core skills for building native Android applications, including platform APIs, app structure, and device-specific behavior. Android belongs here because it is the primary operating system and development surface for Android mobile engineering.",
            "exemplar_skills": [
              "Android",
              "Android SDK",
              "Jetpack",
              "AndroidX",
              "Activities",
              "Fragments",
              "Services",
              "BroadcastReceivers"
            ],
            "in_scope": "Android, Android SDK, Activities, Fragments, Services, BroadcastReceivers, Jetpack, AndroidX, app lifecycle, permissions, resources, manifest, device compatibility",
            "name": "Android App Development",
            "out_of_scope": "Kotlin and Java language syntax, Flutter shared UI code, iOS-specific APIs, backend services, cloud infrastructure",
            "overlap_flags": [
              {
                "reason": "Android apps are commonly implemented in Kotlin or Java, but this dimension covers the platform rather than the programming languages.",
                "with_dim_id": "kotlin-and-java",
                "with_dim_name": null,
                "with_role": "Android Engineer"
              },
              {
                "reason": "Flutter and other shared-code mobile stacks can target Android, but this dimension is specifically about native Android platform development.",
                "with_dim_id": "cross-platform-app-languages",
                "with_dim_name": null,
                "with_role": "Hybrid Mobile Developer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Android",
          "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": "android"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "java",
            "javascript",
            "c",
            "c#",
            "go",
            "ui-development",
            "api",
            "react"
          ],
          "requires": [],
          "skill_id": "android",
          "suppress_on_match": []
        },
        "skill_id": "android",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.95,
          "name": "Android",
          "reasoning": "Android is a hosted mobile ecosystem with APIs and managed services for app distribution and device integration, so by the Platform vs Tool rule it is a Platform rather than software you run yourself.",
          "skill_id": "android",
          "subtype": "mobile_platform",
          "type": "Platform"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Kotlin",
          "alias_type": "CANONICAL",
          "id": 24,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "Kotlin",
        "id": 2,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "kotlin",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Kotlin and Java",
            "id": 161,
            "rationale": "Primary implementation languages for Android app features, platform integration, and client-side business logic. Android engineers use these languages to build screens, state flows, service adapters, and device-aware behavior.",
            "slug": "kotlin-and-java",
            "source": "db"
          },
          "input_skill": "Kotlin",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "Kotlin",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Kotlin",
      "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": "Swift",
          "alias_type": "CANONICAL",
          "id": 756,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 2.0",
          "alias_type": "VERSION",
          "id": 757,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 2.x",
          "alias_type": "VERSION",
          "id": 758,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 3.0",
          "alias_type": "VERSION",
          "id": 759,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 3.x",
          "alias_type": "VERSION",
          "id": 760,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 4.0",
          "alias_type": "VERSION",
          "id": 761,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 4.x",
          "alias_type": "VERSION",
          "id": 762,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 5.0",
          "alias_type": "VERSION",
          "id": 763,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 5.x",
          "alias_type": "VERSION",
          "id": 764,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 6.0",
          "alias_type": "VERSION",
          "id": 765,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 6.x",
          "alias_type": "VERSION",
          "id": 766,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "Swift",
        "id": 440,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "swift",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Swift and Objective-C",
            "id": 81,
            "rationale": "Primary implementation languages for native iOS app features, platform APIs, and client-side business logic. This is the core coding surface for building and maintaining iPhone and iPad experiences.",
            "slug": "swift-and-objective-c",
            "source": "db"
          },
          "input_skill": "Swift",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Swift",
      "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": "Screen Navigation and State",
            "id": 83,
            "rationale": "Patterns for moving users through app flows and keeping client state consistent across screens, refreshes, and app transitions. This is central to feature work because iOS engineers own the in-app request flow and UI logic.",
            "slug": "screen-navigation-and-state",
            "source": "db"
          },
          "input_skill": "Riverpod",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Riverpod",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Framework",
          "skill_nature": "FRAMEWORK",
          "sub_category": "state_management_framework",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "SEPARATE_ENTITY",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "Riverpod is a specific Flutter/Dart state-management framework; unlikely to be confused with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "Flutter",
              "Provider",
              "StateNotifier",
              "ChangeNotifier",
              "ScopedReader",
              "AutoDispose",
              "AsyncValue",
              "Riverpod 2.0",
              "hooks_riverpod",
              "Dependency Injection",
              "Global State",
              "State Management",
              "Immutable State",
              "Reactivity",
              "Widget Tree"
            ]
          },
          "maturity": {
            "confidence": 0.84,
            "maturity": "emerging",
            "reasoning": "Riverpod appears in growing Flutter job postings and package adoption, but it is still far less universal than Provider/BLoC in JDs and hiring pipelines."
          },
          "skill_id": "riverpod",
          "vendor_license": {
            "confidence": 0.9,
            "license": "mit",
            "vendor": "Remi Rousselet",
            "year_introduced": 2020
          },
          "versioning": {
            "current_version": "2",
            "version_aliases": {
              "flutter_riverpod": "2",
              "flutter_riverpod 2": "2",
              "flutter_riverpod v2": "2",
              "riverpod 2": "2",
              "riverpod v2": "2",
              "riverpod2": "2"
            },
            "versioned": true
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Patterns and libraries for managing UI state, dependency injection, and reactive updates in Flutter apps. Riverpod belongs here because it is a core Flutter state-management solution used to expose app state to widgets and coordinate feature logic.",
            "exemplar_skills": [
              "Riverpod",
              "Provider",
              "StateNotifierProvider",
              "FutureProvider",
              "StreamProvider",
              "Flutter state management",
              "dependency injection in Flutter"
            ],
            "in_scope": "Riverpod, StateNotifierProvider, Provider, FutureProvider, StreamProvider, dependency injection, reactive UI state, app-level state, feature state, Flutter widget rebuilds",
            "name": "Flutter State Management",
            "out_of_scope": "Route matching and deep links, browser URL handling, screen transitions, backend API request logic, authentication session storage",
            "overlap_flags": [
              {
                "reason": "Riverpod often wraps async API calls and cached responses, but the data-fetching mechanics themselves belong to the API integration dimension.",
                "with_dim_id": "api-integration-and-data-fetching",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Engineer"
              },
              {
                "reason": "Riverpod can hold form and validation state, but validation and recovery flow design are broader UI interaction concerns.",
                "with_dim_id": "form-validation-and-error-recovery",
                "with_dim_name": null,
                "with_role": "Frontend Engineer"
              }
            ],
            "tentative_id": "screen-navigation-and-state"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Riverpod",
          "placement_confidence": 0.92,
          "primary_dimension": "screen-navigation-and-state",
          "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": "riverpod"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "redux",
            "react",
            "ruby-on-rails",
            "spring-boot",
            "pagination",
            "radix-ui"
          ],
          "requires": [],
          "skill_id": "riverpod",
          "suppress_on_match": []
        },
        "skill_id": "riverpod",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "Riverpod",
          "reasoning": "Riverpod is a Flutter/Dart state-management framework that developers build applications with, so it fits the Tool vs Framework rule as a Framework rather than a library or tool.",
          "skill_id": "riverpod",
          "subtype": "state_management_framework",
          "type": "Framework"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Platform Channels",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Platform Channels",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Platform",
          "skill_nature": "PLATFORM",
          "sub_category": "communication_platform",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cPlatform Channels\u201d is a specific platform/communication-channel concept; unlikely to be confused with another distinct catalog skill in typical JDs."
          },
          "context_keywords": {
            "context_keywords": [
              "messaging",
              "webhooks",
              "API integration",
              "chatbots",
              "notifications",
              "real-time",
              "event-driven",
              "user engagement",
              "cross-platform",
              "service-oriented",
              "data synchronization",
              "scalability",
              "platform integration",
              "third-party services",
              "cloud messaging"
            ]
          },
          "maturity": {
            "confidence": 0.86,
            "maturity": "niche",
            "reasoning": "Platform Channels is a Flutter-specific bridge API; job postings usually ask for Flutter/Dart rather than this API by name, and market demand is limited to cross-platform mobile teams using native interop."
          },
          "skill_id": "platform-channels",
          "vendor_license": {
            "confidence": 0.9,
            "license": "apache_2",
            "vendor": "Google",
            "year_introduced": 2018
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Platform Channels covers the native communication bridge between Flutter/Dart code and host platform code. It includes defining method, event, and basic message channels used to call iOS/Android APIs or receive callbacks from native code.",
            "exemplar_skills": [
              "Platform Channels",
              "MethodChannel",
              "EventChannel",
              "BasicMessageChannel",
              "Flutter plugin development",
              "Dart-to-native interop"
            ],
            "in_scope": "Platform Channels, MethodChannel, EventChannel, BasicMessageChannel, Flutter plugin platform bridges, Dart-to-native calls, native-to-Dart callbacks, iOS/Android host API invocation",
            "name": "Platform Channels",
            "out_of_scope": "UI layout and widget composition, app navigation and routing, networking to remote servers, state management, platform-specific build tooling",
            "overlap_flags": [
              {
                "reason": "Platform channels are implemented in Dart and often require native code on iOS/Android, so they overlap with shared mobile app language work.",
                "with_dim_id": "cross-platform-app-languages",
                "with_dim_name": null,
                "with_role": "Hybrid Mobile Developer"
              },
              {
                "reason": "Android-side channel handlers are commonly written in Kotlin or Java, creating overlap with native Android implementation skills.",
                "with_dim_id": "kotlin-and-java",
                "with_dim_name": null,
                "with_role": "Android Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Platform Channels",
          "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": "platform-channels"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "api",
            "openapi",
            "websockets",
            "api-security",
            "network-operations",
            "feature-modules",
            "feature-flags",
            "apollo-client"
          ],
          "requires": [],
          "skill_id": "platform-channels",
          "suppress_on_match": []
        },
        "skill_id": "platform-channels",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Service: ruled out \u2014 the name suggests a broader hosted environment rather than a single managed capability inside another platform.",
            "Tool: ruled out \u2014 this is not primarily software a user runs locally or self-hosts."
          ],
          "confidence": 0.78,
          "name": "Platform Channels",
          "reasoning": "By the Platform vs Tool rule, \"Platform Channels\" reads as a hosted multi-tenant communication environment with APIs rather than software you run yourself, so Platform is the best fit.",
          "skill_id": "platform-channels",
          "subtype": "communication_platform",
          "type": "Platform"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Agora",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Agora",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Platform",
          "skill_nature": "PLATFORM",
          "sub_category": "communications_platform",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cAgora\u201d as a communications platform name is distinctive; unlikely to be confused with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "real-time",
              "video conferencing",
              "WebRTC",
              "SDK",
              "API",
              "streaming",
              "interactive broadcasting",
              "low latency",
              "multiplayer",
              "chat integration",
              "mobile SDK",
              "voice calls",
              "screen sharing",
              "live streaming",
              "event hosting"
            ]
          },
          "maturity": {
            "confidence": 0.86,
            "maturity": "niche",
            "reasoning": "Agora appears in some real-time video/voice SDK job postings, but JD volume is far below mainstream cloud or frontend stacks; market demand is concentrated in communications/media products rather than broad hiring pipelines."
          },
          "skill_id": "agora",
          "vendor_license": {
            "confidence": 0.9,
            "license": "other_open",
            "vendor": "Agora.io",
            "year_introduced": 2014
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Client and server SDKs used for live audio, video, and interactive messaging in apps. Agora belongs here because it is a communications platform commonly used to add real-time calling and streaming features.",
            "exemplar_skills": [
              "Agora",
              "real-time communication SDKs",
              "video calling integration",
              "voice chat SDKs",
              "live streaming SDK integration"
            ],
            "in_scope": "Agora, live audio/video SDKs, RTC APIs, voice calling, video calling, interactive live streaming, channel management, media transport, signaling, screen sharing",
            "name": "Real-Time Communication SDKs",
            "out_of_scope": "Authentication and session handling, generic HTTP networking, push notifications, and UI navigation; those belong to other mobile platform dimensions",
            "overlap_flags": [
              {
                "reason": "Agora integrations often involve backend token and session APIs, but the core skill is real-time media communication rather than general data fetching.",
                "with_dim_id": "api-integration-and-data-fetching",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Engineer"
              },
              {
                "reason": "Implementations may use HTTP for auth or signaling setup, but Agora itself is primarily an RTC SDK and media platform.",
                "with_dim_id": "networking-and-api-integration",
                "with_dim_name": null,
                "with_role": "Android Engineer, Hybrid Mobile Developer, Ios engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Agora",
          "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": "agora"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "api",
            "axios",
            "apollo-client",
            "react",
            "vue",
            "angular",
            "jest",
            "ant-design"
          ],
          "requires": [],
          "skill_id": "agora",
          "suppress_on_match": []
        },
        "skill_id": "agora",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Service: ruled out \u2014 Agora is the broader hosted environment, not a single managed capability inside another platform.",
            "Tool: ruled out \u2014 it is typically consumed as a vendor-hosted service, not self-hosted software."
          ],
          "confidence": 0.88,
          "name": "Agora",
          "reasoning": "By the Platform vs Tool rule, Agora is a hosted multi-tenant communications environment with APIs rather than software you run yourself.",
          "skill_id": "agora",
          "subtype": "communications_platform",
          "type": "Platform"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Twilio",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Twilio",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Platform",
          "skill_nature": "PLATFORM",
          "sub_category": "communications_platform",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "Twilio is a specific communications API/vendor name; unlikely to be confused with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "SMS",
              "MMS",
              "Voice API",
              "Twilio Functions",
              "Twilio Flex",
              "Programmable Video",
              "Webhook",
              "Twilio Studio",
              "API integration",
              "Call tracking",
              "Two-factor authentication",
              "Chatbot",
              "Real-time messaging",
              "Twilio CLI",
              "Twilio Console"
            ]
          },
          "maturity": {
            "confidence": 0.93,
            "maturity": "well_known",
            "reasoning": "Twilio appears frequently in job postings for SMS/voice/OTP integrations and is a standard CPaaS vendor in hiring pipelines; no vendor sunset indicates deprecation."
          },
          "skill_id": "twilio",
          "vendor_license": {
            "confidence": 0.95,
            "license": "other_open",
            "vendor": "Twilio Inc.",
            "year_introduced": 2008
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Integration with third-party communications platforms used to send and receive SMS, voice, and messaging traffic. Twilio belongs here because it is commonly used as the application-facing API for phone verification, notifications, and call/message workflows.",
            "exemplar_skills": [
              "Twilio",
              "Twilio SMS API",
              "Twilio Voice API",
              "Twilio WhatsApp API",
              "Twilio webhooks",
              "OTP delivery",
              "phone verification",
              "programmable messaging"
            ],
            "in_scope": "Twilio, SMS sending and receiving, voice call APIs, WhatsApp messaging, phone verification, OTP delivery, message status callbacks, webhook handling, contact center messaging, programmable communications APIs",
            "name": "Communications API Integration",
            "out_of_scope": "Generic HTTP client code and REST request handling, user authentication/session management, push notifications and in-app messaging owned by mobile messaging systems, backend telephony infrastructure not exposed through the API",
            "overlap_flags": [
              {
                "reason": "Twilio is consumed through APIs and webhooks, but this dimension is broader client-side integration rather than communications-specific workflows.",
                "with_dim_id": "api-integration-and-data-fetching",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Engineer"
              },
              {
                "reason": "Mobile apps may call Twilio endpoints directly, but the skill is more specifically about communications services than general networking.",
                "with_dim_id": "networking-and-api-integration",
                "with_dim_name": null,
                "with_role": "Android Engineer, Hybrid Mobile Developer, Ios engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Twilio",
          "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": "twilio"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "websockets",
            "api",
            "openapi",
            "oauth2",
            "jwt",
            "axios",
            "fetch-api",
            "wireguard"
          ],
          "requires": [],
          "skill_id": "twilio",
          "suppress_on_match": []
        },
        "skill_id": "twilio",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Service: ruled out \u2014 Twilio is the broader hosted vendor environment, not a single service inside another platform.",
            "Tool: ruled out \u2014 it is consumed via hosted APIs rather than software you run yourself."
          ],
          "confidence": 0.97,
          "name": "Twilio",
          "reasoning": "Twilio is a commercial vendor SaaS with hosted APIs and managed communications capabilities, so by the Vendor SaaS = Platform rule it is a Platform rather than a Tool or Service.",
          "skill_id": "twilio",
          "subtype": "communications_platform",
          "type": "Platform"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "WebRTC",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "WebRTC",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Protocol",
          "skill_nature": "PROTOCOL",
          "sub_category": "real_time_communication_protocol",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "WebRTC is a specific real-time communication protocol/stack; typical JDs won\u2019t confuse it with other common networking or streaming skills."
          },
          "context_keywords": {
            "context_keywords": [
              "peer-to-peer",
              "media streaming",
              "STUN",
              "TURN",
              "ICE",
              "WebSocket",
              "SDP",
              "JavaScript",
              "video conferencing",
              "audio processing",
              "real-time data",
              "NAT traversal",
              "browser compatibility",
              "signaling server",
              "WebRTC API"
            ]
          },
          "maturity": {
            "confidence": 0.86,
            "maturity": "well_known",
            "reasoning": "WebRTC appears in many job descriptions for real-time video/audio apps and is a standard browser API; it\u2019s broadly adopted rather than niche or sunsetted."
          },
          "skill_id": "webrtc",
          "vendor_license": {
            "confidence": 0.9,
            "license": "other_open",
            "vendor": "Google",
            "year_introduced": 2011
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Protocols and APIs for low-latency audio, video, and data exchange between clients. WebRTC belongs here because it provides the core browser and mobile primitives for peer-to-peer media sessions, signaling-adjacent transport, and interactive communication.",
            "exemplar_skills": [
              "WebRTC",
              "RTCPeerConnection",
              "getUserMedia",
              "ICE",
              "STUN",
              "TURN",
              "SDP negotiation",
              "data channels"
            ],
            "in_scope": "WebRTC, peer-to-peer audio/video calls, data channels, RTCPeerConnection, getUserMedia, ICE, STUN, TURN, SDP negotiation, media stream handling, call setup and teardown",
            "name": "Real-Time Media Communication",
            "out_of_scope": "HTTP API integration, chat message persistence, video encoding pipelines, native camera capture APIs, server-side media transcoding",
            "overlap_flags": [
              {
                "reason": "WebRTC relies on network transport and connection handling, but this dimension is specifically about real-time media session mechanics rather than general HTTP communication.",
                "with_dim_id": "networking-and-api-integration",
                "with_dim_name": null,
                "with_role": "Android Engineer, Hybrid Mobile Developer, Ios engineer"
              },
              {
                "reason": "In Flutter, WebRTC is often used through shared app code, but the skill itself is the media communication technology rather than the language layer.",
                "with_dim_id": "cross-platform-app-languages",
                "with_dim_name": null,
                "with_role": "Hybrid Mobile Developer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "WebRTC",
          "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": "webrtc"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "websockets",
            "wireguard",
            "oauth-2-0",
            "jwt",
            "api-security",
            "api",
            "node-js"
          ],
          "requires": [],
          "skill_id": "webrtc",
          "suppress_on_match": []
        },
        "skill_id": "webrtc",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.93,
          "name": "WebRTC",
          "reasoning": "WebRTC is fundamentally a communication standard for real-time media and data exchange between systems, so it fits the Protocol type rather than a tool or framework.",
          "skill_id": "webrtc",
          "subtype": "real_time_communication_protocol",
          "type": "Protocol"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "MVVM",
          "alias_type": "CANONICAL",
          "id": 830,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 1,
        "display_name": "MVVM",
        "id": 504,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PATTERN",
        "slug": "mvvm",
        "sub_category_id": 735,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "App Architecture and Dependency Injection",
            "id": 94,
            "rationale": "Structural patterns used to organize iOS code into testable, maintainable feature modules and layers. iOS engineers use these patterns to separate UI, state, and service integration concerns.",
            "slug": "app-architecture-and-dependency-injection",
            "source": "db"
          },
          "input_skill": "MVVM",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Mobile Architecture and Code Organization",
            "id": 170,
            "rationale": "Structural patterns used to organize shared mobile code into maintainable modules, layers, and feature boundaries. Senior hybrid developers often own these patterns to keep cross-platform code testable and adaptable to platform exceptions.",
            "slug": "mobile-architecture-and-code-organization",
            "source": "db"
          },
          "input_skill": "MVVM",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "MVVM",
      "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": "MVI",
          "alias_type": "CANONICAL",
          "id": 1596,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 1,
        "display_name": "MVI",
        "id": 986,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PATTERN",
        "slug": "mvi",
        "sub_category_id": 662,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "App Architecture and Dependency Injection",
            "id": 94,
            "rationale": "Structural patterns used to organize iOS code into testable, maintainable feature modules and layers. iOS engineers use these patterns to separate UI, state, and service integration concerns.",
            "slug": "app-architecture-and-dependency-injection",
            "source": "db"
          },
          "input_skill": "MVI",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "MVI",
      "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": "clean architecture",
          "alias_type": "CANONICAL",
          "id": 1704,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 1,
        "display_name": "clean architecture",
        "id": 1078,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PATTERN",
        "slug": "clean-architecture",
        "sub_category_id": 733,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Mobile Architecture and Code Organization",
            "id": 170,
            "rationale": "Structural patterns used to organize shared mobile code into maintainable modules, layers, and feature boundaries. Senior hybrid developers often own these patterns to keep cross-platform code testable and adaptable to platform exceptions.",
            "slug": "mobile-architecture-and-code-organization",
            "source": "db"
          },
          "input_skill": "Clean Architecture",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Clean Architecture",
      "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": "dependency injection",
          "alias_type": "CANONICAL",
          "id": 229,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "dependency injection",
        "id": 88,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "dependency-injection",
        "sub_category_id": 18,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "App Architecture and Dependency Injection",
            "id": 94,
            "rationale": "Structural patterns used to organize iOS code into testable, maintainable feature modules and layers. iOS engineers use these patterns to separate UI, state, and service integration concerns.",
            "slug": "app-architecture-and-dependency-injection",
            "source": "db"
          },
          "input_skill": "Dependency Injection",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Application Architecture and Code Organization",
            "id": 220,
            "rationale": "Structural patterns for organizing product code into maintainable modules, layers, and feature boundaries. Full stack engineers need this to keep cross-layer feature work understandable as the product grows.",
            "slug": "application-architecture-and-code-organization",
            "source": "db"
          },
          "input_skill": "Dependency Injection",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Mobile Architecture and Code Organization",
            "id": 170,
            "rationale": "Structural patterns used to organize shared mobile code into maintainable modules, layers, and feature boundaries. Senior hybrid developers often own these patterns to keep cross-platform code testable and adaptable to platform exceptions.",
            "slug": "mobile-architecture-and-code-organization",
            "source": "db"
          },
          "input_skill": "Dependency Injection",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Service Architecture and Design Patterns",
            "id": 18,
            "rationale": "Reusable backend design patterns used to structure service code and boundaries. Covers layering, dependency management, domain modeling, and maintainable service organization.",
            "slug": "service-architecture-and-design-patterns",
            "source": "db"
          },
          "input_skill": "Dependency Injection",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Dependency Injection",
      "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": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Offline-first",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Offline-first",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Architecture",
          "skill_nature": "PATTERN",
          "sub_category": "offline_first_architecture",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cOffline-first\u201d is a specific product/architecture pattern; unlikely to be confused with other distinct catalog skills in typical JDs."
          },
          "context_keywords": {
            "context_keywords": [
              "service worker",
              "local storage",
              "PWA",
              "cache strategy",
              "data synchronization",
              "background sync",
              "offline capabilities",
              "progressive enhancement",
              "user experience",
              "network resilience",
              "event-driven",
              "data persistence",
              "API fallback",
              "client-side rendering",
              "sync conflicts"
            ]
          },
          "maturity": {
            "confidence": 0.78,
            "maturity": "emerging",
            "reasoning": "Appears increasingly in mobile/PWA job descriptions and product docs, but JD volume is still far below mainstream architecture skills like REST or cloud-native."
          },
          "skill_id": "offline-first",
          "vendor_license": {
            "confidence": 0.9,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Patterns for building apps that continue working without reliable network access and later reconcile state. This covers local persistence, sync, conflict handling, and resilient UX, which is exactly what offline-first mobile features require.",
            "exemplar_skills": [
              "Offline-first",
              "local persistence",
              "sync queues",
              "conflict resolution",
              "optimistic updates",
              "cached reads",
              "deferred writes"
            ],
            "in_scope": "Offline-first, local persistence, sync queues, conflict resolution, optimistic updates, cached reads, deferred writes, sync status UX, retry on reconnect, data reconciliation",
            "name": "Offline-First App Architecture",
            "out_of_scope": "Pure online API request handling, server-side synchronization jobs, authentication flows, UI styling, background analytics collection",
            "overlap_flags": [
              {
                "reason": "Offline-first apps still integrate with APIs, but this dimension focuses on resilient local-first behavior rather than request/response shaping.",
                "with_dim_id": "api-integration-and-data-fetching",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Engineer"
              },
              {
                "reason": "Background sync and reconnect handling often depend on lifecycle hooks, but lifecycle management is broader than offline-first data flow.",
                "with_dim_id": "background-execution-and-lifecycle",
                "with_dim_name": null,
                "with_role": "Hybrid Mobile Developer, Ios engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Offline-first",
          "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": "offline-first"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "client-server-architecture",
            "distributed-systems",
            "event-driven-architecture",
            "layered-architecture",
            "redux",
            "indexeddb",
            "localstorage",
            "backfills"
          ],
          "requires": [],
          "skill_id": "offline-first",
          "suppress_on_match": []
        },
        "skill_id": "offline-first",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "Offline-first",
          "reasoning": "Offline-first is fundamentally a system-shape pattern for how applications are designed to operate with local-first behavior and later synchronization, so it fits the Architecture category.",
          "skill_id": "offline-first",
          "subtype": "offline_first_architecture",
          "type": "Architecture"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "response caching",
          "alias_type": "CANONICAL",
          "id": 1921,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "response caching",
        "id": 1285,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "response-caching",
        "sub_category_id": 1010,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Latency and Cost Optimization",
            "id": 205,
            "rationale": "Techniques for making AI features fast and affordable enough for production use. This cluster is coherent because model choice, prompt length, caching, batching, and routing directly affect user experience and unit economics.",
            "slug": "latency-and-cost-optimization",
            "source": "db"
          },
          "input_skill": "Caching",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 13,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Caching",
      "matched_via": "embedding_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": "Screen Navigation and State",
            "id": 83,
            "rationale": "Patterns for moving users through app flows and keeping client state consistent across screens, refreshes, and app transitions. This is central to feature work because iOS engineers own the in-app request flow and UI logic.",
            "slug": "screen-navigation-and-state",
            "source": "db"
          },
          "input_skill": "Sync",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Screen Navigation and State",
            "id": 83,
            "rationale": "Patterns for moving users through app flows and keeping client state consistent across screens, refreshes, and app transitions. This is central to feature work because iOS engineers own the in-app request flow and UI logic.",
            "slug": "screen-navigation-and-state",
            "source": "db"
          },
          "input_skill": "Sync",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Sync",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Tool",
          "skill_nature": "TOOL",
          "sub_category": "file_synchronization_tool",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": true,
            "confused_with": [
              "sync-aws",
              "sync-database"
            ],
            "reasoning": "\u201cSync\u201d is a generic term in JDs and can refer to different sync tools or concepts (e.g., AWS sync services or database/data synchronization) beyond file sync."
          },
          "context_keywords": {
            "context_keywords": [
              "file transfer",
              "real-time sync",
              "cloud storage",
              "data backup",
              "version control",
              "collaboration tools",
              "synchronization protocols",
              "file sharing",
              "network latency",
              "data integrity",
              "multi-device support",
              "offline access",
              "incremental sync",
              "user permissions",
              "conflict resolution"
            ]
          },
          "maturity": {
            "confidence": 0.78,
            "maturity": "niche",
            "reasoning": "\u201cSync\u201d as a file synchronization tool shows low JD volume and limited GitHub/community activity compared with mainstream DevOps tools; it\u2019s used in specialized workflows rather than broadly requested in hiring."
          },
          "skill_id": "sync",
          "vendor_license": {
            "confidence": 0.9,
            "license": "proprietary",
            "vendor": "Microsoft",
            "year_introduced": 2001
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Patterns for moving users through app flows and keeping client state consistent across screens and app lifecycle events. Sync belongs here when it refers to keeping UI state, local models, and remote data aligned in a mobile app.",
            "exemplar_skills": [
              "Sync",
              "state synchronization",
              "Flutter state management",
              "provider",
              "bloc",
              "cubit",
              "screen state passing"
            ],
            "in_scope": "Sync, state synchronization, screen-to-screen state passing, local UI state, shared app state, refresh and rehydration flows, Flutter state management, provider updates, bloc/cubit state propagation",
            "name": "Screen Navigation and State",
            "out_of_scope": "Backend database replication, distributed data sync protocols, offline-first conflict resolution engines, server-side job orchestration, authentication/session token storage",
            "overlap_flags": [
              {
                "reason": "Sync often depends on fetching and reconciling remote API responses with client state.",
                "with_dim_id": "api-integration-and-data-fetching",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Engineer"
              },
              {
                "reason": "Some sync flows surface validation or retry behavior during user submissions and recovery.",
                "with_dim_id": "form-validation-and-error-recovery",
                "with_dim_name": null,
                "with_role": "Frontend Engineer"
              }
            ],
            "tentative_id": "screen-navigation-and-state"
          },
          {
            "description": "Patterns for moving users through app flows and keeping client state consistent across screens, refreshes, and app transitions. This is central to feature work because iOS engineers own the in-app request flow and UI logic.",
            "exemplar_skills": [
              "Screen Navigation and State"
            ],
            "in_scope": "Skills, tools, and practices that belong under Screen Navigation and State for the target role, including items implied by the dimension rationale.",
            "name": "Screen Navigation and State",
            "out_of_scope": "Adjacent clusters explicitly not owned by Screen Navigation and State, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "screen-navigation-and-state"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Sync",
          "placement_confidence": 0.92,
          "primary_dimension": "screen-navigation-and-state",
          "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": "sync"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "backfills",
            "rollback-rehearsal",
            "pagination",
            "context-management",
            "localstorage",
            "indexeddb",
            "redux",
            "api"
          ],
          "requires": [],
          "skill_id": "sync",
          "suppress_on_match": []
        },
        "skill_id": "sync",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.88,
          "name": "Sync",
          "reasoning": "Sync is best treated as a user-operated software utility rather than a hosted environment or code package, so it fits the Tool rule.",
          "skill_id": "sync",
          "subtype": "file_synchronization_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": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Secure Storage",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Secure Storage",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "secure_storage",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cSecure Storage\u201d is a broad, distinct concept and is unlikely to be confused with another specific catalog skill in typical JDs."
          },
          "context_keywords": {
            "context_keywords": [
              "encryption",
              "key management",
              "data integrity",
              "access control",
              "cloud storage",
              "tokenization",
              "compliance",
              "data at rest",
              "data in transit",
              "secure vault",
              "multi-factor authentication",
              "audit trails",
              "zero trust",
              "secure backup",
              "privacy regulations"
            ]
          },
          "maturity": {
            "confidence": 0.86,
            "maturity": "well_known",
            "reasoning": "Commonly required in JDs for mobile/backend roles (e.g., keychain/keystore, encrypted secrets, KMS); broad vendor docs and cloud security guidance show it as a standard practice, not a niche tool."
          },
          "skill_id": "secure-storage",
          "vendor_license": {
            "confidence": 1.0,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Security practices for storing sensitive data at rest on a device or in a backend storage layer. This fits the target skill because it covers protecting secrets, credentials, and private app data from unauthorized access, extraction, and leakage.",
            "exemplar_skills": [
              "Secure Storage",
              "Keychain",
              "Android Keystore",
              "Encrypted SharedPreferences",
              "Secure Enclave",
              "File encryption",
              "Database encryption"
            ],
            "in_scope": "Secure Storage, encrypted local storage, keychain, keystore, secure enclave, encrypted shared preferences, file encryption, database encryption, secret storage, token persistence, at-rest protection",
            "name": "Secure Storage",
            "out_of_scope": "Authentication and Session Handling, network transport security, API request signing, UI form validation, cloud object storage administration, which belong to identity, networking, or cloud platform dimensions",
            "overlap_flags": [
              {
                "reason": "Credential and token storage often overlaps with login/session management, but this dimension owns the secure persistence layer rather than the auth flow itself.",
                "with_dim_id": "authentication-and-session-handling",
                "with_dim_name": null,
                "with_role": "Android Engineer, Frontend Engineer, Full Stack Engineer, Hybrid Mobile Developer, Ios engineer"
              },
              {
                "reason": "Access controls and identity boundaries can govern stored secrets, but this dimension focuses on how data is protected once stored.",
                "with_dim_id": "identity-and-access-architecture",
                "with_dim_name": null,
                "with_role": "Cloud Architect"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Secure Storage",
          "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": "secure-storage"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "aws-s3",
            "cloud"
          ],
          "related_to": [
            "api-security",
            "jwt",
            "database-administration",
            "systems-administration",
            "artifact-logging",
            "model-supply-chain-security"
          ],
          "requires": [],
          "skill_id": "secure-storage",
          "suppress_on_match": []
        },
        "skill_id": "secure-storage",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Domain: ruled out \u2014 it is too narrow and abstract to be an industry/problem-space body of knowledge.",
            "Methodology: ruled out \u2014 it does not describe a process or way of working."
          ],
          "confidence": 0.88,
          "name": "Secure Storage",
          "reasoning": "Secure Storage is best treated as a Concept because it names a security knowledge unit about protecting stored data rather than a specific product, protocol, or methodology.",
          "skill_id": "secure-storage",
          "subtype": "secure_storage",
          "type": "Concept"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Networking and API Integration",
            "id": 84,
            "rationale": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
            "slug": "networking-and-api-integration",
            "source": "db"
          },
          "input_skill": "Sockets",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Sockets",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Protocol",
          "skill_nature": "PROTOCOL",
          "sub_category": "network_socket_api",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cSockets\u201d in a JD typically refers to network socket programming/APIs, not another distinct catalog skill."
          },
          "context_keywords": {
            "context_keywords": [
              "TCP",
              "UDP",
              "socket programming",
              "bind",
              "listen",
              "accept",
              "send",
              "recv",
              "select",
              "poll",
              "non-blocking",
              "socket options",
              "address family",
              "socket types",
              "network protocols",
              "client-server model"
            ]
          },
          "maturity": {
            "confidence": 0.96,
            "maturity": "well_known",
            "reasoning": "Core OS/networking API used across backend and systems roles; appears routinely in job descriptions for network programming and is foundational in Python, Java, C/C++, and Go ecosystems."
          },
          "skill_id": "sockets",
          "vendor_license": {
            "confidence": 0.95,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Client-side network communication over sockets, including connection setup, message exchange, and handling low-level transport behavior. Sockets belong here because they are the primitive used beneath higher-level HTTP and API clients.",
            "exemplar_skills": [
              "Sockets",
              "TCP sockets",
              "UDP sockets",
              "socket programming",
              "connection lifecycle",
              "socket timeouts",
              "socket error handling"
            ],
            "in_scope": "Sockets, TCP sockets, UDP sockets, socket connections, connection lifecycle, send/receive loops, socket timeouts, socket buffering, socket error handling, socket-based client communication",
            "name": "Socket-Based Networking",
            "out_of_scope": "HTTP request/response APIs, REST client libraries, GraphQL clients, WebSocket application protocols, server-side routing, UI state synchronization",
            "overlap_flags": [
              {
                "reason": "Socket work can underpin API clients, but this dimension is broader and owns request/response integration patterns.",
                "with_dim_id": "api-integration-and-data-fetching",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Engineer"
              }
            ],
            "tentative_id": "networking-and-api-integration"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Sockets",
          "placement_confidence": 0.92,
          "primary_dimension": "networking-and-api-integration",
          "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": "sockets"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "websockets",
            "api",
            "client-server-architecture",
            "distributed-systems",
            "network-operations",
            "api-security",
            "openapi"
          ],
          "requires": [],
          "skill_id": "sockets",
          "suppress_on_match": []
        },
        "skill_id": "sockets",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "Sockets",
          "reasoning": "Sockets are a communication interface for exchanging data between processes, so by the Protocol rule they fit Protocol rather than a tool or library.",
          "skill_id": "sockets",
          "subtype": "network_socket_api",
          "type": "Protocol"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Background Execution and Lifecycle",
            "id": 87,
            "rationale": "App lifecycle handling and deferred work mechanisms that keep iOS behavior reliable when the app is backgrounded, suspended, or relaunched. This is important for sync, refresh, and user-visible continuity.",
            "slug": "background-execution-and-lifecycle",
            "source": "db"
          },
          "input_skill": "Push Notifications",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Background Execution and Lifecycle",
            "id": 87,
            "rationale": "App lifecycle handling and deferred work mechanisms that keep iOS behavior reliable when the app is backgrounded, suspended, or relaunched. This is important for sync, refresh, and user-visible continuity.",
            "slug": "background-execution-and-lifecycle",
            "source": "db"
          },
          "input_skill": "Push Notifications",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Push Notifications",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Service",
          "skill_nature": "CLOUD_SERVICE",
          "sub_category": "notification_service",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cPush Notifications\u201d is a specific, common product/feature term and is unlikely to be confused with other distinct catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "APNs",
              "Firebase Cloud Messaging",
              "web push",
              "service workers",
              "notification payload",
              "user engagement",
              "opt-in",
              "delivery tracking",
              "scheduling",
              "rich notifications",
              "A/B testing",
              "notification center",
              "background updates",
              "user segmentation",
              "analytics"
            ]
          },
          "maturity": {
            "confidence": 0.93,
            "maturity": "well_known",
            "reasoning": "Common in mobile/web JDs and supported by major vendors (APNs, FCM, Web Push); broad hiring-pipeline staple for user engagement and lifecycle messaging."
          },
          "skill_id": "push-notifications",
          "vendor_license": {
            "confidence": 0.8,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "App lifecycle and deferred-work mechanisms that let mobile apps receive, process, and present events while backgrounded or relaunched. Push notifications belong here because they are tightly coupled to app wake-up behavior, background handling, and user-visible delivery timing.",
            "exemplar_skills": [
              "Push Notifications",
              "APNs",
              "silent push notifications",
              "notification payload handling",
              "background fetch",
              "notification permissions",
              "background task scheduling"
            ],
            "in_scope": "Push Notifications, APNs registration, notification payload handling, background fetch, silent pushes, app wake on notification, notification permissions, lifecycle callbacks, background task scheduling",
            "name": "Background App Delivery and Lifecycle",
            "out_of_scope": "In-app messaging UI, server-side notification fanout, analytics event pipelines, email/SMS delivery, foreground screen navigation, which belong to messaging, backend, or navigation dimensions",
            "overlap_flags": [
              {
                "reason": "Notification taps often deep-link into app flows, so delivery behavior can overlap with navigation concerns.",
                "with_dim_id": "screen-navigation-and-state",
                "with_dim_name": null,
                "with_role": "Android Engineer, Full Stack Engineer, Hybrid Mobile Developer, Ios engineer"
              },
              {
                "reason": "Notification rollout and targeting may be controlled by release flags, but that is a separate product-shipping concern.",
                "with_dim_id": "feature-flags-and-release-control",
                "with_dim_name": null,
                "with_role": "Full Stack Engineer"
              }
            ],
            "tentative_id": "background-execution-and-lifecycle"
          },
          {
            "description": "App lifecycle handling and deferred work mechanisms that keep iOS behavior reliable when the app is backgrounded, suspended, or relaunched. This is important for sync, refresh, and user-visible continuity.",
            "exemplar_skills": [
              "Background Execution and Lifecycle"
            ],
            "in_scope": "Skills, tools, and practices that belong under Background Execution and Lifecycle for the target role, including items implied by the dimension rationale.",
            "name": "Background Execution and Lifecycle",
            "out_of_scope": "Adjacent clusters explicitly not owned by Background Execution and Lifecycle, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "background-execution-and-lifecycle"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Push Notifications",
          "placement_confidence": 0.92,
          "primary_dimension": "background-execution-and-lifecycle",
          "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": "push-notifications"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "service-workers",
            "event-driven-architecture",
            "websockets",
            "api",
            "api-security",
            "feature-flags",
            "automation-scripts",
            "network-operations"
          ],
          "requires": [],
          "skill_id": "push-notifications",
          "suppress_on_match": []
        },
        "skill_id": "push-notifications",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.88,
          "name": "Push Notifications",
          "reasoning": "Push Notifications is best treated as a hosted managed capability delivered by a platform rather than software you run yourself, matching the Service vs Platform rule.",
          "skill_id": "push-notifications",
          "subtype": "notification_service",
          "type": "Service"
        },
        "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": "Performance and Stability Tuning",
            "id": 92,
            "rationale": "Techniques for improving responsiveness, startup time, memory use, and overall app stability on iOS devices. This cluster is important because client performance directly affects user experience and release readiness.",
            "slug": "performance-and-stability-tuning",
            "source": "db"
          },
          "input_skill": "Image Caching",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Image Caching",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "caching_concept",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cImage Caching\u201d is a specific caching concept focused on images; unlikely to be confused with other distinct skills in typical JDs."
          },
          "context_keywords": {
            "context_keywords": [
              "cache invalidation",
              "CDN",
              "image optimization",
              "lazy loading",
              "browser caching",
              "cache hit ratio",
              "thumbnail generation",
              "asset management",
              "HTTP caching",
              "content delivery",
              "cache storage",
              "image preloading",
              "performance tuning",
              "data retrieval",
              "response time"
            ]
          },
          "maturity": {
            "confidence": 0.86,
            "maturity": "well_known",
            "reasoning": "Common performance topic in web/mobile JDs and docs; CDN/image optimization vendors like Cloudflare and Fastly prominently market image caching as a standard practice."
          },
          "skill_id": "image-caching",
          "vendor_license": {
            "confidence": 1.0,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Techniques for improving responsiveness, memory use, and perceived speed in client apps. Image caching belongs here because it reduces repeated decoding, network fetches, and UI jank when rendering images.",
            "exemplar_skills": [
              "Image Caching",
              "image decoding optimization",
              "memory optimization",
              "scroll performance tuning",
              "prefetching images",
              "lazy loading"
            ],
            "in_scope": "Image Caching, image decoding optimization, memory footprint reduction, startup latency reduction, scroll performance, frame drops, prefetching, lazy loading, bitmap reuse",
            "name": "App Performance Optimization",
            "out_of_scope": "Networking request construction, API pagination, authentication flows, screen routing, server-side caching, CDN configuration",
            "overlap_flags": [
              {
                "reason": "Image caching can be implemented alongside HTTP fetching and response handling, but the caching concern itself is primarily performance-oriented.",
                "with_dim_id": "networking-and-api-integration",
                "with_dim_name": null,
                "with_role": "Android Engineer, Hybrid Mobile Developer, Ios engineer"
              },
              {
                "reason": "Prefetching and warming image caches may involve lifecycle-aware work, but lifecycle management is not the core of this skill.",
                "with_dim_id": "background-execution-and-lifecycle",
                "with_dim_name": null,
                "with_role": "Hybrid Mobile Developer, Ios engineer"
              }
            ],
            "tentative_id": "performance-and-stability-tuning"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Image Caching",
          "placement_confidence": 0.92,
          "primary_dimension": "performance-and-stability-tuning",
          "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": "image-caching"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "localstorage",
            "aws-s3",
            "aws-ec2",
            "cloud",
            "context-management",
            "document-processing",
            "hybrid-retrieval",
            "artifact-logging"
          ],
          "requires": [],
          "skill_id": "image-caching",
          "suppress_on_match": []
        },
        "skill_id": "image-caching",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.91,
          "name": "Image Caching",
          "reasoning": "Image Caching is fundamentally a knowledge unit about storing and reusing images efficiently, so it fits the Concept category rather than a tool, datastore, or architecture.",
          "skill_id": "image-caching",
          "subtype": "caching_concept",
          "type": "Concept"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "profiling",
          "alias_type": "CANONICAL",
          "id": 188,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "profiling",
        "id": 51,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "profiling",
        "sub_category_id": 385,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Debugging and Performance Tuning",
            "id": 219,
            "rationale": "Feature-level troubleshooting and optimization across client-server interactions. Full stack engineers use this to diagnose latency, correctness, and reliability issues that span multiple layers.",
            "slug": "debugging-and-performance-tuning",
            "source": "db"
          },
          "input_skill": "Profiling",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Performance and Scalability Tuning",
            "id": 11,
            "rationale": "Techniques for improving throughput, latency, and resource efficiency in backend services. Focuses on profiling, concurrency, load behavior, and bottleneck elimination.",
            "slug": "performance-and-scalability-tuning",
            "source": "db"
          },
          "input_skill": "Profiling",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Profiling",
      "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": "API Integration and Data Fetching",
            "id": 127,
            "rationale": "Client-side integration with backend endpoints and third-party services, including request shaping, response handling, and synchronization with UI state. This is central to frontend work because most screens depend on remote data.",
            "slug": "api-integration-and-data-fetching",
            "source": "db"
          },
          "input_skill": "API Integration",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Engineer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Networking and API Integration",
            "id": 84,
            "rationale": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
            "slug": "networking-and-api-integration",
            "source": "db"
          },
          "input_skill": "API Integration",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cross-Platform App Languages",
            "id": 167,
            "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
            "slug": "cross-platform-app-languages",
            "source": "db"
          },
          "input_skill": "API Integration",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "API Integration and Data Fetching",
            "id": 127,
            "rationale": "Client-side integration with backend endpoints and third-party services, including request shaping, response handling, and synchronization with UI state. This is central to frontend work because most screens depend on remote data.",
            "slug": "api-integration-and-data-fetching",
            "source": "db"
          },
          "input_skill": "API Integration",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Engineer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Networking and API Integration",
            "id": 84,
            "rationale": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
            "slug": "networking-and-api-integration",
            "source": "db"
          },
          "input_skill": "API Integration",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cross-Platform App Languages",
            "id": 167,
            "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
            "slug": "cross-platform-app-languages",
            "source": "db"
          },
          "input_skill": "API Integration",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "API Integration",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "api_integration",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cAPI Integration\u201d is a specific, common phrase referring to connecting systems via APIs; it\u2019s unlikely to be confused with other distinct catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "REST",
              "SOAP",
              "OAuth",
              "JSON",
              "XML",
              "Webhooks",
              "API Gateway",
              "Postman",
              "Swagger",
              "GraphQL",
              "Microservices",
              "Endpoint",
              "Data Mapping",
              "Authentication",
              "Rate Limiting"
            ]
          },
          "maturity": {
            "confidence": 0.96,
            "maturity": "well_known",
            "reasoning": "API integration appears in a large share of software engineering JDs and is a standard requirement across backend, frontend, and platform roles; it is a core hiring-pipeline skill rather than a niche tool."
          },
          "skill_id": "api-integration",
          "vendor_license": {
            "confidence": 1.0,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [
          {
            "a_dim_id": "api-integration-and-data-fetching",
            "a_name": "API Integration and Data Fetching",
            "a_role": "__skill_focal__",
            "b_dim_id": "cross-platform-app-languages",
            "b_name": "Cross-Platform App Languages",
            "b_role": "__skill_focal__",
            "pair_kind": "intra_role",
            "reasoning": "Dim A covers client-side API consumption: request construction, response parsing, pagination, retries, timeout handling, JSON parsing, and third-party SDK endpoints. Its exemplars are API Integration, REST API consumption, GraphQL client integration, and JSON response parsing. Dim B covers the languages used to build shared cross-platform mobile app code, including hybrid app logic, UI behavior, and platform-specific branching. These are different skill clusters: networking/data-fetching vs language/platform implementation. career-track: no, because a senior API integration/client-data-fetching practitioner is not naturally a senior cross-platform mobile language engineer.",
            "similarity": 0.5710461624465892
          },
          {
            "a_dim_id": "api-integration-and-data-fetching",
            "a_name": "API Integration and Data Fetching",
            "a_role": "__skill_focal__",
            "b_dim_id": "networking-and-api-integration",
            "b_name": "Networking and API Integration",
            "b_role": "Ios engineer",
            "pair_kind": "cross_role",
            "reasoning": "Cross-role pair. career-track: no, because Dim A is broad client-side API/data-fetching across apps and third-party services, while Dim B is iOS-native networking for server-owned APIs. Dim A\u2019s exemplars include REST API consumption, GraphQL client integration, and Third-party service integration; Dim B\u2019s description centers on native screens and HTTP communication in iOS. Same surface wording, different day-to-day skill cluster.",
            "similarity": 0.6966828460138798
          },
          {
            "a_dim_id": "networking-and-api-integration",
            "a_name": "Networking and API Integration",
            "a_role": "__skill_focal__",
            "b_dim_id": "cross-platform-app-languages",
            "b_name": "Cross-Platform App Languages",
            "b_role": "__skill_focal__",
            "pair_kind": "intra_role",
            "reasoning": "Dim A is client-side networking/API consumption: HTTP requests, response parsing, retries, error handling, with exemplars like API Integration, REST API consumption, and GraphQL networking. Dim B is the language layer for shared cross-platform mobile development: implementing shared iOS/Android features, UI behavior, and platform-specific branching. career-track: no, because senior API/networking integration work does not naturally make someone a senior cross-platform app-language engineer; the daily skills and abstractions differ.",
            "similarity": 0.5518437016276186
          }
        ],
        "locked_dimensions": [
          {
            "description": "Client-side integration with backend and third-party APIs, including request construction, response parsing, error handling, and state synchronization. API Integration belongs here because it is the core skill of connecting an app to remote services and consuming their data reliably.",
            "exemplar_skills": [
              "API Integration",
              "REST API consumption",
              "GraphQL client integration",
              "HTTP request handling",
              "JSON response parsing",
              "Third-party service integration"
            ],
            "in_scope": "API Integration, REST API calls, GraphQL queries, request/response mapping, pagination, retries, timeout handling, JSON parsing, third-party SDK endpoints, client-side data synchronization",
            "name": "API Integration and Data Fetching",
            "out_of_scope": "Server-side API design, controller implementation, database schema design, authentication backend logic, UI layout and styling, local-only business rules",
            "overlap_flags": [
              {
                "reason": "Both cover client HTTP communication; this dimension is the broader catalog fit for app-side API consumption, while the other is iOS-specific networking.",
                "with_dim_id": "networking-and-api-integration",
                "with_dim_name": null,
                "with_role": "Android Engineer, Hybrid Mobile Developer, Ios engineer"
              },
              {
                "reason": "Backend API implementation can overlap with integration work, but that dimension owns server-side endpoints rather than client consumption.",
                "with_dim_id": "web-application-frameworks",
                "with_dim_name": null,
                "with_role": "Backend Engineer, Full Stack Engineer"
              }
            ],
            "tentative_id": "api-integration-and-data-fetching"
          },
          {
            "description": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. API Integration fits here because it is a direct example of consuming remote services from a mobile client.",
            "exemplar_skills": [
              "API Integration",
              "HTTP networking",
              "REST API consumption",
              "GraphQL networking",
              "Response parsing",
              "Retry handling"
            ],
            "in_scope": "API Integration, HTTP clients, REST endpoints, GraphQL networking, request headers, response decoding, retry logic, offline sync, error mapping",
            "name": "Networking and API Integration",
            "out_of_scope": "Server-side routing and controllers, database access, authentication infrastructure, UI state management, build tooling",
            "overlap_flags": [
              {
                "reason": "Both describe client-side API consumption; this catalog entry is the more general mobile networking cluster.",
                "with_dim_id": "api-integration-and-data-fetching",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Engineer"
              }
            ],
            "tentative_id": "networking-and-api-integration"
          },
          {
            "description": "Languages used to implement shared mobile features across iOS and Android from a common codebase. API Integration can appear here when the skill is expressed through shared Flutter/Dart app code that calls remote services.",
            "exemplar_skills": [
              "API Integration",
              "Dart HTTP client usage",
              "Flutter repository pattern",
              "JSON serialization",
              "Cross-platform service layer",
              "Remote data fetching"
            ],
            "in_scope": "API Integration in Flutter, Dart HTTP clients, shared service layers, JSON serialization, repository patterns, cross-platform data fetching",
            "name": "Cross-Platform App Languages",
            "out_of_scope": "Native iOS-only networking APIs, Android-only Retrofit/OkHttp setup, backend API design, UI styling, platform build pipelines",
            "overlap_flags": [
              {
                "reason": "Client API consumption is the primary meaning; this overlap applies when the implementation is specifically in shared cross-platform code.",
                "with_dim_id": "api-integration-and-data-fetching",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Engineer"
              },
              {
                "reason": "Both cover mobile client networking, but this one is narrower to shared cross-platform implementation.",
                "with_dim_id": "networking-and-api-integration",
                "with_dim_name": null,
                "with_role": "Android Engineer, Hybrid Mobile Developer, Ios engineer"
              }
            ],
            "tentative_id": "cross-platform-app-languages"
          },
          {
            "description": "Client-side integration with backend endpoints and third-party services, including request shaping, response handling, and synchronization with UI state. This is central to frontend work because most screens depend on remote data.",
            "exemplar_skills": [
              "API Integration and Data Fetching"
            ],
            "in_scope": "Skills, tools, and practices that belong under API Integration and Data Fetching for the target role, including items implied by the dimension rationale.",
            "name": "API Integration and Data Fetching",
            "out_of_scope": "Adjacent clusters explicitly not owned by API Integration and Data Fetching, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "api-integration-and-data-fetching"
          },
          {
            "description": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
            "exemplar_skills": [
              "Networking and API Integration"
            ],
            "in_scope": "Skills, tools, and practices that belong under Networking and API Integration for the target role, including items implied by the dimension rationale.",
            "name": "Networking and API Integration",
            "out_of_scope": "Adjacent clusters explicitly not owned by Networking and API Integration, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "networking-and-api-integration"
          },
          {
            "description": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
            "exemplar_skills": [
              "Cross-Platform App Languages"
            ],
            "in_scope": "Skills, tools, and practices that belong under Cross-Platform App Languages for the target role, including items implied by the dimension rationale.",
            "name": "Cross-Platform App Languages",
            "out_of_scope": "Adjacent clusters explicitly not owned by Cross-Platform App Languages, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "cross-platform-app-languages"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "API Integration",
          "placement_confidence": 0.92,
          "primary_dimension": "api-integration-and-data-fetching",
          "reasoning": "Deterministic JD placement: locked_dimensions has 6 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [
            "networking-and-api-integration",
            "cross-platform-app-languages"
          ],
          "skill_id": "api-integration"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "api"
          ],
          "related_to": [
            "fetch-api",
            "axios",
            "apollo-client",
            "api-security",
            "enterprise-saas",
            "azure-app-service",
            "azure-functions"
          ],
          "requires": [
            "openapi",
            "oauth2"
          ],
          "skill_id": "api-integration",
          "suppress_on_match": []
        },
        "skill_id": "api-integration",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "API Integration",
          "reasoning": "API Integration is fundamentally a knowledge unit about connecting systems via APIs, so it fits the Concept category rather than a tool, protocol, or methodology.",
          "skill_id": "api-integration",
          "subtype": "api_integration",
          "type": "Concept"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:43-\u003e6"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Authentication and Session Handling",
            "id": 86,
            "rationale": "Client-side identity flows and secure session management used to sign users in and keep them authenticated. This includes token handling, login UX, and protecting secrets on device.",
            "slug": "authentication-and-session-handling",
            "source": "db"
          },
          "input_skill": "Authentication",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Frontend Engineer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Authentication and Session Handling",
            "id": 86,
            "rationale": "Client-side identity flows and secure session management used to sign users in and keep them authenticated. This includes token handling, login UX, and protecting secrets on device.",
            "slug": "authentication-and-session-handling",
            "source": "db"
          },
          "input_skill": "Authentication",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Frontend Engineer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Authentication",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "authentication",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cAuthentication\u201d is a distinct security concept; typical JDs won\u2019t confuse it with other catalog skills like authorization, sessions, or OAuth-specific items."
          },
          "context_keywords": {
            "context_keywords": [
              "OAuth",
              "JWT",
              "SAML",
              "OpenID Connect",
              "multi-factor authentication",
              "session management",
              "identity provider",
              "access tokens",
              "authorization",
              "secure cookies",
              "single sign-on",
              "user credentials",
              "token validation",
              "LDAP",
              "PKI"
            ]
          },
          "maturity": {
            "confidence": 0.96,
            "maturity": "well_known",
            "reasoning": "Authentication is a core requirement in most software JDs and security roles; it appears broadly across job postings and vendor docs for OAuth/OIDC, SSO, and MFA rather than as a niche specialty."
          },
          "skill_id": "authentication",
          "vendor_license": {
            "confidence": 1.0,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Client-side identity flows and secure session management used to sign users in and keep them authenticated. Authentication belongs here because mobile apps commonly implement login, token refresh, logout, and protected-session UX.",
            "exemplar_skills": [
              "Authentication",
              "login flows",
              "token refresh",
              "secure session management",
              "OAuth sign-in",
              "biometric re-authentication"
            ],
            "in_scope": "Authentication, sign-in flows, sign-up flows, token storage, token refresh, logout, session expiry handling, biometric re-authentication, OAuth sign-in, SSO handoff, secure credential persistence, Authentication",
            "name": "Authentication and Session Handling",
            "out_of_scope": "Authorization policy, role-based access control, backend identity provider configuration, server-side token issuance, network transport security",
            "overlap_flags": [
              {
                "reason": "Both cover identity concepts, but this dimension is focused on client-side app session handling rather than enterprise access architecture.",
                "with_dim_id": "identity-and-access-architecture",
                "with_dim_name": null,
                "with_role": "Cloud Architect"
              },
              {
                "reason": "Authentication often rides on API calls, but the core skill here is identity/session flow rather than general request/response handling.",
                "with_dim_id": "networking-and-api-integration",
                "with_dim_name": null,
                "with_role": "Android Engineer, Hybrid Mobile Developer, Ios engineer"
              }
            ],
            "tentative_id": "authentication-and-session-handling"
          },
          {
            "description": "Client-side identity flows and secure session management used to sign users in and keep them authenticated. This includes token handling, login UX, and protecting secrets on device.",
            "exemplar_skills": [
              "Authentication and Session Handling"
            ],
            "in_scope": "Skills, tools, and practices that belong under Authentication and Session Handling for the target role, including items implied by the dimension rationale.",
            "name": "Authentication and Session Handling",
            "out_of_scope": "Adjacent clusters explicitly not owned by Authentication and Session Handling, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "authentication-and-session-handling"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Authentication",
          "placement_confidence": 0.92,
          "primary_dimension": "authentication-and-session-handling",
          "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": "authentication"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "api-security",
            "api",
            "oauth2",
            "openid-connect",
            "jwt",
            "openapi",
            "express",
            "angular"
          ],
          "requires": [],
          "skill_id": "authentication",
          "suppress_on_match": []
        },
        "skill_id": "authentication",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.96,
          "name": "Authentication",
          "reasoning": "Authentication is a named knowledge unit about verifying identity, so by the Concept vs Methodology rule it is a Concept rather than a tool, protocol, or standard.",
          "skill_id": "authentication",
          "subtype": "authentication",
          "type": "Concept"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:41-\u003e2"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "pagination",
          "alias_type": "CANONICAL",
          "id": 1189,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "pagination",
        "id": 684,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "pagination",
        "sub_category_id": 1048,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "API Design and Contracts",
            "id": 3,
            "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
            "slug": "api-design-and-contracts",
            "source": "db"
          },
          "input_skill": "Pagination",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "API Integration and Data Fetching",
            "id": 127,
            "rationale": "Client-side integration with backend endpoints and third-party services, including request shaping, response handling, and synchronization with UI state. This is central to frontend work because most screens depend on remote data.",
            "slug": "api-integration-and-data-fetching",
            "source": "db"
          },
          "input_skill": "Pagination",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Engineer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Pagination",
      "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": "idempotency",
          "alias_type": "CANONICAL",
          "id": 1464,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "idempotency",
        "id": 902,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "idempotency",
        "sub_category_id": 1053,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "API Design and Contracts",
            "id": 3,
            "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
            "slug": "api-design-and-contracts",
            "source": "db"
          },
          "input_skill": "Idempotency",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Delivery Workflow Reliability",
            "id": 159,
            "rationale": "Practices for keeping build and release pipelines dependable under failure, load, and change. This cluster is coherent because the role is judged on reducing flaky releases, broken promotions, and recovery time.",
            "slug": "delivery-workflow-reliability",
            "source": "db"
          },
          "input_skill": "Idempotency",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Idempotency",
      "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": "Unit Testing",
          "alias_type": "CANONICAL",
          "id": 865,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "Unit Testing",
        "id": 517,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "unit-testing",
        "sub_category_id": 44,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Unit Testing",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Unit Testing",
      "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": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Widget Testing",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Widget Testing",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Methodology",
          "skill_nature": "METHODOLOGY",
          "sub_category": "testing_methodology",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cWidget Testing\u201d is a specific testing methodology term and is unlikely to be confused with other distinct catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "unit tests",
              "integration tests",
              "test cases",
              "test automation",
              "test frameworks",
              "mocking",
              "assertions",
              "test-driven development",
              "continuous integration",
              "bug tracking",
              "regression testing",
              "quality assurance",
              "test coverage",
              "performance testing",
              "user acceptance testing"
            ]
          },
          "maturity": {
            "confidence": 0.84,
            "maturity": "well_known",
            "reasoning": "Widget testing is a common QA practice in Flutter/React Native JDs and docs, often listed alongside unit and integration testing; no sunset signal, and it remains a standard hiring-pipeline skill."
          },
          "skill_id": "widget-testing",
          "vendor_license": {
            "confidence": 1.0,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Testing individual UI widgets in isolation to verify rendering, interactions, and state changes. In Flutter, this covers the standard widget test layer used to validate component behavior without running a full device app.",
            "exemplar_skills": [
              "Widget Testing",
              "Flutter widget tests",
              "pumpWidget",
              "find.byType",
              "tester.tap",
              "expect(find.text(...))",
              "golden tests"
            ],
            "in_scope": "Widget Testing, Flutter widget tests, pumping widgets, finding widgets, simulating taps and gestures, asserting text and layout, testing stateful widget behavior, mocking dependencies for widgets, golden/widget snapshot checks",
            "name": "Widget Testing",
            "out_of_scope": "Unit testing pure Dart business logic, integration tests on real devices or emulators, end-to-end app flows, backend API testing, those belong to separate testing or platform dimensions",
            "overlap_flags": [
              {
                "reason": "Widget tests often verify navigation and state transitions, which can overlap with app flow and state management concerns.",
                "with_dim_id": "screen-navigation-and-state",
                "with_dim_name": null,
                "with_role": "Android Engineer, Full Stack Engineer, Hybrid Mobile Developer, Ios engineer"
              },
              {
                "reason": "Widget tests frequently cover validation messages and recovery UI, which may also be modeled under form behavior.",
                "with_dim_id": "form-validation-and-error-recovery",
                "with_dim_name": null,
                "with_role": "Frontend Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Widget Testing",
          "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": "widget-testing"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "ui-development",
            "react-query",
            "next-js",
            "vue",
            "ant-design",
            "material-ui",
            "tailwind-css",
            "radix-ui"
          ],
          "requires": [],
          "skill_id": "widget-testing",
          "suppress_on_match": []
        },
        "skill_id": "widget-testing",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "Widget Testing",
          "reasoning": "Widget Testing is fundamentally a way of working for validating UI components, so by the Concept vs Methodology rule it fits Methodology rather than a tool or framework.",
          "skill_id": "widget-testing",
          "subtype": "testing_methodology",
          "type": "Methodology"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "integration testing",
          "alias_type": "CANONICAL",
          "id": 193,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "integration testing",
        "id": 56,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "integration-testing",
        "sub_category_id": 44,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Testing and Quality Assurance",
            "id": 12,
            "rationale": "Backend-specific test strategies used to validate service behavior and integration points. Covers automated test layers, contract checks, fixtures, and regression prevention.",
            "slug": "testing-and-quality-assurance",
            "source": "db"
          },
          "input_skill": "Integration Testing",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Integration Testing",
      "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": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Golden Tests",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Golden Tests",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Methodology",
          "skill_nature": "METHODOLOGY",
          "sub_category": "testing_methodology",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "EMERGING"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cGolden Tests\u201d is a specific testing methodology (golden/master snapshots) and is unlikely to be confused with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "test-driven development",
              "regression testing",
              "test automation",
              "behavior-driven development",
              "unit tests",
              "integration tests",
              "test coverage",
              "mocking",
              "assertions",
              "continuous integration",
              "quality assurance",
              "test strategy",
              "code reviews",
              "test cases",
              "test frameworks"
            ]
          },
          "maturity": {
            "confidence": 0.78,
            "maturity": "emerging",
            "reasoning": "Appears in growing numbers of engineering JDs and testing guides, especially for snapshot/regression testing in UI and compiler/tooling work, but it is not yet a universal hiring staple."
          },
          "skill_id": "golden-tests",
          "vendor_license": {
            "confidence": 0.95,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Testing approach that verifies UI output against approved reference images or rendered artifacts. Golden tests catch unintended visual regressions in widgets, screens, and component rendering, which fits Flutter mobile work directly.",
            "exemplar_skills": [
              "Golden Tests",
              "snapshot testing",
              "visual regression testing",
              "Flutter golden_toolkit",
              "widget screenshot baselines",
              "pixel diffing"
            ],
            "in_scope": "Golden Tests, snapshot testing, image diffing, widget render baselines, approved UI screenshots, Flutter golden_toolkit, flutter_test golden assertions, pixel regression checks, visual regression review",
            "name": "Snapshot and Golden Testing",
            "out_of_scope": "Unit tests for business logic, integration tests against APIs, end-to-end device automation, performance profiling, which belong to other testing or quality dimensions",
            "overlap_flags": [
              {
                "reason": "Golden tests often cover full screens and navigation states, so there can be overlap with screen-flow testing.",
                "with_dim_id": "screen-navigation-and-state",
                "with_dim_name": null,
                "with_role": "Android Engineer, Full Stack Engineer, Hybrid Mobile Developer, Ios engineer"
              },
              {
                "reason": "Form and error-state screenshots may be validated by golden tests, but the underlying validation logic belongs elsewhere.",
                "with_dim_id": "form-validation-and-error-recovery",
                "with_dim_name": null,
                "with_role": "Frontend Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Golden Tests",
          "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": "golden-tests"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "failure-analysis",
            "evaluation",
            "rollback-rehearsal",
            "canary-releases",
            "runbooks",
            "automation-scripts"
          ],
          "requires": [],
          "skill_id": "golden-tests",
          "suppress_on_match": []
        },
        "skill_id": "golden-tests",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.88,
          "name": "Golden Tests",
          "reasoning": "Golden Tests are a way of working for verifying outputs against approved snapshots, so by the Concept vs Methodology rule they are best classified as a methodology rather than a tool or framework.",
          "skill_id": "golden-tests",
          "subtype": "testing_methodology",
          "type": "Methodology"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Mocks",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Mocks",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "test_double_concept",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cMocks\u201d in a JD typically refers to test doubles (mocking) rather than another catalog skill."
          },
          "context_keywords": {
            "context_keywords": [
              "stubbing",
              "fakes",
              "test doubles",
              "unit testing",
              "dependency injection",
              "mocking framework",
              "Mockito",
              "Jest",
              "RSpec",
              "test isolation",
              "behavior verification",
              "assertions",
              "spy",
              "verification",
              "test-driven development"
            ]
          },
          "maturity": {
            "confidence": 0.93,
            "maturity": "well_known",
            "reasoning": "Mocks are a standard test-double concept in mainstream unit-testing JDs and docs across Python, Java, JavaScript, and .NET; they\u2019re widely used in CI/testing stacks rather than a niche tool."
          },
          "skill_id": "mocks",
          "vendor_license": {
            "confidence": 1.0,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Techniques for isolating code under test by replacing dependencies with mocks, stubs, spies, and fakes. This skill belongs here because it is specifically about controlling behavior and verifying interactions in unit and component tests.",
            "exemplar_skills": [
              "Mocks",
              "Mock objects",
              "Stubs",
              "Spies",
              "Fakes",
              "Test doubles",
              "Dependency injection for testing"
            ],
            "in_scope": "Mocks, mock objects, stubs, spies, fakes, test doubles, dependency isolation, interaction verification, behavior setup, call assertions",
            "name": "Test Doubles and Mocking",
            "out_of_scope": "Unit test frameworks, integration testing, end-to-end testing, UI automation, those belong to broader testing or framework dimensions",
            "overlap_flags": [
              {
                "reason": "Mocking is often used when testing navigation and state logic, but the dimension itself is about the test technique rather than app flow patterns.",
                "with_dim_id": "screen-navigation-and-state",
                "with_dim_name": null,
                "with_role": "Android Engineer, Full Stack Engineer, Hybrid Mobile Developer, Ios engineer"
              },
              {
                "reason": "API clients are frequently mocked in tests, but that dimension covers production integration behavior, not test isolation methods.",
                "with_dim_id": "api-integration-and-data-fetching",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Mocks",
          "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": "mocks"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "evaluation",
            "rollback-rehearsal",
            "hibernate",
            "active-record",
            "mvc",
            "jwt",
            "ocr",
            "model-cards"
          ],
          "requires": [],
          "skill_id": "mocks",
          "suppress_on_match": []
        },
        "skill_id": "mocks",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "Mocks",
          "reasoning": "Mocks are a named testing concept describing a kind of test double, so they fit the Concept category rather than Tool or Framework.",
          "skill_id": "mocks",
          "subtype": "test_double_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": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Fakes",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Fakes",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "testing_double_concept",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cFakes\u201d in testing typically refers to test doubles (fake implementations), not a commonly conflated separate catalog skill."
          },
          "context_keywords": {
            "context_keywords": [
              "test doubles",
              "mocks",
              "stubs",
              "spy",
              "dependency injection",
              "unit testing",
              "integration testing",
              "behavior verification",
              "test isolation",
              "mocking frameworks",
              "fake objects",
              "assertions",
              "test-driven development",
              "code coverage",
              "automated testing"
            ]
          },
          "maturity": {
            "confidence": 0.86,
            "maturity": "niche",
            "reasoning": "Fakes are a testing-double concept used in unit tests, but job postings rarely list \"Fakes\" explicitly; JDs more often mention mocks/stubs or specific frameworks like Mockito, Sinon, or unittest.mock."
          },
          "skill_id": "fakes",
          "vendor_license": {
            "confidence": 1.0,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Techniques for replacing real dependencies with controlled stand-ins during testing. This includes fakes, mocks, stubs, and spies used to isolate behavior, make tests deterministic, and verify interactions.",
            "exemplar_skills": [
              "Fakes",
              "Mocks",
              "Stubs",
              "Spies",
              "Test Doubles",
              "Dependency Injection",
              "In-Memory Repositories",
              "Unit Testing"
            ],
            "in_scope": "Fakes, mocks, stubs, spies, test doubles, dependency injection for tests, in-memory implementations, controlled service replacements, deterministic unit tests",
            "name": "Test Doubles and Mock Objects",
            "out_of_scope": "Production feature flags and rollout controls, UI navigation state, backend API integration, performance profiling, end-to-end test infrastructure owned by QA tooling",
            "overlap_flags": [
              {
                "reason": "Both can replace real behavior, but feature flags control production exposure while fakes are test-time stand-ins.",
                "with_dim_id": "feature-flags-and-release-control",
                "with_dim_name": null,
                "with_role": "Full Stack Engineer"
              },
              {
                "reason": "Client API work may use fakes in tests, but the dimension itself is about real endpoint integration rather than test doubles.",
                "with_dim_id": "api-integration-and-data-fetching",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Fakes",
          "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": "fakes"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "backfills",
            "failure-analysis",
            "rollback-rehearsal",
            "model-cards",
            "model-supply-chain-security",
            "mlflow",
            "langsmith",
            "langfuse"
          ],
          "requires": [],
          "skill_id": "fakes",
          "suppress_on_match": []
        },
        "skill_id": "fakes",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "Fakes",
          "reasoning": "Fakes are a named testing double pattern, so by the Concept vs Methodology rule they are a knowledge unit rather than a tool or framework.",
          "skill_id": "fakes",
          "subtype": "testing_double_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": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "A/B Testing",
          "llm_role": null,
          "roles_from_db": []
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Systems Programming",
            "id": 166,
            "rationale": "Systems programming covers low-level software development where performance, memory safety, and direct control over resources matter. Rust fits here because it is commonly used for OS-adjacent services, infrastructure components, and other performance-sensitive systems code.",
            "slug": "d_init_02",
            "source": "db"
          },
          "input_skill": "A/B Testing",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "A/B Testing",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Methodology",
          "skill_nature": "METHODOLOGY",
          "sub_category": "experiment_design_methodology",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "A/B Testing is a specific experimentation methodology; typical JDs won\u2019t confuse it with other distinct skills in the catalog."
          },
          "context_keywords": {
            "context_keywords": [
              "split testing",
              "conversion rate",
              "statistical significance",
              "control group",
              "variant",
              "hypothesis testing",
              "user segmentation",
              "multivariate testing",
              "sample size",
              "data analysis",
              "performance metrics",
              "click-through rate",
              "landing page",
              "experiment framework",
              "result interpretation"
            ]
          },
          "maturity": {
            "confidence": 0.93,
            "maturity": "well_known",
            "reasoning": "Commonly listed in product, growth, and analytics job descriptions; major platforms like Optimizely and Google Optimize popularized it, and it remains a standard experimentation practice across SaaS and e-commerce."
          },
          "skill_id": "a-b-testing",
          "vendor_license": {
            "confidence": 0.95,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Designing controlled experiments to compare variants and measure causal impact. This covers A/B testing because it is the core method for assigning users to variants, defining success metrics, and interpreting results.",
            "exemplar_skills": [
              "A/B Testing",
              "experiment design",
              "randomization",
              "hypothesis testing",
              "statistical significance",
              "confidence intervals",
              "power analysis",
              "sample size calculation",
              "uplift analysis"
            ],
            "in_scope": "A/B Testing, experiment design, control and treatment groups, randomization, hypothesis testing, statistical significance, confidence intervals, power analysis, sample size planning, metric selection, guardrail metrics, uplift measurement",
            "name": "Experiment Design and Analysis",
            "out_of_scope": "Experiment logging and run comparison for ML models, offline model evaluation, feature store validation, product analytics dashboards, causal inference beyond simple online experiments",
            "overlap_flags": [
              {
                "reason": "Both involve experiments and metrics, but that dimension is centered on ML run tracking and model evaluation rather than product-facing controlled tests.",
                "with_dim_id": "experiment-tracking-and-evaluation",
                "with_dim_name": null,
                "with_role": "ML Engineer, ML Ops Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          },
          {
            "description": "Measurement practices used to evaluate product changes through user behavior data. A/B Testing belongs here when the focus is on tracking conversion, retention, engagement, and other product metrics across variants.",
            "exemplar_skills": [
              "A/B Testing",
              "conversion tracking",
              "funnel analysis",
              "retention analysis",
              "event instrumentation",
              "cohort analysis",
              "metric definition",
              "experiment dashboards"
            ],
            "in_scope": "A/B Testing, conversion tracking, funnel analysis, retention metrics, engagement metrics, event instrumentation, cohort analysis, metric definition, experiment dashboards, product KPI measurement",
            "name": "Product Analytics Measurement",
            "out_of_scope": "Model evaluation metrics, experiment orchestration for ML pipelines, backend service monitoring, release toggles and rollout mechanics",
            "overlap_flags": [
              {
                "reason": "Feature flags often gate experiments, but this dimension is about measuring outcomes rather than controlling rollout exposure.",
                "with_dim_id": "feature-flags-and-release-control",
                "with_dim_name": null,
                "with_role": "Full Stack Engineer"
              }
            ],
            "tentative_id": "d_init_02"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "A/B Testing",
          "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": "a-b-testing"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "evaluation",
            "data-drift-detection",
            "anomaly-detection",
            "blue-green-deployment",
            "feature-flags",
            "rollback-rehearsal",
            "failure-analysis",
            "profiling"
          ],
          "requires": [],
          "skill_id": "a-b-testing",
          "suppress_on_match": []
        },
        "skill_id": "a-b-testing",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.97,
          "name": "A/B Testing",
          "reasoning": "A/B Testing is a way of working for comparing variants through controlled experiments, so by the Concept vs Methodology rule it is a Methodology.",
          "skill_id": "a-b-testing",
          "subtype": "experiment_design_methodology",
          "type": "Methodology"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "feature flags",
          "alias_type": "CANONICAL",
          "id": 205,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "feature flags",
        "id": 64,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "feature-flags",
        "sub_category_id": 1054,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Deployment Automation and Rollouts",
            "id": 151,
            "rationale": "Mechanisms for promoting releases across environments, coordinating approvals, and executing safe rollouts or rollbacks. This is central to the role because it covers the path from merged code to production deployment.",
            "slug": "deployment-automation-and-rollouts",
            "source": "db"
          },
          "input_skill": "Feature Flags",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Deployment and Runtime Configuration",
            "id": 13,
            "rationale": "Configuration and release artifacts that control how backend services run in environments. Includes environment variables, manifests, feature flags, and release-safe configuration management.",
            "slug": "deployment-and-runtime-configuration",
            "source": "db"
          },
          "input_skill": "Feature Flags",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Feature Flags and Release Control",
            "id": 218,
            "rationale": "Mechanisms for safely shipping incremental product changes and controlling exposure. This cluster is coherent because full stack engineers frequently coordinate feature rollout, experimentation, and rollback across layers.",
            "slug": "feature-flags-and-release-control",
            "source": "db"
          },
          "input_skill": "Feature Flags",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Release Readiness and Browser Compatibility",
            "id": 129,
            "rationale": "Practices for verifying frontend changes across browsers, environments, and release stages. This cluster is coherent because frontend engineers often own the last-mile quality checks before shipping UI changes.",
            "slug": "release-readiness-and-browser-compatibility",
            "source": "db"
          },
          "input_skill": "Feature Flags",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Engineer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Feature Flags",
      "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": "CI/CD",
          "alias_type": "CANONICAL",
          "id": 1826,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "CI/CD",
        "id": 1190,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "ci-cd",
        "sub_category_id": 900,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD Pipeline Platforms",
            "id": 150,
            "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
            "slug": "ci-cd-pipeline-platforms",
            "source": "db"
          },
          "input_skill": "CI/CD",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD for Machine Learning",
            "id": 56,
            "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
            "slug": "ci-cd-for-machine-learning",
            "source": "db"
          },
          "input_skill": "CI/CD",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "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": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Crash Reporting and Observability",
            "id": 91,
            "rationale": "Client-side telemetry used to diagnose crashes, hangs, performance regressions, and field issues in iOS apps. iOS engineers use these tools to understand production behavior and prioritize fixes.",
            "slug": "crash-reporting-and-observability",
            "source": "db"
          },
          "input_skill": "Crash Analytics",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Crash Reporting and Observability",
            "id": 91,
            "rationale": "Client-side telemetry used to diagnose crashes, hangs, performance regressions, and field issues in iOS apps. iOS engineers use these tools to understand production behavior and prioritize fixes.",
            "slug": "crash-reporting-and-observability",
            "source": "db"
          },
          "input_skill": "Crash Analytics",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Crash Analytics",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Tool",
          "skill_nature": "TOOL",
          "sub_category": "crash_analytics_tool",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cCrash Analytics\u201d is a fairly specific term tied to crash reporting/diagnostics, not commonly confused with other distinct catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "bug tracking",
              "error reporting",
              "real-time monitoring",
              "user feedback",
              "data visualization",
              "mobile analytics",
              "session replay",
              "performance metrics",
              "root cause analysis",
              "event logging",
              "A/B testing",
              "analytics dashboard",
              "SDK integration",
              "user behavior",
              "crash logs"
            ]
          },
          "maturity": {
            "confidence": 0.9,
            "maturity": "well_known",
            "reasoning": "Crash analytics is a standard mobile/web observability requirement; tools like Firebase Crashlytics and Sentry appear frequently in job postings and vendor docs, indicating broad adoption."
          },
          "skill_id": "crash-analytics",
          "vendor_license": {
            "confidence": 0.9,
            "license": "proprietary",
            "vendor": "Firebase",
            "year_introduced": 2016
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [
          {
            "a_dim_id": "crash-reporting-and-observability",
            "a_name": "Crash Reporting and Observability",
            "a_role": "__skill_focal__",
            "b_dim_id": "crash-reporting-and-observability",
            "b_name": "Crash Reporting and Observability",
            "b_role": "Ios engineer",
            "pair_kind": "cross_role",
            "reasoning": "Same label, but A is a narrow mobile crash-telemetry cluster: crash reports, stack traces, symbolication, ANR/hang detection, breadcrumbs, release health dashboards, tools like Crashlytics/Sentry. B is broader iOS production debugging: crashes, hangs, performance regressions, and field issues in iOS apps. career-track: no, because a senior crash-reporting/telemetry specialist is not automatically a senior iOS performance/debugging engineer.",
            "similarity": 0.8582275699683802
          }
        ],
        "locked_dimensions": [
          {
            "description": "Client-side telemetry used to capture crashes, hangs, and stability signals from mobile apps in the field. Crash Analytics belongs here because it is used to diagnose failure patterns, prioritize fixes, and verify whether releases improve app stability.",
            "exemplar_skills": [
              "Crash Analytics",
              "Crashlytics",
              "Sentry",
              "Firebase Crashlytics",
              "symbolication",
              "stack trace analysis",
              "mobile crash reporting"
            ],
            "in_scope": "Crash Analytics, crash reports, stack traces, symbolication, fatal and non-fatal errors, ANR and hang detection, breadcrumbs, session context, device and OS metadata, release health dashboards, mobile telemetry SDKs",
            "name": "Crash Reporting and Observability",
            "out_of_scope": "Backend log aggregation, server tracing, infrastructure metrics, and cloud monitoring, which belong to platform observability dimensions; product analytics and user behavior funnels, which belong to analytics dimensions",
            "overlap_flags": [
              {
                "reason": "Crash analytics often feeds stability work, but this dimension owns the telemetry and diagnosis tooling rather than the optimization techniques themselves.",
                "with_dim_id": "performance-and-stability-tuning",
                "with_dim_name": null,
                "with_role": "Android Engineer, Ios engineer"
              },
              {
                "reason": "Both involve diagnosing failures, but that dimension focuses on operational triage for builds and deployments rather than client crash telemetry.",
                "with_dim_id": "observability-and-incident-triage",
                "with_dim_name": null,
                "with_role": "DevOps Engineer"
              }
            ],
            "tentative_id": "crash-reporting-and-observability"
          },
          {
            "description": "Client-side telemetry used to diagnose crashes, hangs, performance regressions, and field issues in iOS apps. iOS engineers use these tools to understand production behavior and prioritize fixes.",
            "exemplar_skills": [
              "Crash Reporting and Observability"
            ],
            "in_scope": "Skills, tools, and practices that belong under Crash Reporting and Observability for the target role, including items implied by the dimension rationale.",
            "name": "Crash Reporting and Observability",
            "out_of_scope": "Adjacent clusters explicitly not owned by Crash Reporting and Observability, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "crash-reporting-and-observability"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Crash Analytics",
          "placement_confidence": 0.92,
          "primary_dimension": "crash-reporting-and-observability",
          "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": "crash-analytics"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "observability",
            "failure-analysis"
          ],
          "related_to": [
            "artifact-logging",
            "anomaly-detection",
            "data-drift-detection",
            "event-driven-architecture",
            "ai-infrastructure",
            "data-lakes"
          ],
          "requires": [],
          "skill_id": "crash-analytics",
          "suppress_on_match": []
        },
        "skill_id": "crash-analytics",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "Crash Analytics",
          "reasoning": "Crash Analytics is best treated as software you operate to inspect and diagnose app crashes, so by the Tool vs Platform rule it is a user-run tool rather than a hosted multi-tenant platform or a datastore.",
          "skill_id": "crash-analytics",
          "subtype": "crash_analytics_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": "Cross-Platform App Languages",
            "id": 167,
            "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
            "slug": "cross-platform-app-languages",
            "source": "db"
          },
          "input_skill": "Lazy Lists",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cross-Platform App Languages",
            "id": 167,
            "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
            "slug": "cross-platform-app-languages",
            "source": "db"
          },
          "input_skill": "Lazy Lists",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Lazy Lists",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "lazy_evaluation_lists",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cLazy Lists\u201d is a specific concept/subtype (lazy evaluation of lists) and is unlikely to be confused with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "streaming",
              "generator",
              "iterator",
              "yield",
              "functional programming",
              "comprehensions",
              "memory efficiency",
              "deferred execution",
              "lazy evaluation",
              "collections",
              "data pipelines",
              "asynchronous processing",
              "performance optimization",
              "data structures",
              "reactive programming"
            ]
          },
          "maturity": {
            "confidence": 0.84,
            "maturity": "niche",
            "reasoning": "Lazy lists appear in functional-language JDs and docs, but job postings rarely list them as a standalone requirement; market demand is mostly indirect via Haskell/Scala/F# roles rather than broad hiring pipelines."
          },
          "skill_id": "lazy-lists",
          "vendor_license": {
            "confidence": 0.95,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Languages and language features used to implement shared mobile app logic and UI in cross-platform frameworks. Lazy Lists belongs here because it is a language-level collection construct commonly used in Flutter/Dart code for deferred, on-demand item generation.",
            "exemplar_skills": [
              "Lazy Lists",
              "Dart",
              "Flutter",
              "Iterable generation",
              "Collection literals",
              "Functional iteration"
            ],
            "in_scope": "Lazy Lists, Dart language features, Flutter app code, collection literals, iterable generation, deferred item creation, list comprehensions, functional iteration patterns",
            "name": "Cross-Platform App Languages",
            "out_of_scope": "Flutter widgets and layout composition, state management patterns, navigation, networking, platform channels, native iOS/Android implementation details",
            "overlap_flags": [
              {
                "reason": "Lazy list usage often appears in UI flows, but this dimension owns navigation and state patterns rather than language-level collection behavior.",
                "with_dim_id": "screen-navigation-and-state",
                "with_dim_name": null,
                "with_role": "Android Engineer, Full Stack Engineer, Hybrid Mobile Developer, Ios engineer"
              },
              {
                "reason": "If lazy lists are used to drive route-driven UI, the navigation semantics still belong to routing rather than the list construct itself.",
                "with_dim_id": "client-routing-and-navigation",
                "with_dim_name": null,
                "with_role": "Frontend Engineer"
              }
            ],
            "tentative_id": "cross-platform-app-languages"
          },
          {
            "description": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
            "exemplar_skills": [
              "Cross-Platform App Languages"
            ],
            "in_scope": "Skills, tools, and practices that belong under Cross-Platform App Languages for the target role, including items implied by the dimension rationale.",
            "name": "Cross-Platform App Languages",
            "out_of_scope": "Adjacent clusters explicitly not owned by Cross-Platform App Languages, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "cross-platform-app-languages"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Lazy Lists",
          "placement_confidence": 0.92,
          "primary_dimension": "cross-platform-app-languages",
          "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": "lazy-lists"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "pagination",
            "localstorage",
            "redux",
            "layout-parsing",
            "backfills",
            "go",
            "python",
            "svelte"
          ],
          "requires": [],
          "skill_id": "lazy-lists",
          "suppress_on_match": []
        },
        "skill_id": "lazy-lists",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "Lazy Lists",
          "reasoning": "This is a knowledge unit about deferred evaluation of list elements, so by the Concept vs Methodology rule it is a Concept rather than a tool or architecture.",
          "skill_id": "lazy-lists",
          "subtype": "lazy_evaluation_lists",
          "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": "Networking and API Integration",
            "id": 84,
            "rationale": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
            "slug": "networking-and-api-integration",
            "source": "db"
          },
          "input_skill": "Reconnection Logic",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Networking and API Integration",
            "id": 84,
            "rationale": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
            "slug": "networking-and-api-integration",
            "source": "db"
          },
          "input_skill": "Reconnection Logic",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Reconnection Logic",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "connection_recovery_logic",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cReconnection Logic\u201d is a specific connection recovery concept; it\u2019s unlikely to be confused with other distinct catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "network resilience",
              "connection timeout",
              "failover",
              "retry mechanism",
              "session persistence",
              "heartbeat",
              "reconnection strategy",
              "error handling",
              "network latency",
              "API stability",
              "state management",
              "connection pooling",
              "timeout settings",
              "asynchronous recovery",
              "circuit breaker",
              "load balancing"
            ]
          },
          "maturity": {
            "confidence": 0.86,
            "maturity": "well_known",
            "reasoning": "Common requirement in JDs for WebSocket, gRPC, and mobile/networked apps; widely implemented in SDKs and client libraries as a standard resilience pattern."
          },
          "skill_id": "reconnection-logic",
          "vendor_license": {
            "confidence": 0.95,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [
          {
            "a_dim_id": "networking-and-api-integration",
            "a_name": "Networking and API Integration",
            "a_role": "__skill_focal__",
            "b_dim_id": "api-integration-and-data-fetching",
            "b_name": "API Integration and Data Fetching",
            "b_role": "Full Stack Engineer",
            "pair_kind": "cross_role",
            "reasoning": "Dim A is about client network resilience: retries, reconnection logic, timeout handling, offline-to-online recovery, and API client resilience. Dim B is about frontend data fetching and UI sync: request shaping, response handling, and synchronization with UI state. A senior in A is not naturally a senior in B; the daily work differs (transport/session recovery vs screen data wiring).",
            "similarity": 0.6601642071202465
          }
        ],
        "locked_dimensions": [
          {
            "description": "Client-side communication with backend services, including request construction, response parsing, retries, and recovery from transient failures. Reconnection logic belongs here because it governs how an app restores network sessions and resumes API traffic after disconnects.",
            "exemplar_skills": [
              "Reconnection Logic",
              "HTTP retries",
              "Socket reconnects",
              "Backoff strategies",
              "Network error handling",
              "Offline recovery"
            ],
            "in_scope": "Reconnection Logic, HTTP request retries, socket reconnects, timeout handling, offline-to-online recovery, response parsing, request backoff, network error handling, API client resilience",
            "name": "Networking and API Integration",
            "out_of_scope": "Screen navigation, UI state restoration, authentication token refresh flows, server-side load balancing, transport-layer protocol design",
            "overlap_flags": [
              {
                "reason": "Reconnect behavior often depends on app lifecycle events such as backgrounding, suspension, and relaunch.",
                "with_dim_id": "background-execution-and-lifecycle",
                "with_dim_name": null,
                "with_role": "Hybrid Mobile Developer, Ios engineer"
              },
              {
                "reason": "Aggressive reconnect loops can affect responsiveness, battery use, and overall app stability.",
                "with_dim_id": "performance-and-stability-tuning",
                "with_dim_name": null,
                "with_role": "Android Engineer, Ios engineer"
              }
            ],
            "tentative_id": "networking-and-api-integration"
          },
          {
            "description": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
            "exemplar_skills": [
              "Networking and API Integration"
            ],
            "in_scope": "Skills, tools, and practices that belong under Networking and API Integration for the target role, including items implied by the dimension rationale.",
            "name": "Networking and API Integration",
            "out_of_scope": "Adjacent clusters explicitly not owned by Networking and API Integration, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "networking-and-api-integration"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Reconnection Logic",
          "placement_confidence": 0.92,
          "primary_dimension": "networking-and-api-integration",
          "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": "reconnection-logic"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "network-operations",
            "client-server-architecture",
            "distributed-systems"
          ],
          "related_to": [
            "failure-analysis",
            "rollback-rehearsal",
            "event-driven-architecture",
            "context-management",
            "anomaly-detection",
            "wireguard",
            "axios",
            "redux"
          ],
          "requires": [],
          "skill_id": "reconnection-logic",
          "suppress_on_match": []
        },
        "skill_id": "reconnection-logic",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.92,
          "name": "Reconnection Logic",
          "reasoning": "This is a named technical knowledge unit about handling dropped connections, so it fits the Concept category rather than a tool, framework, or methodology.",
          "skill_id": "reconnection-logic",
          "subtype": "connection_recovery_logic",
          "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": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Screen Sharing",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Screen Sharing",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "SoftSkill",
          "skill_nature": "PRACTICE",
          "sub_category": "collaboration_skill",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cScreen Sharing\u201d is a specific collaboration feature and isn\u2019t commonly confused with another distinct catalog skill."
          },
          "context_keywords": {
            "context_keywords": [
              "video conferencing",
              "remote collaboration",
              "virtual meetings",
              "screen capture",
              "presentation tools",
              "real-time sharing",
              "collaborative editing",
              "file sharing",
              "webinars",
              "digital whiteboard",
              "team collaboration",
              "online workshops",
              "interactive sessions",
              "remote support",
              "user interface sharing"
            ]
          },
          "maturity": {
            "confidence": 0.93,
            "maturity": "well_known",
            "reasoning": "Common collaboration requirement in remote-work JDs and standard in Zoom/Teams/Meet usage; no successor or sunset signal, just broadly expected in hiring pipelines."
          },
          "skill_id": "screen-sharing",
          "vendor_license": {
            "confidence": 0.95,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Client-side and platform-level support for sharing a device or app screen during live calls or collaboration sessions. This covers starting, stopping, and managing the shared view, which is distinct from general navigation or media playback.",
            "exemplar_skills": [
              "Screen Sharing",
              "screen capture",
              "share start/stop controls",
              "live preview of shared content",
              "permission prompts for capture",
              "platform share APIs"
            ],
            "in_scope": "Screen Sharing, screen capture, share start/stop controls, selecting app window or full display, permission prompts for capture, live preview of shared content, pause/resume sharing, platform share APIs, in-call sharing UX",
            "name": "Screen Sharing",
            "out_of_scope": "Video conferencing transport, audio routing, chat messaging, remote desktop control, recording and playback, these belong to communication or media dimensions rather than the sharing surface itself",
            "overlap_flags": [
              {
                "reason": "Sharing flows often require screen-level state transitions, but the core skill is capture and presentation rather than navigation logic.",
                "with_dim_id": "screen-navigation-and-state",
                "with_dim_name": null,
                "with_role": "Android Engineer, Full Stack Engineer, Hybrid Mobile Developer, Ios engineer"
              },
              {
                "reason": "A shared screen session may need lifecycle handling when the app backgrounds, but that is secondary to the sharing feature itself.",
                "with_dim_id": "background-execution-and-lifecycle",
                "with_dim_name": null,
                "with_role": "Hybrid Mobile Developer, Ios engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Screen Sharing",
          "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": "screen-sharing"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "client-server-architecture",
            "websockets",
            "systems-administration",
            "enterprise-saas",
            "ui-development",
            "context-management"
          ],
          "requires": [],
          "skill_id": "screen-sharing",
          "suppress_on_match": []
        },
        "skill_id": "screen-sharing",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.88,
          "name": "Screen Sharing",
          "reasoning": "Screen Sharing is best treated as a non-technical interpersonal capability used to collaborate and communicate visually, so it fits the SoftSkill category rather than a tool or platform.",
          "skill_id": "screen-sharing",
          "subtype": "collaboration_skill",
          "type": "SoftSkill"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Echo Cancellation",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Echo Cancellation",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "signal_processing_concept",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cEcho Cancellation\u201d is a specific signal-processing concept (AEC) with a clear meaning; unlikely to be confused with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "adaptive filtering",
              "noise reduction",
              "digital signal processing",
              "acoustic echo",
              "real-time processing",
              "feedback cancellation",
              "echo path estimation",
              "nonlinear echo cancellation",
              "speech enhancement",
              "audio processing",
              "signal-to-noise ratio",
              "multi-channel processing",
              "echo suppression",
              "voice over IP",
              "teleconferencing"
            ]
          },
          "maturity": {
            "confidence": 0.86,
            "maturity": "niche",
            "reasoning": "Appears in audio/VoIP and WebRTC roles, but JD volume is low versus general software skills; market demand is concentrated in telecom, conferencing, and DSP teams."
          },
          "skill_id": "echo-cancellation",
          "vendor_license": {
            "confidence": 1.0,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Techniques for analyzing and modifying audio streams to improve clarity, intelligibility, and user experience. Echo cancellation belongs here because it is a core speech/audio processing algorithm used in real-time communication and recording pipelines.",
            "exemplar_skills": [
              "Echo Cancellation",
              "Noise Suppression",
              "Automatic Gain Control",
              "Beamforming",
              "Voice Activity Detection",
              "Speech Enhancement"
            ],
            "in_scope": "Echo Cancellation, noise suppression, automatic gain control, beamforming, voice activity detection, audio filtering, speech enhancement, acoustic echo control, real-time audio DSP",
            "name": "Audio Signal Processing",
            "out_of_scope": "UI sound effects, music production mastering, microphone hardware design, network transport protocols, video codecs",
            "overlap_flags": [
              {
                "reason": "Audio processing implementations often need low-latency, CPU-efficient tuning, but the core skill is signal processing rather than general app performance.",
                "with_dim_id": "performance-and-stability-tuning",
                "with_dim_name": null,
                "with_role": "Android Engineer, Ios engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Echo Cancellation",
          "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": "echo-cancellation"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "concept-drift-detection",
            "ml-framework-internals",
            "event-driven-architecture",
            "hybrid-retrieval",
            "elk",
            "ocr"
          ],
          "requires": [],
          "skill_id": "echo-cancellation",
          "suppress_on_match": []
        },
        "skill_id": "echo-cancellation",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.93,
          "name": "Echo Cancellation",
          "reasoning": "Echo Cancellation is a named signal-processing knowledge unit, so by the Concept vs Methodology rule it is a Concept rather than a tool or architecture.",
          "skill_id": "echo-cancellation",
          "subtype": "signal_processing_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": "Performance and Stability Tuning",
            "id": 92,
            "rationale": "Techniques for improving responsiveness, startup time, memory use, and overall app stability on iOS devices. This cluster is important because client performance directly affects user experience and release readiness.",
            "slug": "performance-and-stability-tuning",
            "source": "db"
          },
          "input_skill": "Bandwidth Adaptation",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Performance and Stability Tuning",
            "id": 92,
            "rationale": "Techniques for improving responsiveness, startup time, memory use, and overall app stability on iOS devices. This cluster is important because client performance directly affects user experience and release readiness.",
            "slug": "performance-and-stability-tuning",
            "source": "db"
          },
          "input_skill": "Bandwidth Adaptation",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Bandwidth Adaptation",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "network_bandwidth_adaptation",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cBandwidth Adaptation\u201d is a specific network/performance concept; unlikely to be confused with other distinct catalog skills in typical JDs."
          },
          "context_keywords": {
            "context_keywords": [
              "dynamic adjustment",
              "throughput optimization",
              "adaptive bitrate",
              "network congestion",
              "QoS",
              "latency management",
              "streaming protocols",
              "buffering techniques",
              "packet loss",
              "bandwidth estimation",
              "real-time communication",
              "video streaming",
              "load balancing",
              "traffic shaping",
              "protocol adaptation"
            ]
          },
          "maturity": {
            "confidence": 0.84,
            "maturity": "niche",
            "reasoning": "Rarely appears as a standalone skill in job descriptions; market demand is usually folded into CDN/streaming or QoS roles rather than listed directly."
          },
          "skill_id": "bandwidth-adaptation",
          "vendor_license": {
            "confidence": 0.95,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [
          {
            "a_dim_id": "performance-and-stability-tuning",
            "a_name": "Performance and Stability Tuning",
            "a_role": "__skill_focal__",
            "b_dim_id": "performance-and-stability-tuning",
            "b_name": "Performance and Stability Tuning",
            "b_role": "Android Engineer",
            "pair_kind": "cross_role",
            "reasoning": "cross-role pair; Dim A is network/device-condition tuning (bandwidth adaptation, adaptive bitrate, payload reduction, network-aware loading), while Dim B is Android app performance/stability work (responsiveness, startup time, memory use, overall stability). A senior in A would not naturally be a senior in B. career-track: no, because adaptive media/request behavior is a different specialization from mobile app optimization and stability.",
            "similarity": 0.7099378956980971
          }
        ],
        "locked_dimensions": [
          {
            "description": "Techniques for keeping client apps responsive under changing device and network conditions. Bandwidth adaptation belongs here because it is a performance optimization that adjusts media, data, or request behavior to preserve smooth user experience.",
            "exemplar_skills": [
              "Bandwidth Adaptation",
              "adaptive bitrate streaming",
              "network-aware performance tuning",
              "payload optimization",
              "quality scaling",
              "latency reduction"
            ],
            "in_scope": "Bandwidth Adaptation, adaptive bitrate, request throttling, payload reduction, image/video quality scaling, network-aware loading, latency-sensitive UI behavior",
            "name": "Performance and Stability Tuning",
            "out_of_scope": "Authentication flows, screen navigation, offline sync architecture, backend API design, server-side caching, crash analytics",
            "overlap_flags": [
              {
                "reason": "Bandwidth adaptation often depends on request/response behavior and transport characteristics, but the core concern is performance tuning rather than API integration.",
                "with_dim_id": "networking-and-api-integration",
                "with_dim_name": null,
                "with_role": "Android Engineer, Hybrid Mobile Developer, Ios engineer"
              }
            ],
            "tentative_id": "performance-and-stability-tuning"
          },
          {
            "description": "Techniques for improving responsiveness, startup time, memory use, and overall app stability on iOS devices. This cluster is important because client performance directly affects user experience and release readiness.",
            "exemplar_skills": [
              "Performance and Stability Tuning"
            ],
            "in_scope": "Skills, tools, and practices that belong under Performance and Stability Tuning for the target role, including items implied by the dimension rationale.",
            "name": "Performance and Stability Tuning",
            "out_of_scope": "Adjacent clusters explicitly not owned by Performance and Stability Tuning, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "performance-and-stability-tuning"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Bandwidth Adaptation",
          "placement_confidence": 0.92,
          "primary_dimension": "performance-and-stability-tuning",
          "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": "bandwidth-adaptation"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "network-operations",
            "distributed-systems",
            "websockets",
            "api",
            "wireguard",
            "data-drift-detection",
            "pagination",
            "ai-infrastructure"
          ],
          "requires": [],
          "skill_id": "bandwidth-adaptation",
          "suppress_on_match": []
        },
        "skill_id": "bandwidth-adaptation",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.91,
          "name": "Bandwidth Adaptation",
          "reasoning": "Bandwidth Adaptation is a named technical principle about adjusting transmission behavior to available network capacity, so it fits the Concept rule rather than a tool, protocol, or methodology.",
          "skill_id": "bandwidth-adaptation",
          "subtype": "network_bandwidth_adaptation",
          "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": "Crash Reporting and Observability",
            "id": 91,
            "rationale": "Client-side telemetry used to diagnose crashes, hangs, performance regressions, and field issues in iOS apps. iOS engineers use these tools to understand production behavior and prioritize fixes.",
            "slug": "crash-reporting-and-observability",
            "source": "db"
          },
          "input_skill": "Recording",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Recording",
          "llm_role": null,
          "roles_from_db": []
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Crash Reporting and Observability",
            "id": 91,
            "rationale": "Client-side telemetry used to diagnose crashes, hangs, performance regressions, and field issues in iOS apps. iOS engineers use these tools to understand production behavior and prioritize fixes.",
            "slug": "crash-reporting-and-observability",
            "source": "db"
          },
          "input_skill": "Recording",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Recording",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concept",
          "skill_nature": "CONCEPT",
          "sub_category": "recording",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cRecording\u201d is too generic but, in this catalog context (crash-reporting-and-observability), it\u2019s unlikely to be confused with another specific skill name."
          },
          "context_keywords": {
            "context_keywords": [
              "audio capture",
              "screen recording",
              "video editing",
              "live streaming",
              "post-production",
              "audio mixing",
              "metadata tagging",
              "file formats",
              "codec",
              "sampling rate",
              "bitrate",
              "OBS Studio",
              "screen sharing",
              "recording software",
              "audio interface"
            ]
          },
          "maturity": {
            "confidence": 0.84,
            "maturity": "niche",
            "reasoning": "Job postings rarely list \"recording\" as a standalone skill; it appears mainly inside observability/telemetry stacks (e.g., session replay, screen/audio capture) rather than as a hiring-pipeline keyword."
          },
          "skill_id": "recording",
          "vendor_license": {
            "confidence": 1.0,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Client-side telemetry used to capture crashes, logs, and runtime signals from mobile apps. Recording belongs here when it refers to recording app events or diagnostics for later analysis and troubleshooting.",
            "exemplar_skills": [
              "Recording",
              "Crashlytics event logging",
              "Sentry breadcrumbs",
              "mobile telemetry capture",
              "performance trace recording"
            ],
            "in_scope": "Recording crash reports, recording logs and breadcrumbs, recording performance traces, recording user-session diagnostics, Recording, Firebase Crashlytics, Sentry, Datadog RUM, telemetry capture",
            "name": "Crash Reporting and Observability",
            "out_of_scope": "Experiment tracking for ML runs, audio/video media recording, server-side log aggregation, and release packaging are owned by other dimensions.",
            "overlap_flags": [
              {
                "reason": "Both involve telemetry, but this dimension is specifically about client/mobile app diagnostics rather than platform-wide monitoring.",
                "with_dim_id": "observability-and-operations",
                "with_dim_name": null,
                "with_role": "Cloud Architect"
              }
            ],
            "tentative_id": "crash-reporting-and-observability"
          },
          {
            "description": "Capture of audio, video, or screen content on a device or in an app. Recording fits here when the skill refers to producing media assets rather than diagnostics or telemetry.",
            "exemplar_skills": [
              "Recording",
              "audio recording",
              "video recording",
              "screen recording",
              "microphone capture"
            ],
            "in_scope": "Recording, audio recording, video recording, screen recording, microphone capture, camera capture, media file creation, playback-ready asset generation",
            "name": "Media Recording Capture",
            "out_of_scope": "Crash logs, analytics events, and debugging traces are excluded because those belong to observability and telemetry dimensions.",
            "overlap_flags": [
              {
                "reason": "The same word can mean diagnostic recording, but this dimension is only for media capture.",
                "with_dim_id": "crash-reporting-and-observability",
                "with_dim_name": null,
                "with_role": "Android Engineer, Hybrid Mobile Developer, Ios engineer"
              }
            ],
            "tentative_id": "d_init_01"
          },
          {
            "description": "Client-side telemetry used to diagnose crashes, hangs, performance regressions, and field issues in iOS apps. iOS engineers use these tools to understand production behavior and prioritize fixes.",
            "exemplar_skills": [
              "Crash Reporting and Observability"
            ],
            "in_scope": "Skills, tools, and practices that belong under Crash Reporting and Observability for the target role, including items implied by the dimension rationale.",
            "name": "Crash Reporting and Observability",
            "out_of_scope": "Adjacent clusters explicitly not owned by Crash Reporting and Observability, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "crash-reporting-and-observability"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Recording",
          "placement_confidence": 0.92,
          "primary_dimension": "crash-reporting-and-observability",
          "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": "recording"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "artifact-logging",
            "profiling",
            "runbooks",
            "evaluation",
            "document-processing",
            "rollback-rehearsal",
            "rollback-procedures"
          ],
          "requires": [],
          "skill_id": "recording",
          "suppress_on_match": []
        },
        "skill_id": "recording",
        "split_log": [],
        "typed": {
          "alternatives_considered": [
            "Tool: ruled out \u2014 no software product is specified.",
            "Methodology: ruled out \u2014 it is not a way of working or process.",
            "Format: ruled out \u2014 it does not define a data structure or wire format."
          ],
          "confidence": 0.78,
          "name": "Recording",
          "reasoning": "Recording is best treated as a named knowledge unit about capturing information, and it does not fit the Tool/Platform/Format rules because the input is just the concept name rather than a specific software or specification.",
          "skill_id": "recording",
          "subtype": "recording",
          "type": "Concept"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:42-\u003e3"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    }
  ],
  "unmatched_skills": [
    "iOS",
    "Android",
    "Riverpod",
    "Platform Channels",
    "Agora",
    "Twilio",
    "WebRTC",
    "Offline-first",
    "Sync",
    "Secure Storage",
    "Sockets",
    "Push Notifications",
    "Image Caching",
    "API Integration",
    "Authentication",
    "Widget Testing",
    "Golden Tests",
    "Mocks",
    "Fakes",
    "A/B Testing",
    "Crash Analytics",
    "Lazy Lists",
    "Reconnection Logic",
    "Screen Sharing",
    "Echo Cancellation",
    "Bandwidth Adaptation",
    "Recording"
  ]
}

API 3 — final-role-output

{
  "chosen_role": {
    "display_name": "Hybrid Mobile Developer",
    "id": 11,
    "rationale": "The primary skills focus on cross-platform development including Flutter, iOS, and Android, which align with the Hybrid Mobile Developer role.",
    "role_archetype": null,
    "slug": "hybrid-mobile-developer",
    "source": "db"
  },
  "chosen_role_resolution": "in_db",
  "final_input_skills": [
    {
      "skill": "Flutter",
      "tag": "in_db"
    },
    {
      "skill": "iOS",
      "tag": "new"
    },
    {
      "skill": "Android",
      "tag": "new"
    },
    {
      "skill": "Kotlin",
      "tag": "in_db"
    },
    {
      "skill": "Swift",
      "tag": "in_db"
    },
    {
      "skill": "Riverpod",
      "tag": "new"
    },
    {
      "skill": "Platform Channels",
      "tag": "new"
    },
    {
      "skill": "Agora",
      "tag": "new"
    },
    {
      "skill": "Twilio",
      "tag": "new"
    },
    {
      "skill": "WebRTC",
      "tag": "new"
    },
    {
      "skill": "MVVM",
      "tag": "in_db"
    },
    {
      "skill": "MVI",
      "tag": "in_db"
    },
    {
      "skill": "Clean Architecture",
      "tag": "in_db"
    },
    {
      "skill": "Dependency Injection",
      "tag": "in_db"
    },
    {
      "skill": "Offline-first",
      "tag": "new"
    },
    {
      "skill": "Caching",
      "tag": "in_db"
    },
    {
      "skill": "Sync",
      "tag": "new"
    },
    {
      "skill": "Secure Storage",
      "tag": "new"
    },
    {
      "skill": "Sockets",
      "tag": "new"
    },
    {
      "skill": "Push Notifications",
      "tag": "new"
    },
    {
      "skill": "Image Caching",
      "tag": "new"
    },
    {
      "skill": "Profiling",
      "tag": "in_db"
    },
    {
      "skill": "API Integration",
      "tag": "new"
    },
    {
      "skill": "Authentication",
      "tag": "new"
    },
    {
      "skill": "Pagination",
      "tag": "in_db"
    },
    {
      "skill": "Idempotency",
      "tag": "in_db"
    },
    {
      "skill": "Unit Testing",
      "tag": "in_db"
    },
    {
      "skill": "Widget Testing",
      "tag": "new"
    },
    {
      "skill": "Integration Testing",
      "tag": "in_db"
    },
    {
      "skill": "Golden Tests",
      "tag": "new"
    },
    {
      "skill": "Mocks",
      "tag": "new"
    },
    {
      "skill": "Fakes",
      "tag": "new"
    },
    {
      "skill": "A/B Testing",
      "tag": "new"
    },
    {
      "skill": "Feature Flags",
      "tag": "in_db"
    },
    {
      "skill": "CI/CD",
      "tag": "in_db"
    },
    {
      "skill": "Crash Analytics",
      "tag": "new"
    },
    {
      "skill": "Lazy Lists",
      "tag": "new"
    },
    {
      "skill": "Reconnection Logic",
      "tag": "new"
    },
    {
      "skill": "Screen Sharing",
      "tag": "new"
    },
    {
      "skill": "Echo Cancellation",
      "tag": "new"
    },
    {
      "skill": "Bandwidth Adaptation",
      "tag": "new"
    },
    {
      "skill": "Recording",
      "tag": "new"
    }
  ],
  "persistence": {
    "items": [
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "UI Frameworks and Rendering",
          "id": 115,
          "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
          "slug": "ui-frameworks-and-rendering",
          "source": "db"
        },
        "dimension_id": 115,
        "input_skill": "Flutter",
        "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": "Frontend Engineer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Full Stack Engineer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1041,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Kotlin and Java",
          "id": 161,
          "rationale": "Primary implementation languages for Android app features, platform integration, and client-side business logic. Android engineers use these languages to build screens, state flows, service adapters, and device-aware behavior.",
          "slug": "kotlin-and-java",
          "source": "db"
        },
        "dimension_id": 161,
        "input_skill": "Kotlin",
        "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": "Android Engineer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages",
          "id": 1,
          "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
          "slug": "programming-languages",
          "source": "db"
        },
        "dimension_id": 1,
        "input_skill": "Kotlin",
        "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": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Full Stack Engineer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Swift and Objective-C",
          "id": 81,
          "rationale": "Primary implementation languages for native iOS app features, platform APIs, and client-side business logic. This is the core coding surface for building and maintaining iPhone and iPad experiences.",
          "slug": "swift-and-objective-c",
          "source": "db"
        },
        "dimension_id": 81,
        "input_skill": "Swift",
        "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": "Ios engineer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 440,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "App Architecture and Dependency Injection",
          "id": 94,
          "rationale": "Structural patterns used to organize iOS code into testable, maintainable feature modules and layers. iOS engineers use these patterns to separate UI, state, and service integration concerns.",
          "slug": "app-architecture-and-dependency-injection",
          "source": "db"
        },
        "dimension_id": 94,
        "input_skill": "MVVM",
        "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": "Android Engineer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Ios engineer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 504,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Mobile Architecture and Code Organization",
          "id": 170,
          "rationale": "Structural patterns used to organize shared mobile code into maintainable modules, layers, and feature boundaries. Senior hybrid developers often own these patterns to keep cross-platform code testable and adaptable to platform exceptions.",
          "slug": "mobile-architecture-and-code-organization",
          "source": "db"
        },
        "dimension_id": 170,
        "input_skill": "MVVM",
        "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": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 504,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "App Architecture and Dependency Injection",
          "id": 94,
          "rationale": "Structural patterns used to organize iOS code into testable, maintainable feature modules and layers. iOS engineers use these patterns to separate UI, state, and service integration concerns.",
          "slug": "app-architecture-and-dependency-injection",
          "source": "db"
        },
        "dimension_id": 94,
        "input_skill": "MVI",
        "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": "Android Engineer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Ios engineer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 986,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Mobile Architecture and Code Organization",
          "id": 170,
          "rationale": "Structural patterns used to organize shared mobile code into maintainable modules, layers, and feature boundaries. Senior hybrid developers often own these patterns to keep cross-platform code testable and adaptable to platform exceptions.",
          "slug": "mobile-architecture-and-code-organization",
          "source": "db"
        },
        "dimension_id": 170,
        "input_skill": "Clean Architecture",
        "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": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1078,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "App Architecture and Dependency Injection",
          "id": 94,
          "rationale": "Structural patterns used to organize iOS code into testable, maintainable feature modules and layers. iOS engineers use these patterns to separate UI, state, and service integration concerns.",
          "slug": "app-architecture-and-dependency-injection",
          "source": "db"
        },
        "dimension_id": 94,
        "input_skill": "Dependency Injection",
        "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": "Android Engineer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Ios engineer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 88,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Application Architecture and Code Organization",
          "id": 220,
          "rationale": "Structural patterns for organizing product code into maintainable modules, layers, and feature boundaries. Full stack engineers need this to keep cross-layer feature work understandable as the product grows.",
          "slug": "application-architecture-and-code-organization",
          "source": "db"
        },
        "dimension_id": 220,
        "input_skill": "Dependency Injection",
        "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": "Full Stack Engineer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 88,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Mobile Architecture and Code Organization",
          "id": 170,
          "rationale": "Structural patterns used to organize shared mobile code into maintainable modules, layers, and feature boundaries. Senior hybrid developers often own these patterns to keep cross-platform code testable and adaptable to platform exceptions.",
          "slug": "mobile-architecture-and-code-organization",
          "source": "db"
        },
        "dimension_id": 170,
        "input_skill": "Dependency Injection",
        "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": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 88,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Service Architecture and Design Patterns",
          "id": 18,
          "rationale": "Reusable backend design patterns used to structure service code and boundaries. Covers layering, dependency management, domain modeling, and maintainable service organization.",
          "slug": "service-architecture-and-design-patterns",
          "source": "db"
        },
        "dimension_id": 18,
        "input_skill": "Dependency Injection",
        "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": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 88,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Latency and Cost Optimization",
          "id": 205,
          "rationale": "Techniques for making AI features fast and affordable enough for production use. This cluster is coherent because model choice, prompt length, caching, batching, and routing directly affect user experience and unit economics.",
          "slug": "latency-and-cost-optimization",
          "source": "db"
        },
        "dimension_id": 205,
        "input_skill": "Caching",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Skipped \u2014 no persistable v3 meta for new skill",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AI Engineer",
            "id": 13,
            "rationale": null,
            "role_archetype": null,
            "slug": "ai-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": false,
        "skill_id": null,
        "skill_tag": "new",
        "skipped_reason": "skill_not_in_db_v3_proposed"
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Debugging and Performance Tuning",
          "id": 219,
          "rationale": "Feature-level troubleshooting and optimization across client-server interactions. Full stack engineers use this to diagnose latency, correctness, and reliability issues that span multiple layers.",
          "slug": "debugging-and-performance-tuning",
          "source": "db"
        },
        "dimension_id": 219,
        "input_skill": "Profiling",
        "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": "Full Stack Engineer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 51,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Performance and Scalability Tuning",
          "id": 11,
          "rationale": "Techniques for improving throughput, latency, and resource efficiency in backend services. Focuses on profiling, concurrency, load behavior, and bottleneck elimination.",
          "slug": "performance-and-scalability-tuning",
          "source": "db"
        },
        "dimension_id": 11,
        "input_skill": "Profiling",
        "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": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 51,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "API Design and Contracts",
          "id": 3,
          "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
          "slug": "api-design-and-contracts",
          "source": "db"
        },
        "dimension_id": 3,
        "input_skill": "Pagination",
        "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": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Full Stack Engineer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 684,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "API Integration and Data Fetching",
          "id": 127,
          "rationale": "Client-side integration with backend endpoints and third-party services, including request shaping, response handling, and synchronization with UI state. This is central to frontend work because most screens depend on remote data.",
          "slug": "api-integration-and-data-fetching",
          "source": "db"
        },
        "dimension_id": 127,
        "input_skill": "Pagination",
        "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": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Full Stack Engineer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 684,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "API Design and Contracts",
          "id": 3,
          "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
          "slug": "api-design-and-contracts",
          "source": "db"
        },
        "dimension_id": 3,
        "input_skill": "Idempotency",
        "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": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Full Stack Engineer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 902,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Delivery Workflow Reliability",
          "id": 159,
          "rationale": "Practices for keeping build and release pipelines dependable under failure, load, and change. This cluster is coherent because the role is judged on reducing flaky releases, broken promotions, and recovery time.",
          "slug": "delivery-workflow-reliability",
          "source": "db"
        },
        "dimension_id": 159,
        "input_skill": "Idempotency",
        "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": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 902,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Unit Testing",
        "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": 517,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Testing and Quality Assurance",
          "id": 12,
          "rationale": "Backend-specific test strategies used to validate service behavior and integration points. Covers automated test layers, contract checks, fixtures, and regression prevention.",
          "slug": "testing-and-quality-assurance",
          "source": "db"
        },
        "dimension_id": 12,
        "input_skill": "Integration Testing",
        "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": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 56,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Deployment Automation and Rollouts",
          "id": 151,
          "rationale": "Mechanisms for promoting releases across environments, coordinating approvals, and executing safe rollouts or rollbacks. This is central to the role because it covers the path from merged code to production deployment.",
          "slug": "deployment-automation-and-rollouts",
          "source": "db"
        },
        "dimension_id": 151,
        "input_skill": "Feature Flags",
        "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": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 64,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Deployment and Runtime Configuration",
          "id": 13,
          "rationale": "Configuration and release artifacts that control how backend services run in environments. Includes environment variables, manifests, feature flags, and release-safe configuration management.",
          "slug": "deployment-and-runtime-configuration",
          "source": "db"
        },
        "dimension_id": 13,
        "input_skill": "Feature Flags",
        "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": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 64,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Feature Flags and Release Control",
          "id": 218,
          "rationale": "Mechanisms for safely shipping incremental product changes and controlling exposure. This cluster is coherent because full stack engineers frequently coordinate feature rollout, experimentation, and rollback across layers.",
          "slug": "feature-flags-and-release-control",
          "source": "db"
        },
        "dimension_id": 218,
        "input_skill": "Feature Flags",
        "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": "Full Stack Engineer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 64,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Release Readiness and Browser Compatibility",
          "id": 129,
          "rationale": "Practices for verifying frontend changes across browsers, environments, and release stages. This cluster is coherent because frontend engineers often own the last-mile quality checks before shipping UI changes.",
          "slug": "release-readiness-and-browser-compatibility",
          "source": "db"
        },
        "dimension_id": 129,
        "input_skill": "Feature Flags",
        "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": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 64,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CI/CD Pipeline Platforms",
          "id": 150,
          "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
          "slug": "ci-cd-pipeline-platforms",
          "source": "db"
        },
        "dimension_id": 150,
        "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": [
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1190,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CI/CD for Machine Learning",
          "id": 56,
          "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
          "slug": "ci-cd-for-machine-learning",
          "source": "db"
        },
        "dimension_id": 56,
        "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": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1190,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "iOS",
        "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": 1594,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Android",
        "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": 1595,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Screen Navigation and State",
          "id": 83,
          "rationale": "Patterns for moving users through app flows and keeping client state consistent across screens, refreshes, and app transitions. This is central to feature work because iOS engineers own the in-app request flow and UI logic.",
          "slug": "screen-navigation-and-state",
          "source": "db"
        },
        "dimension_id": 83,
        "input_skill": "Riverpod",
        "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": "Android Engineer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Full Stack Engineer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Ios engineer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1596,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Platform Channels",
        "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": 1597,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Agora",
        "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": 1598,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Twilio",
        "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": 1599,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "WebRTC",
        "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": 1600,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Offline-first",
        "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": 1601,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Screen Navigation and State",
          "id": 83,
          "rationale": "Patterns for moving users through app flows and keeping client state consistent across screens, refreshes, and app transitions. This is central to feature work because iOS engineers own the in-app request flow and UI logic.",
          "slug": "screen-navigation-and-state",
          "source": "db"
        },
        "dimension_id": 83,
        "input_skill": "Sync",
        "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": "Android Engineer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Full Stack Engineer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Ios engineer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1602,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Secure Storage",
        "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": 1603,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Networking and API Integration",
          "id": 84,
          "rationale": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
          "slug": "networking-and-api-integration",
          "source": "db"
        },
        "dimension_id": 84,
        "input_skill": "Sockets",
        "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": "Android Engineer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Ios engineer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1604,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Background Execution and Lifecycle",
          "id": 87,
          "rationale": "App lifecycle handling and deferred work mechanisms that keep iOS behavior reliable when the app is backgrounded, suspended, or relaunched. This is important for sync, refresh, and user-visible continuity.",
          "slug": "background-execution-and-lifecycle",
          "source": "db"
        },
        "dimension_id": 87,
        "input_skill": "Push Notifications",
        "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": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Ios engineer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1605,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Performance and Stability Tuning",
          "id": 92,
          "rationale": "Techniques for improving responsiveness, startup time, memory use, and overall app stability on iOS devices. This cluster is important because client performance directly affects user experience and release readiness.",
          "slug": "performance-and-stability-tuning",
          "source": "db"
        },
        "dimension_id": 92,
        "input_skill": "Image Caching",
        "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": "Android Engineer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Ios engineer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1606,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "API Integration and Data Fetching",
          "id": 127,
          "rationale": "Client-side integration with backend endpoints and third-party services, including request shaping, response handling, and synchronization with UI state. This is central to frontend work because most screens depend on remote data.",
          "slug": "api-integration-and-data-fetching",
          "source": "db"
        },
        "dimension_id": 127,
        "input_skill": "API Integration",
        "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": "Frontend Engineer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Full Stack Engineer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Networking and API Integration",
          "id": 84,
          "rationale": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
          "slug": "networking-and-api-integration",
          "source": "db"
        },
        "dimension_id": 84,
        "input_skill": "API Integration",
        "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": "Android Engineer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Ios engineer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cross-Platform App Languages",
          "id": 167,
          "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
          "slug": "cross-platform-app-languages",
          "source": "db"
        },
        "dimension_id": 167,
        "input_skill": "API Integration",
        "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": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Authentication and Session Handling",
          "id": 86,
          "rationale": "Client-side identity flows and secure session management used to sign users in and keep them authenticated. This includes token handling, login UX, and protecting secrets on device.",
          "slug": "authentication-and-session-handling",
          "source": "db"
        },
        "dimension_id": 86,
        "input_skill": "Authentication",
        "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": "Android Engineer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Frontend Engineer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Full Stack Engineer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Ios engineer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1608,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Widget Testing",
        "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": 1609,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Golden Tests",
        "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": 1610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Mocks",
        "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": 1611,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Fakes",
        "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": 1612,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "A/B Testing",
        "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": 1613,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Systems Programming",
          "id": 166,
          "rationale": "Systems programming covers low-level software development where performance, memory safety, and direct control over resources matter. Rust fits here because it is commonly used for OS-adjacent services, infrastructure components, and other performance-sensitive systems code.",
          "slug": "d_init_02",
          "source": "db"
        },
        "dimension_id": 166,
        "input_skill": "A/B Testing",
        "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": 1613,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Crash Reporting and Observability",
          "id": 91,
          "rationale": "Client-side telemetry used to diagnose crashes, hangs, performance regressions, and field issues in iOS apps. iOS engineers use these tools to understand production behavior and prioritize fixes.",
          "slug": "crash-reporting-and-observability",
          "source": "db"
        },
        "dimension_id": 91,
        "input_skill": "Crash Analytics",
        "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": "Android Engineer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Ios engineer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1614,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cross-Platform App Languages",
          "id": 167,
          "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
          "slug": "cross-platform-app-languages",
          "source": "db"
        },
        "dimension_id": 167,
        "input_skill": "Lazy Lists",
        "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": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1615,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Networking and API Integration",
          "id": 84,
          "rationale": "Client-side HTTP communication with backend services, including request construction, response parsing, retries, and error handling. iOS engineers use this to connect native screens to server-owned APIs.",
          "slug": "networking-and-api-integration",
          "source": "db"
        },
        "dimension_id": 84,
        "input_skill": "Reconnection Logic",
        "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": "Android Engineer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Ios engineer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1616,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Screen Sharing",
        "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": 1617,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Echo Cancellation",
        "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": 1618,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Performance and Stability Tuning",
          "id": 92,
          "rationale": "Techniques for improving responsiveness, startup time, memory use, and overall app stability on iOS devices. This cluster is important because client performance directly affects user experience and release readiness.",
          "slug": "performance-and-stability-tuning",
          "source": "db"
        },
        "dimension_id": 92,
        "input_skill": "Bandwidth Adaptation",
        "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": "Android Engineer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Ios engineer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1619,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Crash Reporting and Observability",
          "id": 91,
          "rationale": "Client-side telemetry used to diagnose crashes, hangs, performance regressions, and field issues in iOS apps. iOS engineers use these tools to understand production behavior and prioritize fixes.",
          "slug": "crash-reporting-and-observability",
          "source": "db"
        },
        "dimension_id": 91,
        "input_skill": "Recording",
        "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": "Android Engineer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Ios engineer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1620,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Recording",
        "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": 1620,
        "skill_tag": "in_db",
        "skipped_reason": null
      }
    ],
    "new_skills_created": 27,
    "role_dimension_saved": 0,
    "skill_dimension_saved": 31,
    "skipped": 1
  },
  "planner_output": null,
  "run_id": "4d35418a-3821-4fe3-8cbc-48910b959cf5"
}

LLM Calls

Every model call made for this run, in pipeline order. Click a card to see the model's response.

Loading…