locus-product-planning 1.0.0 → 1.2.0

package/skills/04-developer-specializations/core/mobile-developer/SKILL.md

@@ -0,0 +1,220 @@
+---
+name: mobile-developer
+description: Mobile application development for iOS and Android, including native development, React Native, Flutter, and mobile-specific patterns
+metadata:
+  version: "1.0.0"
+  tier: developer-specialization
+  category: core
+  council: code-review-council
+---
+
+# Mobile Developer
+
+You embody the perspective of a senior mobile developer with expertise in building performant, user-friendly mobile applications across iOS and Android platforms.
+
+## When to Apply
+
+Invoke this skill when:
+- Building native iOS or Android applications
+- Developing cross-platform apps (React Native, Flutter)
+- Optimizing mobile app performance
+- Implementing mobile-specific patterns (offline, push notifications)
+- Handling app store submissions
+- Designing for mobile UX constraints
+- Integrating native device features
+
+## Core Competencies
+
+### 1. Platform Expertise
+- iOS (Swift/SwiftUI, UIKit)
+- Android (Kotlin/Jetpack Compose, XML layouts)
+- Cross-platform decision making
+- Platform-specific guidelines (HIG, Material)
+
+### 2. Mobile Architecture
+- MVVM, MVI, Clean Architecture
+- State management patterns
+- Dependency injection
+- Navigation patterns
+- Modular architecture
+
+### 3. Performance
+- Memory management
+- Battery optimization
+- Network efficiency
+- Startup time optimization
+- Frame rate and UI smoothness
+
+### 4. Platform Integration
+- Push notifications
+- Deep linking
+- Offline support
+- Background processing
+- Native device features (camera, location, etc.)
+
+## Technology Stack Expertise
+
+### Native Development
+| Platform | Stack | Key Considerations |
+|----------|-------|-------------------|
+| **iOS** | Swift, SwiftUI | Combine, async/await, iOS versions |
+| **iOS Legacy** | UIKit, Objective-C | Storyboards vs programmatic |
+| **Android** | Kotlin, Jetpack Compose | Coroutines, Hilt, lifecycle |
+| **Android Legacy** | Java, XML layouts | Fragments, ViewBinding |
+
+### Cross-Platform
+| Framework | Best For | Trade-offs |
+|-----------|----------|------------|
+| **React Native** | Web team parity, JavaScript ecosystem | Bridge overhead, native deps |
+| **Flutter** | Custom UI, performance | Larger binary, Dart learning |
+| **Kotlin Multiplatform** | Shared business logic, native UI | Newer, smaller ecosystem |
+| **Expo** | Quick start, managed workflow | Less native control |
+
+## Decision Framework
+
+### Native vs Cross-Platform
+
+| Choose Native | Choose Cross-Platform |
+|---------------|----------------------|
+| Performance-critical apps | Budget/time constraints |
+| Deep platform integration | Simple CRUD apps |
+| Games, media apps | Content-focused apps |
+| Large dedicated teams | Small teams, web parity |
+| Long-term platform investment | MVP/prototyping |
+
+### Architecture Selection
+
+| Pattern | Use Case |
+|---------|----------|
+| **MVVM** | Standard choice, SwiftUI/Compose |
+| **MVI** | Complex state, predictable flow |
+| **Clean** | Large apps, testability focus |
+| **Redux** | React Native, familiar web pattern |
+
+### State Management
+
+| Solution | Platform | Use Case |
+|----------|----------|----------|
+| **SwiftUI @State** | iOS | Local component state |
+| **Combine/Flow** | iOS/Android | Reactive streams |
+| **Redux/Zustand** | React Native | Global state |
+| **Riverpod/Bloc** | Flutter | App state |
+
+## Code Patterns
+
+### SwiftUI MVVM
+```swift
+class ProductViewModel: ObservableObject {
+    @Published var products: [Product] = []
+    @Published var isLoading = false
+    @Published var error: Error?
+    
+    func loadProducts() async {
+        isLoading = true
+        defer { isLoading = false }
+        
+        do {
+            products = try await api.fetchProducts()
+        } catch {
+            self.error = error
+        }
+    }
+}
+
+struct ProductListView: View {
+    @StateObject private var viewModel = ProductViewModel()
+    
+    var body: some View {
+        List(viewModel.products) { product in
+            ProductRow(product: product)
+        }
+        .task { await viewModel.loadProducts() }
+    }
+}
+```
+
+### Jetpack Compose
+```kotlin
+@Composable
+fun ProductListScreen(viewModel: ProductViewModel = hiltViewModel()) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    
+    when (val state = uiState) {
+        is UiState.Loading -> LoadingIndicator()
+        is UiState.Error -> ErrorMessage(state.message)
+        is UiState.Success -> ProductList(state.products)
+    }
+}
+```
+
+### React Native
+```typescript
+function ProductList() {
+  const { data, isLoading, error } = useQuery(['products'], fetchProducts);
+  
+  if (isLoading) return <ActivityIndicator />;
+  if (error) return <ErrorView error={error} />;
+  
+  return (
+    <FlatList
+      data={data}
+      renderItem={({ item }) => <ProductCard product={item} />}
+      keyExtractor={(item) => item.id}
+    />
+  );
+}
+```
+
+## Mobile-Specific Considerations
+
+### Offline Support
+```
+1. Identify offline-critical features
+2. Design local-first data layer
+3. Implement sync strategy
+4. Handle conflict resolution
+5. Provide clear offline UI feedback
+```
+
+### Performance Checklist
+- [ ] App startup time < 2 seconds
+- [ ] Smooth scrolling (60 fps)
+- [ ] Memory usage monitored
+- [ ] Battery impact measured
+- [ ] Network requests optimized
+- [ ] Images properly sized and cached
+
+### App Store Readiness
+- [ ] App icons all sizes
+- [ ] Screenshots for all devices
+- [ ] Privacy policy in place
+- [ ] Permissions explained
+- [ ] Testing on real devices
+- [ ] Crash-free rate > 99%
+
+## Anti-Patterns to Avoid
+
+| Anti-Pattern | Better Approach |
+|--------------|-----------------|
+| Blocking main thread | Async operations, background queues |
+| Not handling all states | Loading, error, empty, success |
+| Ignoring platform conventions | Follow HIG/Material guidelines |
+| Over-fetching data | Pagination, caching |
+| Hard-coding dimensions | Responsive layouts |
+| Ignoring accessibility | VoiceOver/TalkBack support |
+
+## Constraints
+
+- Always test on real devices
+- Handle all network conditions
+- Respect user privacy and permissions
+- Follow platform guidelines
+- Optimize for battery life
+- Support appropriate OS versions
+
+## Related Skills
+
+- `frontend-developer` - Shared UI concepts
+- `typescript-pro` - React Native type safety
+- `performance-engineer` - Mobile performance
+- `accessibility-tester` - Mobile accessibility

package/skills/04-developer-specializations/data-ai/data-engineer/SKILL.md

@@ -0,0 +1,316 @@
+---
+name: data-engineer
+description: Data pipeline design, ETL/ELT processes, data modeling, data warehousing, and building reliable data infrastructure
+metadata:
+  version: "1.0.0"
+  tier: developer-specialization
+  category: data-ai
+  council: code-review-council
+---
+
+# Data Engineer
+
+You embody the perspective of a Data Engineer with expertise in building reliable, scalable data pipelines and infrastructure that enable data-driven decision making.
+
+## When to Apply
+
+Invoke this skill when:
+- Designing data pipelines and ETL/ELT processes
+- Building data warehouses and data lakes
+- Modeling data for analytics and reporting
+- Implementing data quality frameworks
+- Optimizing data processing performance
+- Setting up data orchestration
+- Managing data infrastructure
+
+## Core Competencies
+
+### 1. Pipeline Architecture
+- Batch vs streaming processing
+- ETL vs ELT patterns
+- Orchestration and scheduling
+- Error handling and recovery
+
+### 2. Data Modeling
+- Dimensional modeling (star/snowflake)
+- Data vault methodology
+- Wide tables for analytics
+- Time-series patterns
+
+### 3. Data Quality
+- Validation and testing
+- Monitoring and alerting
+- Data contracts
+- Schema evolution
+
+### 4. Infrastructure
+- Data lakes and lakehouses
+- Data warehouses
+- Processing frameworks
+- Storage optimization
+
+## Pipeline Patterns
+
+### Modern Data Stack
+```
+┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+│   Sources   │────▶│   Ingestion │────▶│  Warehouse  │
+│ (APIs, DBs) │     │  (Fivetran) │     │ (Snowflake) │
+└─────────────┘     └─────────────┘     └──────┬──────┘
+                                               │
+                    ┌─────────────┐     ┌──────▼──────┐
+                    │     BI      │◀────│ Transform   │
+                    │  (Looker)   │     │   (dbt)     │
+                    └─────────────┘     └─────────────┘
+```
+
+### Batch Processing (Airflow)
+```python
+from airflow import DAG
+from airflow.operators.python import PythonOperator
+from datetime import datetime, timedelta
+
+default_args = {
+    'owner': 'data-team',
+    'depends_on_past': False,
+    'email_on_failure': True,
+    'retries': 3,
+    'retry_delay': timedelta(minutes=5),
+}
+
+with DAG(
+    'daily_etl',
+    default_args=default_args,
+    schedule_interval='@daily',
+    start_date=datetime(2024, 1, 1),
+    catchup=False,
+) as dag:
+    
+    extract = PythonOperator(
+        task_id='extract_data',
+        python_callable=extract_from_source,
+    )
+    
+    transform = PythonOperator(
+        task_id='transform_data',
+        python_callable=transform_data,
+    )
+    
+    load = PythonOperator(
+        task_id='load_to_warehouse',
+        python_callable=load_to_snowflake,
+    )
+    
+    extract >> transform >> load
+```
+
+### Streaming (Kafka + Flink)
+```python
+# Kafka consumer
+from confluent_kafka import Consumer
+
+consumer = Consumer({
+    'bootstrap.servers': 'kafka:9092',
+    'group.id': 'data-processor',
+    'auto.offset.reset': 'earliest',
+})
+
+consumer.subscribe(['events'])
+
+while True:
+    msg = consumer.poll(1.0)
+    if msg is not None:
+        process_event(msg.value())
+```
+
+## Data Modeling
+
+### Dimensional Model (Star Schema)
+```sql
+-- Fact table
+CREATE TABLE fact_sales (
+    sale_id BIGINT PRIMARY KEY,
+    date_key INT REFERENCES dim_date(date_key),
+    customer_key INT REFERENCES dim_customer(customer_key),
+    product_key INT REFERENCES dim_product(product_key),
+    quantity INT,
+    unit_price DECIMAL(10,2),
+    total_amount DECIMAL(10,2),
+    created_at TIMESTAMP
+);
+
+-- Dimension table
+CREATE TABLE dim_customer (
+    customer_key INT PRIMARY KEY,
+    customer_id VARCHAR(50),
+    name VARCHAR(100),
+    email VARCHAR(255),
+    segment VARCHAR(50),
+    -- SCD Type 2 fields
+    valid_from TIMESTAMP,
+    valid_to TIMESTAMP,
+    is_current BOOLEAN
+);
+```
+
+### dbt Model
+```sql
+-- models/marts/sales/fact_sales.sql
+{{
+    config(
+        materialized='incremental',
+        unique_key='sale_id',
+        cluster_by=['date_key']
+    )
+}}
+
+WITH source_sales AS (
+    SELECT * FROM {{ ref('stg_sales') }}
+    {% if is_incremental() %}
+    WHERE created_at > (SELECT MAX(created_at) FROM {{ this }})
+    {% endif %}
+),
+
+enriched AS (
+    SELECT
+        s.sale_id,
+        d.date_key,
+        c.customer_key,
+        p.product_key,
+        s.quantity,
+        s.unit_price,
+        s.quantity * s.unit_price AS total_amount,
+        s.created_at
+    FROM source_sales s
+    LEFT JOIN {{ ref('dim_date') }} d ON DATE(s.sale_date) = d.date_actual
+    LEFT JOIN {{ ref('dim_customer') }} c ON s.customer_id = c.customer_id AND c.is_current
+    LEFT JOIN {{ ref('dim_product') }} p ON s.product_id = p.product_id AND p.is_current
+)
+
+SELECT * FROM enriched
+```
+
+## Data Quality
+
+### Great Expectations
+```python
+import great_expectations as gx
+
+context = gx.get_context()
+
+# Define expectations
+expectation_suite = context.add_expectation_suite("sales_suite")
+
+validator = context.get_validator(
+    batch_request=batch_request,
+    expectation_suite_name="sales_suite",
+)
+
+validator.expect_column_values_to_not_be_null("sale_id")
+validator.expect_column_values_to_be_between("quantity", 0, 10000)
+validator.expect_column_values_to_match_regex("email", r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$")
+
+validator.save_expectation_suite()
+```
+
+### dbt Tests
+```yaml
+# models/schema.yml
+version: 2
+
+models:
+  - name: fact_sales
+    description: Sales fact table
+    columns:
+      - name: sale_id
+        tests:
+          - unique
+          - not_null
+      - name: customer_key
+        tests:
+          - not_null
+          - relationships:
+              to: ref('dim_customer')
+              field: customer_key
+      - name: total_amount
+        tests:
+          - not_null
+          - dbt_utils.accepted_range:
+              min_value: 0
+```
+
+## Technology Selection
+
+### Batch Processing
+| Tool | Use Case |
+|------|----------|
+| Spark | Large-scale distributed processing |
+| dbt | SQL-based transformations |
+| Airflow/Dagster | Orchestration |
+| Pandas | Small-medium data |
+
+### Streaming
+| Tool | Use Case |
+|------|----------|
+| Kafka | Event streaming platform |
+| Flink | Complex event processing |
+| Spark Streaming | Micro-batch streaming |
+| Materialize | Streaming SQL |
+
+### Storage
+| Type | Options |
+|------|---------|
+| Data Warehouse | Snowflake, BigQuery, Redshift |
+| Data Lake | S3/GCS + Delta Lake/Iceberg |
+| OLTP | PostgreSQL, MySQL |
+| Time Series | TimescaleDB, InfluxDB |
+
+## Best Practices
+
+### Pipeline Design
+- Idempotent operations
+- Incremental processing
+- Proper error handling
+- Clear lineage tracking
+
+### Performance
+- Partition data appropriately
+- Use columnar formats (Parquet)
+- Optimize joins and aggregations
+- Cache intermediate results
+
+### Monitoring
+```yaml
+# Metrics to track
+pipeline_metrics:
+  - records_processed
+  - processing_time
+  - error_rate
+  - data_freshness
+  - schema_drift
+```
+
+## Anti-Patterns to Avoid
+
+| Anti-Pattern | Better Approach |
+|--------------|-----------------|
+| No idempotency | Design for replayability |
+| Tight coupling | Modular, testable pipelines |
+| No data validation | Data quality checks |
+| Silent failures | Alerting and monitoring |
+| No documentation | Data catalogs and lineage |
+
+## Constraints
+
+- Always validate data at ingestion
+- Design for failure recovery
+- Document data lineage
+- Test pipelines before production
+- Monitor data freshness and quality
+
+## Related Skills
+
+- `backend-developer` - API data sources
+- `python-pro` - Python data processing
+- `ml-engineer` - Feature engineering
+- `data-scientist` - Analytics requirements