---
name: minimalist-ui
description: "Use when creating clean editorial interfaces with warm monochrome palettes, crisp borders, restrained motion, and flat bento layouts."
category: frontend
risk: safe
source: community
source_repo: Leonxlnx/taste-skill
source_type: community
date_added: "2026-04-17"
author: Leonxlnx
tags: [frontend, design, minimalism, ui]
tools: [claude, cursor, codex, antigravity]
---
# Protocol: Premium Utilitarian Minimalism UI Architect

## When to Use

- Use when the user wants a refined minimalist UI inspired by tools like Notion, Linear, or editorial workspace products.
- Use when designing warm monochrome interfaces with crisp borders, generous whitespace, muted pastel accents, and quiet motion.
- Use when the task should avoid gradients, heavy shadows, saturated colors, pill-heavy components, and generic SaaS visuals.

## Limitations

- Minimalism can hide hierarchy when content is dense; validate scannability, contrast, and navigation clarity with real content.
- This skill assumes the product can support restrained palettes and typography-led layouts; do not override an established brand system without cause.
- Subtle motion and flat surfaces still need responsive, keyboard, and screen-reader verification in the target project.

## 1. Protocol Overview
Name: Premium Utilitarian Minimalism & Editorial UI
Description: An advanced frontend engineering directive for generating highly refined, ultra-minimalist, "document-style" web interfaces analogous to top-tier workspace platforms. This protocol strictly enforces a high-contrast warm monochrome palette, bespoke typographic hierarchies, meticulous structural macro-whitespace, bento-grid layouts, and an ultra-flat component architecture with deliberate muted pastel accents. It actively rejects standard generic SaaS design trends.

## 2. Absolute Negative Constraints (Banned Elements)
The AI must strictly avoid the following generic web development defaults:
- DO NOT use the "Inter", "Roboto", or "Open Sans" typefaces.
- DO NOT use generic, thin-line icon libraries like "Lucide", "Feather", or standard "Heroicons".
- DO NOT use Tailwind's default heavy drop shadows (e.g., `shadow-md`, `shadow-lg`, `shadow-xl`). Shadows must be practically non-existent or heavily customized to be ultra-diffuse and low opacity (< 0.05).
- DO NOT use primary colored backgrounds for large elements or sections (e.g., no bright blue, green, or red hero sections).
- DO NOT use gradients, neon colors, or 3D glassmorphism (beyond subtle navbar blurs).
- DO NOT use `rounded-full` (pill shapes) for large containers, cards, or primary buttons.
- DO NOT use emojis anywhere in code, markup, text content, headings, or alt text. Replace with proper icons or clean SVG primitives.
- DO NOT use generic placeholder names like "John Doe", "Acme Corp", or "Lorem Ipsum". Use realistic, contextual content.
- DO NOT use AI copywriting clichés: "Elevate", "Seamless", "Unleash", "Next-Gen", "Game-changer", "Delve". Write plain, specific language.

## 3. Typographic Architecture
The interface must rely on extreme typographic contrast and premium font selection to establish an editorial feel.
- Primary Sans-Serif (Body, UI, Buttons): Use clean, geometric, or system-native fonts with character. Target: `font-family: 'SF Pro Display', 'Geist Sans', 'Helvetica Neue', 'Switzer', sans-serif`.
- Editorial Serif (Hero Headings & Quotes): Target: `font-family: 'Lyon Text', 'Newsreader', 'Playfair Display', 'Instrument Serif', serif`. Apply tight tracking (`letter-spacing: -0.02em` to `-0.04em`) and tight line-height (`1.1`).
- Monospace (Code, Keystrokes, Meta-data): Target: `font-family: 'Geist Mono', 'SF Mono', 'JetBrains Mono', monospace`.
- Text Colors: Body text must never be absolute black (`#000000`). Use off-black/charcoal (`#111111` or `#2F3437`) with a generous `line-height` of `1.6` for legibility. Secondary text should be muted gray (`#787774`).

## 4. Color Palette (Warm Monochrome + Spot Pastels)
Color is a scarce resource, utilized only for semantic meaning or subtle accents.
- Canvas / Background: Pure White `#FFFFFF` or Warm Bone/Off-White `#F7F6F3` / `#FBFBFA`.
- Primary Surface (Cards): `#FFFFFF` or `#F9F9F8`.
- Structural Borders / Dividers: Ultra-light gray `#EAEAEA` or `rgba(0,0,0,0.06)`.
- Accent Colors: Exclusively use highly desaturated, washed-out pastels for tags, inline code backgrounds, or subtle icon backgrounds.
  - Pale Red: `#FDEBEC` (Text: `#9F2F2D`)
  - Pale Blue: `#E1F3FE` (Text: `#1F6C9F`)
  - Pale Green: `#EDF3EC` (Text: `#346538`)
  - Pale Yellow: `#FBF3DB` (Text: `#956400`)

## 5. Component Specifications
- Bento Box Feature Grids:
  - Utilize asymmetrical CSS Grid layouts.
  - Cards must have exactly `border: 1px solid #EAEAEA`.
  - Border-radius must be crisp: `8px` or `12px` maximum.
  - Internal padding must be generous (e.g., `24px` to `40px`).
- Primary Call-To-Action (Buttons):
  - Solid background `#111111`, text `#FFFFFF`.
  - Slight border-radius (`4px` to `6px`). No box-shadow.
  - Hover state should be a subtle color shift to `#333333` or a micro-scale `transform: scale(0.98)`.
- Tags & Status Badges:
  - Pill-shaped (`border-radius: 9999px`), very small typography (`text-xs`), uppercase with wide tracking (`letter-spacing: 0.05em`).
  - Background must use the defined Muted Pastels.
- Accordions (FAQ):
  - Strip all container boxes. Separate items only with a `border-bottom: 1px solid #EAEAEA`.
  - Use a clean, sharp `+` and `-` icon for the toggle state.
- Keystroke Micro-UIs:
  - Render shortcuts as physical keys using `<kbd>` tags: `border: 1px solid #EAEAEA`, `border-radius: 4px`, `background: #F7F6F3`, using the Monospace font.
- Faux-OS Window Chrome:
  - When mocking up software, wrap it in a minimalist container with a white top bar containing three small, light gray circles (replicating macOS window controls).

## 6. Iconography & Imagery Directives
- System Icons: Use "Phosphor Icons (Bold or Fill weights)" or "Radix UI Icons" for a technical, slightly thicker-stroke aesthetic. Standardize stroke width across all icons.
- Illustrations: Monochromatic, rough continuous-line ink sketches on a white background, featuring a single offset geometric shape filled with a muted pastel color.
- Photography: Use high-quality, desaturated images with a warm tone. Apply subtle overlays (`opacity: 0.04` warm grain) to blend photos into the monochrome palette. Never use oversaturated stock photos. Use reliable placeholders like `https://picsum.photos/seed/{context}/1200/800` when real assets are unavailable.
- Hero & Section Backgrounds: Sections should not feel empty and flat. Use subtle full-width background imagery at very low opacity, soft radial light spots (`radial-gradient` with warm tones at `opacity: 0.03`), or minimal geometric line patterns to add depth without breaking the clean aesthetic.

## 7. Subtle Motion & Micro-Animations
Motion should feel invisible — present but never distracting. The goal is quiet sophistication, not spectacle.
- Scroll Entry: Elements fade in gently as they enter the viewport. Use `translateY(12px)` + `opacity: 0` resolving over `600ms` with `cubic-bezier(0.16, 1, 0.3, 1)`. Use `IntersectionObserver`, never `window.addEventListener('scroll')`.
- Hover States: Cards lift with an ultra-subtle shadow shift (`box-shadow` transitioning from `0 0 0` to `0 2px 8px rgba(0,0,0,0.04)` over `200ms`). Buttons respond with `scale(0.98)` on `:active`.
- Staggered Reveals: Lists and grid items enter with a cascade delay (`animation-delay: calc(var(--index) * 80ms)`). Never mount everything at once.
- Background Ambient Motion: Optional. A single, very slow-moving radial gradient blob (`animation-duration: 20s+`, `opacity: 0.02-0.04`) drifting behind hero sections. Must be applied to a `position: fixed; pointer-events: none` layer. Never on scrolling containers.
- Performance: Animate exclusively via `transform` and `opacity`. No layout-triggering properties (`top`, `left`, `width`, `height`). Use `will-change: transform` sparingly and only on actively animating elements.

## 8. Execution Protocol
When tasked with writing frontend code (HTML, React, Tailwind, Vue) or designing a layout:
1. Establish the macro-whitespace first. Use massive vertical padding between sections (e.g., `py-24` or `py-32` in Tailwind).
2. Constrain the main typography content width to `max-w-4xl` or `max-w-5xl`.
3. Apply the custom typographic hierarchy and monochromatic color variables immediately.
4. Ensure every card, divider, and border adheres strictly to the `1px solid #EAEAEA` rule.
5. Add scroll-entry animations to all major content blocks.
6. Ensure sections have visual depth through imagery, ambient gradients, or subtle textures — no empty flat backgrounds.
7. Provide code that reflects this high-end, uncluttered, editorial aesthetic natively without requiring manual adjustments.


---
name: miro-automation
description: "Automate Miro tasks via Rube MCP (Composio): boards, items, sticky notes, frames, sharing, connectors. Always search tools first for current schemas."
risk: critical
source: community
date_added: "2026-02-27"
---

# Miro Automation via Rube MCP

Automate Miro whiteboard operations through Composio's Miro toolkit via Rube MCP.

## Prerequisites

- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Miro connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `miro`
- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas

## Setup

**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.

1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `miro`
3. If connection is not ACTIVE, follow the returned auth link to complete Miro OAuth
4. Confirm connection status shows ACTIVE before running any workflows

## Core Workflows

### 1. List and Browse Boards

**When to use**: User wants to find boards or get board details

**Tool sequence**:
1. `MIRO_GET_BOARDS2` - List all accessible boards [Required]
2. `MIRO_GET_BOARD` - Get detailed info for a specific board [Optional]

**Key parameters**:
- `query`: Search term to filter boards by name
- `sort`: Sort by 'default', 'last_modified', 'last_opened', 'last_created', 'alphabetically'
- `limit`: Number of results per page (max 50)
- `offset`: Pagination offset
- `board_id`: Specific board ID for detailed retrieval

**Pitfalls**:
- Pagination uses offset-based approach, not cursor-based
- Maximum 50 boards per page; iterate with offset for full list
- Board IDs are long alphanumeric strings; always resolve by search first

### 2. Create Boards and Items

**When to use**: User wants to create a new board or add items to an existing board

**Tool sequence**:
1. `MIRO_CREATE_BOARD` - Create a new empty board [Optional]
2. `MIRO_CREATE_STICKY_NOTE_ITEM` - Add sticky notes to a board [Optional]
3. `MIRO_CREATE_FRAME_ITEM2` - Add frames to organize content [Optional]
4. `MIRO_CREATE_ITEMS_IN_BULK` - Add multiple items at once [Optional]

**Key parameters**:
- `name` / `description`: Board name and description (for CREATE_BOARD)
- `board_id`: Target board ID (required for all item creation)
- `data`: Content object with `content` field for sticky note text
- `style`: Styling object with `fillColor` for sticky note color
- `position`: Object with `x` and `y` coordinates
- `geometry`: Object with `width` and `height`

**Pitfalls**:
- `board_id` is required for ALL item operations; resolve via GET_BOARDS2 first
- Sticky note colors use hex codes (e.g., '#FF0000') in the `fillColor` field
- Position coordinates use the board's coordinate system (origin at center)
- BULK create has a maximum items-per-request limit; check current schema
- Frame items require `geometry` with both width and height

### 3. Browse and Manage Board Items

**When to use**: User wants to view, find, or organize items on a board

**Tool sequence**:
1. `MIRO_GET_BOARD_ITEMS` - List all items on a board [Required]
2. `MIRO_GET_CONNECTORS2` - List connections between items [Optional]

**Key parameters**:
- `board_id`: Target board ID (required)
- `type`: Filter by item type ('sticky_note', 'shape', 'text', 'frame', 'image', 'card')
- `limit`: Number of items per page
- `cursor`: Pagination cursor from previous response

**Pitfalls**:
- Results are paginated; follow `cursor` until absent for complete item list
- Item types must match Miro's predefined types exactly
- Large boards may have thousands of items; use type filtering to narrow results
- Connectors are separate from items; use GET_CONNECTORS2 for relationship data

### 4. Share and Collaborate on Boards

**When to use**: User wants to share a board with team members or manage access

**Tool sequence**:
1. `MIRO_GET_BOARDS2` - Find the board to share [Prerequisite]
2. `MIRO_SHARE_BOARD` - Share the board with users [Required]
3. `MIRO_GET_BOARD_MEMBERS` - Verify current board members [Optional]

**Key parameters**:
- `board_id`: Board to share (required)
- `emails`: Array of email addresses to invite
- `role`: Access level ('viewer', 'commenter', 'editor')
- `message`: Optional invitation message

**Pitfalls**:
- Email addresses must be valid; invalid emails cause the entire request to fail
- Role must be one of the predefined values; case-sensitive
- Sharing with users outside the organization may require admin approval
- GET_BOARD_MEMBERS returns all members including the owner

### 5. Create Visual Connections

**When to use**: User wants to connect items on a board with lines or arrows

**Tool sequence**:
1. `MIRO_GET_BOARD_ITEMS` - Find items to connect [Prerequisite]
2. `MIRO_GET_CONNECTORS2` - View existing connections [Optional]

**Key parameters**:
- `board_id`: Target board ID
- `startItem`: Object with `id` of the source item
- `endItem`: Object with `id` of the target item
- `style`: Connector style (line type, color, arrows)

**Pitfalls**:
- Both start and end items must exist on the same board
- Item IDs are required for connections; resolve via GET_BOARD_ITEMS first
- Connector styles vary; check available options in schema
- Self-referencing connections (same start and end) are not allowed

## Common Patterns

### ID Resolution

**Board name -> Board ID**:
```
1. Call MIRO_GET_BOARDS2 with query=board_name
2. Find board by name in results
3. Extract id field
```

**Item lookup on board**:
```
1. Call MIRO_GET_BOARD_ITEMS with board_id and optional type filter
2. Find item by content or position
3. Extract item id for further operations
```

### Pagination

- Boards: Use `offset` and `limit` (offset-based)
- Board items: Use `cursor` and `limit` (cursor-based)
- Continue until no more results or cursor is absent
- Default page sizes vary by endpoint

### Coordinate System

- Board origin (0,0) is at the center
- Positive X is right, positive Y is down
- Items positioned by their center point
- Use `position: {x: 0, y: 0}` for center of board
- Frames define bounded areas; items inside inherit frame position

## Known Pitfalls

**Board IDs**:
- Board IDs are required for virtually all operations
- Always resolve board names to IDs via GET_BOARDS2 first
- Do not hardcode board IDs; they vary by account

**Item Creation**:
- Each item type has different required fields
- Sticky notes need `data.content` for text
- Frames need `geometry.width` and `geometry.height`
- Position defaults to (0,0) if not specified; items may overlap

**Rate Limits**:
- Miro API has rate limits per token
- Bulk operations preferred over individual item creation
- Use MIRO_CREATE_ITEMS_IN_BULK for multiple items

**Response Parsing**:
- Response data may be nested under `data` key
- Item types determine which fields are present in response
- Parse defensively; optional fields may be absent

## Quick Reference

| Task | Tool Slug | Key Params |
|------|-----------|------------|
| List boards | MIRO_GET_BOARDS2 | query, sort, limit, offset |
| Get board details | MIRO_GET_BOARD | board_id |
| Create board | MIRO_CREATE_BOARD | name, description |
| Add sticky note | MIRO_CREATE_STICKY_NOTE_ITEM | board_id, data, style, position |
| Add frame | MIRO_CREATE_FRAME_ITEM2 | board_id, data, geometry, position |
| Bulk add items | MIRO_CREATE_ITEMS_IN_BULK | board_id, items |
| Get board items | MIRO_GET_BOARD_ITEMS | board_id, type, cursor |
| Share board | MIRO_SHARE_BOARD | board_id, emails, role |
| Get members | MIRO_GET_BOARD_MEMBERS | board_id |
| Get connectors | MIRO_GET_CONNECTORS2 | board_id |

## When to Use
This skill is applicable to execute the workflow or actions described in the overview.

## Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.


---
name: mise-configurator
description: "Generate production-ready mise.toml setups for local development, CI/CD pipelines, and toolchain standardization."
category: devops
risk: safe
source: self
source_type: self
date_added: "2026-04-16"
author: community
tags: [mise, devops, ci-cd, toolchain, runtimes, automation]
tools: [claude, cursor, gemini]
---
# Mise Configurator

## Overview

This skill generates clean, production-ready `mise.toml` configurations for local development environments and CI/CD pipelines.

It helps standardize runtime versions, simplify onboarding, replace legacy version managers like `asdf`, `nvm`, and `pyenv`, and create reproducible multi-language environments with minimal setup effort.

## When to Use This Skill

- Use when you need to create or update a `mise.toml`
- Use when working with Node.js, Python, Go, Rust, Java, Bun, Terraform, or mixed stacks
- Use when the user asks about CI/CD runtime setup using mise
- Use when migrating from `.tool-versions`, `asdf`, `nvm`, or `pyenv`
- Use when standardizing tool versions across teams or monorepos

## How It Works

### Step 1: Detect Project Context

Inspect available repository files such as:

- `package.json`
- `pnpm-lock.yaml`
- `pyproject.toml`
- `requirements.txt`
- `go.mod`
- `Cargo.toml`
- `.tool-versions`
- `Dockerfile`
- GitHub Actions or CI files

Infer languages, package managers, and pinned versions.

### Step 2: Generate `mise.toml`

Create a minimal, valid, copy-paste-ready configuration using:

- existing pinned versions when found
- explicit user-provided target versions when absent
- practical defaults for developer productivity
- concrete pinned versions in shared production configs

### Step 3: Add Bootstrap Commands

Provide setup commands such as:

```bash
mise trust
mise install
```

### Step 4: Generate CI/CD Integration

If requested, generate pipeline examples using mise with caching and runtime installation.

## Examples

### Example 1: Node.js + pnpm Project

```toml
[tools]
node = "22.11.0"
pnpm = "9.15.0"
```

### Example 2: Python + GitHub Actions

```toml
[tools]
python = "3.12.7"
poetry = "1.8.4"
```

```yaml
steps:
  - uses: actions/checkout@v4
  - uses: jdx/mise-action@v2
  - run: poetry install
  - run: pytest
```

## Best Practices

- ✅ Respect versions already pinned in the repository

- ✅ Keep configs minimal and readable

- ✅ Prefer stable runtime releases

- ✅ Generate CI examples with caching

- ✅ Ask for target versions before pinning when the repository does not already declare them

- ❌ Do not use floating `latest` or `lts` aliases in shared production configs unless explicitly requested

- ❌ Do not over-engineer unnecessary tool entries

- ❌ Do not ignore existing lockfiles or version files

## Limitations

- This skill does not replace environment-specific validation, testing, or expert review.

- Stop and ask for clarification if required inputs, permissions, or safety boundaries are missing.

- Runtime availability may vary by OS, shell, or CI platform.

- Some plugins or niche tools may require manual adjustment.

## Security & Safety Notes

- Review generated shell commands before execution.

- Confirm CI/CD permissions before modifying pipelines.

- Validate runtime versions against production requirements.

- Use only in authorized repositories and environments.

## Common Pitfalls

- **Problem:** Wrong runtime version selected
    **Solution:** Check repository lockfiles and pinned versions first.

- **Problem:** CI installs are slow
    **Solution:** Enable cache layers and reuse mise cache directories.

- **Problem:** Tool missing from registry
    **Solution:** Verify plugin support or install manually.

## Related Skills

- `@docker-expert` - Use when building containerized development environments

- `@github-actions-templates` - Use for advanced workflow automation

- `@monorepo-architect` - Use for large multi-package repositories


---
name: mixpanel-automation
description: "Automate Mixpanel tasks via Rube MCP (Composio): events, segmentation, funnels, cohorts, user profiles, JQL queries. Always search tools first for current schemas."
risk: critical
source: community
date_added: "2026-02-27"
---

# Mixpanel Automation via Rube MCP

Automate Mixpanel product analytics through Composio's Mixpanel toolkit via Rube MCP.

## Prerequisites

- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Mixpanel connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `mixpanel`
- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas

## Setup

**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.

1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `mixpanel`
3. If connection is not ACTIVE, follow the returned auth link to complete Mixpanel authentication
4. Confirm connection status shows ACTIVE before running any workflows

## Core Workflows

### 1. Aggregate Event Data

**When to use**: User wants to count events, get totals, or track event trends over time

**Tool sequence**:
1. `MIXPANEL_GET_ALL_PROJECTS` - List projects to get project ID [Prerequisite]
2. `MIXPANEL_AGGREGATE_EVENT_COUNTS` - Get event counts and aggregations [Required]

**Key parameters**:
- `event`: Event name or array of event names to aggregate
- `from_date` / `to_date`: Date range in 'YYYY-MM-DD' format
- `unit`: Time granularity ('minute', 'hour', 'day', 'week', 'month')
- `type`: Aggregation type ('general', 'unique', 'average')
- `where`: Filter expression for event properties

**Pitfalls**:
- Date format must be 'YYYY-MM-DD'; other formats cause errors
- Event names are case-sensitive; use exact names from your Mixpanel project
- `where` filter uses Mixpanel expression syntax (e.g., `properties["country"] == "US"`)
- Maximum date range may be limited depending on your Mixpanel plan

### 2. Run Segmentation Queries

**When to use**: User wants to break down events by properties for detailed analysis

**Tool sequence**:
1. `MIXPANEL_QUERY_SEGMENTATION` - Run segmentation analysis [Required]

**Key parameters**:
- `event`: Event name to segment
- `from_date` / `to_date`: Date range in 'YYYY-MM-DD' format
- `on`: Property to segment by (e.g., `properties["country"]`)
- `unit`: Time granularity
- `type`: Count type ('general', 'unique', 'average')
- `where`: Filter expression
- `limit`: Maximum number of segments to return

**Pitfalls**:
- The `on` parameter uses Mixpanel property expression syntax
- Property references must use `properties["prop_name"]` format
- Segmentation on high-cardinality properties returns capped results; use `limit`
- Results are grouped by the segmentation property and time unit

### 3. Analyze Funnels

**When to use**: User wants to track conversion funnels and identify drop-off points

**Tool sequence**:
1. `MIXPANEL_LIST_FUNNELS` - List saved funnels to find funnel ID [Prerequisite]
2. `MIXPANEL_QUERY_FUNNEL` - Execute funnel analysis [Required]

**Key parameters**:
- `funnel_id`: ID of the saved funnel to query
- `from_date` / `to_date`: Date range
- `unit`: Time granularity
- `where`: Filter expression
- `on`: Property to segment funnel by
- `length`: Conversion window in days

**Pitfalls**:
- `funnel_id` is required; resolve via LIST_FUNNELS first
- Funnels must be created in Mixpanel UI first; API only queries existing funnels
- Conversion window (`length`) defaults vary; set explicitly for accuracy
- Large date ranges with segmentation can produce very large responses

### 4. Manage User Profiles

**When to use**: User wants to query or update user profiles in Mixpanel

**Tool sequence**:
1. `MIXPANEL_QUERY_PROFILES` - Search and filter user profiles [Required]
2. `MIXPANEL_PROFILE_BATCH_UPDATE` - Update multiple user profiles [Optional]

**Key parameters**:
- `where`: Filter expression for profile properties (e.g., `properties["plan"] == "premium"`)
- `output_properties`: Array of property names to include in results
- `page`: Page number for pagination
- `session_id`: Session ID for consistent pagination (from first response)
- For batch update: array of profile updates with `$distinct_id` and property operations

**Pitfalls**:
- Profile queries return paginated results; use `session_id` from first response for consistent paging
- `where` uses Mixpanel expression syntax for profile properties
- BATCH_UPDATE applies operations (`$set`, `$unset`, `$add`, `$append`) to profiles
- Batch update has a maximum number of profiles per request; chunk larger updates
- Profile property names are case-sensitive

### 5. Manage Cohorts

**When to use**: User wants to list or analyze user cohorts

**Tool sequence**:
1. `MIXPANEL_COHORTS_LIST` - List all saved cohorts [Required]

**Key parameters**:
- No required parameters; returns all accessible cohorts
- Response includes cohort `id`, `name`, `description`, `count`

**Pitfalls**:
- Cohorts are created and managed in Mixpanel UI; API provides read access
- Cohort IDs are numeric; use exact ID from list results
- Cohort counts may be approximate for very large cohorts
- Cohorts can be used as filters in other queries via `where` expressions

### 6. Run JQL and Insight Queries

**When to use**: User wants to run custom JQL queries or insight analyses

**Tool sequence**:
1. `MIXPANEL_JQL_QUERY` - Execute a custom JQL (JavaScript Query Language) query [Optional]
2. `MIXPANEL_QUERY_INSIGHT` - Run a saved insight query [Optional]

**Key parameters**:
- For JQL: `script` containing the JQL JavaScript code
- For Insight: `bookmark_id` of the saved insight
- `project_id`: Project context for the query

**Pitfalls**:
- JQL uses JavaScript-like syntax specific to Mixpanel
- JQL queries have execution time limits; optimize for efficiency
- Insight `bookmark_id` must reference an existing saved insight
- JQL is a legacy feature; check Mixpanel documentation for current availability

## Common Patterns

### ID Resolution

**Project name -> Project ID**:
```
1. Call MIXPANEL_GET_ALL_PROJECTS
2. Find project by name in results
3. Extract project id
```

**Funnel name -> Funnel ID**:
```
1. Call MIXPANEL_LIST_FUNNELS
2. Find funnel by name
3. Extract funnel_id
```

### Mixpanel Expression Syntax

Used in `where` and `on` parameters:
- Property reference: `properties["property_name"]`
- Equality: `properties["country"] == "US"`
- Comparison: `properties["age"] > 25`
- Boolean: `properties["is_premium"] == true`
- Contains: `"search_term" in properties["name"]`
- AND/OR: `properties["country"] == "US" and properties["plan"] == "pro"`

### Pagination

- Event queries: Follow date-based pagination by adjusting date ranges
- Profile queries: Use `page` number and `session_id` for consistent results
- Funnel/cohort lists: Typically return complete results without pagination

## Known Pitfalls

**Date Formats**:
- Always use 'YYYY-MM-DD' format
- Date ranges are inclusive on both ends
- Data freshness depends on Mixpanel ingestion delay (typically minutes)

**Expression Syntax**:
- Property references always use `properties["name"]` format
- String values must be quoted: `properties["status"] == "active"`
- Numeric values are unquoted: `properties["count"] > 10`
- Boolean values: `true` / `false` (lowercase)

**Rate Limits**:
- Mixpanel API has rate limits per project
- Large segmentation queries may time out; reduce date range or segments
- Use batch operations where available to minimize API calls

**Response Parsing**:
- Response data may be nested under `data` key
- Event data is typically grouped by date and segment
- Numeric values may be returned as strings; parse explicitly
- Empty date ranges return empty objects, not empty arrays

## Quick Reference

| Task | Tool Slug | Key Params |
|------|-----------|------------|
| List projects | MIXPANEL_GET_ALL_PROJECTS | (none) |
| Aggregate events | MIXPANEL_AGGREGATE_EVENT_COUNTS | event, from_date, to_date, unit |
| Segmentation | MIXPANEL_QUERY_SEGMENTATION | event, on, from_date, to_date |
| List funnels | MIXPANEL_LIST_FUNNELS | (none) |
| Query funnel | MIXPANEL_QUERY_FUNNEL | funnel_id, from_date, to_date |
| Query profiles | MIXPANEL_QUERY_PROFILES | where, output_properties, page |
| Batch update profiles | MIXPANEL_PROFILE_BATCH_UPDATE | (profile update objects) |
| List cohorts | MIXPANEL_COHORTS_LIST | (none) |
| JQL query | MIXPANEL_JQL_QUERY | script |
| Query insight | MIXPANEL_QUERY_INSIGHT | bookmark_id |

## When to Use
This skill is applicable to execute the workflow or actions described in the overview.

## Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.


---
name: ml-engineer
description: Build production ML systems with PyTorch 2.x, TensorFlow, and modern ML frameworks. Implements model serving, feature engineering, A/B testing, and monitoring.
risk: critical
source: community
date_added: '2026-02-27'
---

## Use this skill when

- Working on ml engineer tasks or workflows
- Needing guidance, best practices, or checklists for ml engineer

## Do not use this skill when

- The task is unrelated to ml engineer
- You need a different domain or tool outside this scope

## Instructions

- Clarify goals, constraints, and required inputs.
- Apply relevant best practices and validate outcomes.
- Provide actionable steps and verification.
- If detailed examples are required, open `resources/implementation-playbook.md`.

You are an ML engineer specializing in production machine learning systems, model serving, and ML infrastructure.

## Purpose
Expert ML engineer specializing in production-ready machine learning systems. Masters modern ML frameworks (PyTorch 2.x, TensorFlow 2.x), model serving architectures, feature engineering, and ML infrastructure. Focuses on scalable, reliable, and efficient ML systems that deliver business value in production environments.

## Capabilities

### Core ML Frameworks & Libraries
- PyTorch 2.x with torch.compile, FSDP, and distributed training capabilities
- TensorFlow 2.x/Keras with tf.function, mixed precision, and TensorFlow Serving
- JAX/Flax for research and high-performance computing workloads
- Scikit-learn, XGBoost, LightGBM, CatBoost for classical ML algorithms
- ONNX for cross-framework model interoperability and optimization
- Hugging Face Transformers and Accelerate for LLM fine-tuning and deployment
- Ray/Ray Train for distributed computing and hyperparameter tuning

### Model Serving & Deployment
- Model serving platforms: TensorFlow Serving, TorchServe, MLflow, BentoML
- Container orchestration: Docker, Kubernetes, Helm charts for ML workloads
- Cloud ML services: AWS SageMaker, Azure ML, GCP Vertex AI, Databricks ML
- API frameworks: FastAPI, Flask, gRPC for ML microservices
- Real-time inference: Redis, Apache Kafka for streaming predictions
- Batch inference: Apache Spark, Ray, Dask for large-scale prediction jobs
- Edge deployment: TensorFlow Lite, PyTorch Mobile, ONNX Runtime
- Model optimization: quantization, pruning, distillation for efficiency

### Feature Engineering & Data Processing
- Feature stores: Feast, Tecton, AWS Feature Store, Databricks Feature Store
- Data processing: Apache Spark, Pandas, Polars, Dask for large datasets
- Feature engineering: automated feature selection, feature crosses, embeddings
- Data validation: Great Expectations, TensorFlow Data Validation (TFDV)
- Pipeline orchestration: Apache Airflow, Kubeflow Pipelines, Prefect, Dagster
- Real-time features: Apache Kafka, Apache Pulsar, Redis for streaming data
- Feature monitoring: drift detection, data quality, feature importance tracking

### Model Training & Optimization
- Distributed training: PyTorch DDP, Horovod, DeepSpeed for multi-GPU/multi-node
- Hyperparameter optimization: Optuna, Ray Tune, Hyperopt, Weights & Biases
- AutoML platforms: H2O.ai, AutoGluon, FLAML for automated model selection
- Experiment tracking: MLflow, Weights & Biases, Neptune, ClearML
- Model versioning: MLflow Model Registry, DVC, Git LFS
- Training acceleration: mixed precision, gradient checkpointing, efficient attention
- Transfer learning and fine-tuning strategies for domain adaptation

### Production ML Infrastructure
- Model monitoring: data drift, model drift, performance degradation detection
- A/B testing: multi-armed bandits, statistical testing, gradual rollouts
- Model governance: lineage tracking, compliance, audit trails
- Cost optimization: spot instances, auto-scaling, resource allocation
- Load balancing: traffic splitting, canary deployments, blue-green deployments
- Caching strategies: model caching, feature caching, prediction memoization
- Error handling: circuit breakers, fallback models, graceful degradation

### MLOps & CI/CD Integration
- ML pipelines: end-to-end automation from data to deployment
- Model testing: unit tests, integration tests, data validation tests
- Continuous training: automatic model retraining based on performance metrics
- Model packaging: containerization, versioning, dependency management
- Infrastructure as Code: Terraform, CloudFormation, Pulumi for ML infrastructure
- Monitoring & alerting: Prometheus, Grafana, custom metrics for ML systems
- Security: model encryption, secure inference, access controls

### Performance & Scalability
- Inference optimization: batching, caching, model quantization
- Hardware acceleration: GPU, TPU, specialized AI chips (AWS Inferentia, Google Edge TPU)
- Distributed inference: model sharding, parallel processing
- Memory optimization: gradient checkpointing, model compression
- Latency optimization: pre-loading, warm-up strategies, connection pooling
- Throughput maximization: concurrent processing, async operations
- Resource monitoring: CPU, GPU, memory usage tracking and optimization

### Model Evaluation & Testing
- Offline evaluation: cross-validation, holdout testing, temporal validation
- Online evaluation: A/B testing, multi-armed bandits, champion-challenger
- Fairness testing: bias detection, demographic parity, equalized odds
- Robustness testing: adversarial examples, data poisoning, edge cases
- Performance metrics: accuracy, precision, recall, F1, AUC, business metrics
- Statistical significance testing and confidence intervals
- Model interpretability: SHAP, LIME, feature importance analysis

### Specialized ML Applications
- Computer vision: object detection, image classification, semantic segmentation
- Natural language processing: text classification, named entity recognition, sentiment analysis
- Recommendation systems: collaborative filtering, content-based, hybrid approaches
- Time series forecasting: ARIMA, Prophet, deep learning approaches
- Anomaly detection: isolation forests, autoencoders, statistical methods
- Reinforcement learning: policy optimization, multi-armed bandits
- Graph ML: node classification, link prediction, graph neural networks

### Data Management for ML
- Data pipelines: ETL/ELT processes for ML-ready data
- Data versioning: DVC, lakeFS, Pachyderm for reproducible ML
- Data quality: profiling, validation, cleansing for ML datasets
- Feature stores: centralized feature management and serving
- Data governance: privacy, compliance, data lineage for ML
- Synthetic data generation: GANs, VAEs for data augmentation
- Data labeling: active learning, weak supervision, semi-supervised learning

## Behavioral Traits
- Prioritizes production reliability and system stability over model complexity
- Implements comprehensive monitoring and observability from the start
- Focuses on end-to-end ML system performance, not just model accuracy
- Emphasizes reproducibility and version control for all ML artifacts
- Considers business metrics alongside technical metrics
- Plans for model maintenance and continuous improvement
- Implements thorough testing at multiple levels (data, model, system)
- Optimizes for both performance and cost efficiency
- Follows MLOps best practices for sustainable ML systems
- Stays current with ML infrastructure and deployment technologies

## Knowledge Base
- Modern ML frameworks and their production capabilities (PyTorch 2.x, TensorFlow 2.x)
- Model serving architectures and optimization techniques
- Feature engineering and feature store technologies
- ML monitoring and observability best practices
- A/B testing and experimentation frameworks for ML
- Cloud ML platforms and services (AWS, GCP, Azure)
- Container orchestration and microservices for ML
- Distributed computing and parallel processing for ML
- Model optimization techniques (quantization, pruning, distillation)
- ML security and compliance considerations

## Response Approach
1. **Analyze ML requirements** for production scale and reliability needs
2. **Design ML system architecture** with appropriate serving and infrastructure components
3. **Implement production-ready ML code** with comprehensive error handling and monitoring
4. **Include evaluation metrics** for both technical and business performance
5. **Consider resource optimization** for cost and latency requirements
6. **Plan for model lifecycle** including retraining and updates
7. **Implement testing strategies** for data, models, and systems
8. **Document system behavior** and provide operational runbooks

## Example Interactions
- "Design a real-time recommendation system that can handle 100K predictions per second"
- "Implement A/B testing framework for comparing different ML model versions"
- "Build a feature store that serves both batch and real-time ML predictions"
- "Create a distributed training pipeline for large-scale computer vision models"
- "Design model monitoring system that detects data drift and performance degradation"
- "Implement cost-optimized batch inference pipeline for processing millions of records"
- "Build ML serving architecture with auto-scaling and load balancing"
- "Create continuous training pipeline that automatically retrains models based on performance"

## Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.


---
name: ml-pipeline-workflow
description: "Complete end-to-end MLOps pipeline orchestration from data preparation through model deployment."
risk: critical
source: community
date_added: "2026-02-27"
---

# ML Pipeline Workflow

Complete end-to-end MLOps pipeline orchestration from data preparation through model deployment.

## Do not use this skill when

- The task is unrelated to ml pipeline workflow
- You need a different domain or tool outside this scope

## Instructions

- Clarify goals, constraints, and required inputs.
- Apply relevant best practices and validate outcomes.
- Provide actionable steps and verification.
- If detailed examples are required, open `resources/implementation-playbook.md`.

## Overview

This skill provides comprehensive guidance for building production ML pipelines that handle the full lifecycle: data ingestion → preparation → training → validation → deployment → monitoring.

## Use this skill when

- Building new ML pipelines from scratch
- Designing workflow orchestration for ML systems
- Implementing data → model → deployment automation
- Setting up reproducible training workflows
- Creating DAG-based ML orchestration
- Integrating ML components into production systems

## What This Skill Provides

### Core Capabilities

1. **Pipeline Architecture**
   - End-to-end workflow design
   - DAG orchestration patterns (Airflow, Dagster, Kubeflow)
   - Component dependencies and data flow
   - Error handling and retry strategies

2. **Data Preparation**
   - Data validation and quality checks
   - Feature engineering pipelines
   - Data versioning and lineage
   - Train/validation/test splitting strategies

3. **Model Training**
   - Training job orchestration
   - Hyperparameter management
   - Experiment tracking integration
   - Distributed training patterns

4. **Model Validation**
   - Validation frameworks and metrics
   - A/B testing infrastructure
   - Performance regression detection
   - Model comparison workflows

5. **Deployment Automation**
   - Model serving patterns
   - Canary deployments
   - Blue-green deployment strategies
   - Rollback mechanisms

### Reference Documentation

See the `references/` directory for detailed guides:
- **data-preparation.md** - Data cleaning, validation, and feature engineering
- **model-training.md** - Training workflows and best practices
- **model-validation.md** - Validation strategies and metrics
- **model-deployment.md** - Deployment patterns and serving architectures

### Assets and Templates

The `assets/` directory contains:
- **pipeline-dag.yaml.template** - DAG template for workflow orchestration
- **training-config.yaml** - Training configuration template
- **validation-checklist.md** - Pre-deployment validation checklist

## Usage Patterns

### Basic Pipeline Setup

```python
# 1. Define pipeline stages
stages = [
    "data_ingestion",
    "data_validation",
    "feature_engineering",
    "model_training",
    "model_validation",
    "model_deployment"
]

# 2. Configure dependencies
# See assets/pipeline-dag.yaml.template for full example
```

### Production Workflow

1. **Data Preparation Phase**
   - Ingest raw data from sources
   - Run data quality checks
   - Apply feature transformations
   - Version processed datasets

2. **Training Phase**
   - Load versioned training data
   - Execute training jobs
   - Track experiments and metrics
   - Save trained models

3. **Validation Phase**
   - Run validation test suite
   - Compare against baseline
   - Generate performance reports
   - Approve for deployment

4. **Deployment Phase**
   - Package model artifacts
   - Deploy to serving infrastructure
   - Configure monitoring
   - Validate production traffic

## Best Practices

### Pipeline Design

- **Modularity**: Each stage should be independently testable
- **Idempotency**: Re-running stages should be safe
- **Observability**: Log metrics at every stage
- **Versioning**: Track data, code, and model versions
- **Failure Handling**: Implement retry logic and alerting

### Data Management

- Use data validation libraries (Great Expectations, TFX)
- Version datasets with DVC or similar tools
- Document feature engineering transformations
- Maintain data lineage tracking

### Model Operations

- Separate training and serving infrastructure
- Use model registries (MLflow, Weights & Biases)
- Implement gradual rollouts for new models
- Monitor model performance drift
- Maintain rollback capabilities

### Deployment Strategies

- Start with shadow deployments
- Use canary releases for validation
- Implement A/B testing infrastructure
- Set up automated rollback triggers
- Monitor latency and throughput

## Integration Points

### Orchestration Tools

- **Apache Airflow**: DAG-based workflow orchestration
- **Dagster**: Asset-based pipeline orchestration
- **Kubeflow Pipelines**: Kubernetes-native ML workflows
- **Prefect**: Modern dataflow automation

### Experiment Tracking

- MLflow for experiment tracking and model registry
- Weights & Biases for visualization and collaboration
- TensorBoard for training metrics

### Deployment Platforms

- AWS SageMaker for managed ML infrastructure
- Google Vertex AI for GCP deployments
- Azure ML for Azure cloud
- Kubernetes + KServe for cloud-agnostic serving

## Progressive Disclosure

Start with the basics and gradually add complexity:

1. **Level 1**: Simple linear pipeline (data → train → deploy)
2. **Level 2**: Add validation and monitoring stages
3. **Level 3**: Implement hyperparameter tuning
4. **Level 4**: Add A/B testing and gradual rollouts
5. **Level 5**: Multi-model pipelines with ensemble strategies

## Common Patterns

### Batch Training Pipeline

```yaml
# See assets/pipeline-dag.yaml.template
stages:
  - name: data_preparation
    dependencies: []
  - name: model_training
    dependencies: [data_preparation]
  - name: model_evaluation
    dependencies: [model_training]
  - name: model_deployment
    dependencies: [model_evaluation]
```

### Real-time Feature Pipeline

```python
# Stream processing for real-time features
# Combined with batch training
# See references/data-preparation.md
```

### Continuous Training

```python
# Automated retraining on schedule
# Triggered by data drift detection
# See references/model-training.md
```

## Troubleshooting

### Common Issues

- **Pipeline failures**: Check dependencies and data availability
- **Training instability**: Review hyperparameters and data quality
- **Deployment issues**: Validate model artifacts and serving config
- **Performance degradation**: Monitor data drift and model metrics

### Debugging Steps

1. Check pipeline logs for each stage
2. Validate input/output data at boundaries
3. Test components in isolation
4. Review experiment tracking metrics
5. Inspect model artifacts and metadata

## Next Steps

After setting up your pipeline:

1. Explore **hyperparameter-tuning** skill for optimization
2. Learn **experiment-tracking-setup** for MLflow/W&B
3. Review **model-deployment-patterns** for serving strategies
4. Implement monitoring with observability tools

## Related Skills

- **experiment-tracking-setup**: MLflow and Weights & Biases integration
- **hyperparameter-tuning**: Automated hyperparameter optimization
- **model-deployment-patterns**: Advanced deployment strategies

## Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.


---
name: mlops-engineer
description: Build comprehensive ML pipelines, experiment tracking, and model registries with MLflow, Kubeflow, and modern MLOps tools.
risk: critical
source: community
date_added: '2026-02-27'
---

## Use this skill when

- Working on mlops engineer tasks or workflows
- Needing guidance, best practices, or checklists for mlops engineer

## Do not use this skill when

- The task is unrelated to mlops engineer
- You need a different domain or tool outside this scope

## Instructions

- Clarify goals, constraints, and required inputs.
- Apply relevant best practices and validate outcomes.
- Provide actionable steps and verification.
- If detailed examples are required, open `resources/implementation-playbook.md`.

You are an MLOps engineer specializing in ML infrastructure, automation, and production ML systems across cloud platforms.

## Purpose
Expert MLOps engineer specializing in building scalable ML infrastructure and automation pipelines. Masters the complete MLOps lifecycle from experimentation to production, with deep knowledge of modern MLOps tools, cloud platforms, and best practices for reliable, scalable ML systems.

## Capabilities

### ML Pipeline Orchestration & Workflow Management
- Kubeflow Pipelines for Kubernetes-native ML workflows
- Apache Airflow for complex DAG-based ML pipeline orchestration
- Prefect for modern dataflow orchestration with dynamic workflows
- Dagster for data-aware pipeline orchestration and asset management
- Azure ML Pipelines and AWS SageMaker Pipelines for cloud-native workflows
- Argo Workflows for container-native workflow orchestration
- GitHub Actions and GitLab CI/CD for ML pipeline automation
- Custom pipeline frameworks with Docker and Kubernetes

### Experiment Tracking & Model Management
- MLflow for end-to-end ML lifecycle management and model registry
- Weights & Biases (W&B) for experiment tracking and model optimization
- Neptune for advanced experiment management and collaboration
- ClearML for MLOps platform with experiment tracking and automation
- Comet for ML experiment management and model monitoring
- DVC (Data Version Control) for data and model versioning
- Git LFS and cloud storage integration for artifact management
- Custom experiment tracking with metadata databases

### Model Registry & Versioning
- MLflow Model Registry for centralized model management
- Azure ML Model Registry and AWS SageMaker Model Registry
- DVC for Git-based model and data versioning
- Pachyderm for data versioning and pipeline automation
- lakeFS for data versioning with Git-like semantics
- Model lineage tracking and governance workflows
- Automated model promotion and approval processes
- Model metadata management and documentation

### Cloud-Specific MLOps Expertise

#### AWS MLOps Stack
- SageMaker Pipelines, Experiments, and Model Registry
- SageMaker Processing, Training, and Batch Transform jobs
- SageMaker Endpoints for real-time and serverless inference
- AWS Batch and ECS/Fargate for distributed ML workloads
- S3 for data lake and model artifacts with lifecycle policies
- CloudWatch and X-Ray for ML system monitoring and tracing
- AWS Step Functions for complex ML workflow orchestration
- EventBridge for event-driven ML pipeline triggers

#### Azure MLOps Stack
- Azure ML Pipelines, Experiments, and Model Registry
- Azure ML Compute Clusters and Compute Instances
- Azure ML Endpoints for managed inference and deployment
- Azure Container Instances and AKS for containerized ML workloads
- Azure Data Lake Storage and Blob Storage for ML data
- Application Insights and Azure Monitor for ML system observability
- Azure DevOps and GitHub Actions for ML CI/CD pipelines
- Event Grid for event-driven ML workflows

#### GCP MLOps Stack
- Vertex AI Pipelines, Experiments, and Model Registry
- Vertex AI Training and Prediction for managed ML services
- Vertex AI Endpoints and Batch Prediction for inference
- Google Kubernetes Engine (GKE) for container orchestration
- Cloud Storage and BigQuery for ML data management
- Cloud Monitoring and Cloud Logging for ML system observability
- Cloud Build and Cloud Functions for ML automation
- Pub/Sub for event-driven ML pipeline architecture

### Container Orchestration & Kubernetes
- Kubernetes deployments for ML workloads with resource management
- Helm charts for ML application packaging and deployment
- Istio service mesh for ML microservices communication
- KEDA for Kubernetes-based autoscaling of ML workloads
- Kubeflow for complete ML platform on Kubernetes
- KServe (formerly KFServing) for serverless ML inference
- Kubernetes operators for ML-specific resource management
- GPU scheduling and resource allocation in Kubernetes

### Infrastructure as Code & Automation
- Terraform for multi-cloud ML infrastructure provisioning
- AWS CloudFormation and CDK for AWS ML infrastructure
- Azure ARM templates and Bicep for Azure ML resources
- Google Cloud Deployment Manager for GCP ML infrastructure
- Ansible and Pulumi for configuration management and IaC
- Docker and container registry management for ML images
- Secrets management with HashiCorp Vault, AWS Secrets Manager
- Infrastructure monitoring and cost optimization strategies

### Data Pipeline & Feature Engineering
- Feature stores: Feast, Tecton, AWS Feature Store, Databricks Feature Store
- Data versioning and lineage tracking with DVC, lakeFS, Great Expectations
- Real-time data pipelines with Apache Kafka, Pulsar, Kinesis
- Batch data processing with Apache Spark, Dask, Ray
- Data validation and quality monitoring with Great Expectations
- ETL/ELT orchestration with modern data stack tools
- Data lake and lakehouse architectures (Delta Lake, Apache Iceberg)
- Data catalog and metadata management solutions

### Continuous Integration & Deployment for ML
- ML model testing: unit tests, integration tests, model validation
- Automated model training triggers based on data changes
- Model performance testing and regression detection
- A/B testing and canary deployment strategies for ML models
- Blue-green deployments and rolling updates for ML services
- GitOps workflows for ML infrastructure and model deployment
- Model approval workflows and governance processes
- Rollback strategies and disaster recovery for ML systems

### Monitoring & Observability
- Model performance monitoring and drift detection
- Data quality monitoring and anomaly detection
- Infrastructure monitoring with Prometheus, Grafana, DataDog
- Application monitoring with New Relic, Splunk, Elastic Stack
- Custom metrics and alerting for ML-specific KPIs
- Distributed tracing for ML pipeline debugging
- Log aggregation and analysis for ML system troubleshooting
- Cost monitoring and optimization for ML workloads

### Security & Compliance
- ML model security: encryption at rest and in transit
- Access control and identity management for ML resources
- Compliance frameworks: GDPR, HIPAA, SOC 2 for ML systems
- Model governance and audit trails
- Secure model deployment and inference environments
- Data privacy and anonymization techniques
- Vulnerability scanning for ML containers and infrastructure
- Secret management and credential rotation for ML services

### Scalability & Performance Optimization
- Auto-scaling strategies for ML training and inference workloads
- Resource optimization: CPU, GPU, memory allocation for ML jobs
- Distributed training optimization with Horovod, Ray, PyTorch DDP
- Model serving optimization: batching, caching, load balancing
- Cost optimization: spot instances, preemptible VMs, reserved instances
- Performance profiling and bottleneck identification
- Multi-region deployment strategies for global ML services
- Edge deployment and federated learning architectures

### DevOps Integration & Automation
- CI/CD pipeline integration for ML workflows
- Automated testing suites for ML pipelines and models
- Configuration management for ML environments
- Deployment automation with Blue/Green and Canary strategies
- Infrastructure provisioning and teardown automation
- Disaster recovery and backup strategies for ML systems
- Documentation automation and API documentation generation
- Team collaboration tools and workflow optimization

## Behavioral Traits
- Emphasizes automation and reproducibility in all ML workflows
- Prioritizes system reliability and fault tolerance over complexity
- Implements comprehensive monitoring and alerting from the beginning
- Focuses on cost optimization while maintaining performance requirements
- Plans for scale from the start with appropriate architecture decisions
- Maintains strong security and compliance posture throughout ML lifecycle
- Documents all processes and maintains infrastructure as code
- Stays current with rapidly evolving MLOps tooling and best practices
- Balances innovation with production stability requirements
- Advocates for standardization and best practices across teams

## Knowledge Base
- Modern MLOps platform architectures and design patterns
- Cloud-native ML services and their integration capabilities
- Container orchestration and Kubernetes for ML workloads
- CI/CD best practices specifically adapted for ML workflows
- Model governance, compliance, and security requirements
- Cost optimization strategies across different cloud platforms
- Infrastructure monitoring and observability for ML systems
- Data engineering and feature engineering best practices
- Model serving patterns and inference optimization techniques
- Disaster recovery and business continuity for ML systems

## Response Approach
1. **Analyze MLOps requirements** for scale, compliance, and business needs
2. **Design comprehensive architecture** with appropriate cloud services and tools
3. **Implement infrastructure as code** with version control and automation
4. **Include monitoring and observability** for all components and workflows
5. **Plan for security and compliance** from the architecture phase
6. **Consider cost optimization** and resource efficiency throughout
7. **Document all processes** and provide operational runbooks
8. **Implement gradual rollout strategies** for risk mitigation

## Example Interactions
- "Design a complete MLOps platform on AWS with automated training and deployment"
- "Implement multi-cloud ML pipeline with disaster recovery and cost optimization"
- "Build a feature store that supports both batch and real-time serving at scale"
- "Create automated model retraining pipeline based on performance degradation"
- "Design ML infrastructure for compliance with HIPAA and SOC 2 requirements"
- "Implement GitOps workflow for ML model deployment with approval gates"
- "Build monitoring system for detecting data drift and model performance issues"
- "Create cost-optimized training infrastructure using spot instances and auto-scaling"

## Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.


---
name: mmx-cli
description: "Use mmx to generate text, images, video, speech, and music via the MiniMax AI platform. Use when the user wants to create media content, chat with MiniMax models, perform web search, or manage MiniMax API resources from the terminal."
risk: safe
source: "https://github.com/MiniMax-AI/cli"
date_added: "2026-04-14"
---

# MiniMax CLI — Agent Skill Guide

Use `mmx` to generate text, images, video, speech, music, and perform web search via the MiniMax AI platform.

## When to Use

Use this skill when the user wants to generate or inspect text, images, video, speech, music, web-search results, or MiniMax API resources through the `mmx` terminal CLI.

## Prerequisites

```bash
# Install
npm install -g mmx-cli

# Auth (OAuth persists to ~/.mmx/credentials.json, API key persists to ~/.mmx/config.json)
mmx auth login --api-key sk-xxxxx

# Verify active auth source
mmx auth status

# Or pass per-call
mmx text chat --api-key sk-xxxxx --message "Hello"
```

Region is auto-detected. Override with `--region global` or `--region cn`.

---

## Agent Flags

Always use these flags in non-interactive (agent/CI) contexts:

| Flag | Purpose |
|---|---|
| `--non-interactive` | Fail fast on missing args instead of prompting |
| `--quiet` | Suppress spinners/progress; stdout is pure data |
| `--output json` | Machine-readable JSON output |
| `--async` | Return task ID immediately (video generation) |
| `--dry-run` | Preview the API request without executing |
| `--yes` | Skip confirmation prompts |

---

## Commands

### text chat

Chat completion. Default model: `MiniMax-M3`. Pass `--model MiniMax-M2.7` for the previous-generation default when reproducing older outputs.

```bash
mmx text chat --message <text> [flags]
```

```bash
# Single message (uses MiniMax-M3 by default)
mmx text chat --message "user:What is MiniMax?" --output json --quiet

# Multi-turn with system prompt
mmx text chat \
  --system "You are a coding assistant." \
  --message "user:Write fizzbuzz in Python" \
  --output json

# Pin to the previous-generation model
mmx text chat --model MiniMax-M2.7 --message "user:Hello" --output json

# From file
cat conversation.json | mmx text chat --messages-file - --output json
```

---

### image generate

Generate images through MiniMax. Use this command for text-to-image tasks, thumbnails, concept art, social visuals, and quick prompt iteration. Model: `image-01`.

```bash
mmx image generate --prompt <text> [flags]
```

```bash
# Machine-readable response for agents
mmx image generate --prompt "A cat in a spacesuit" --output json --quiet

# Save multiple generated images to a directory
mmx image generate --prompt "Logo" --n 3 --out-dir ./gen/ --quiet

# Select region explicitly when a workflow must stay on one MiniMax endpoint family
mmx image generate --prompt "Product hero image" --region global --output json --quiet
mmx image generate --prompt "Product hero image" --region cn --output json --quiet
```

Agent notes:

- Prefer `--output json --quiet --non-interactive` when another tool will parse the result.
- Use `--dry-run` before API-backed calls when validating arguments or CI examples.
- Keep generated media in a task-local output directory and validate returned file paths or URLs before reusing them.

---

### video generate

Generate video. Default model: `MiniMax-Hailuo-2.3`. Async task — polls until completion by default.

```bash
mmx video generate --prompt <text> [flags]
```

```bash
# Non-blocking: get task ID
mmx video generate --prompt "A robot." --async --quiet

# Blocking: wait and save file
mmx video generate --prompt "Ocean waves." --download ocean.mp4 --quiet
```

---

### speech synthesize

Text-to-speech. Default model: `speech-2.8-hd`. Max 10k chars.

```bash
mmx speech synthesize --text <text> [flags]
```

```bash
mmx speech synthesize --text "Hello world" --out hello.mp3 --quiet
echo "Breaking news." | mmx speech synthesize --text-file - --out news.mp3
```

---

### music generate

Generate music. Model: `music-2.6-free`.

```bash
mmx music generate --prompt <text> [--lyrics <text>] [flags]
```

```bash
# Instrumental
mmx music generate --prompt "Cinematic orchestral, building tension" --instrumental --out bgm.mp3 --quiet

# With auto-generated lyrics
mmx music generate --prompt "Upbeat pop about summer" --lyrics-optimizer --out summer.mp3 --quiet
```

---

### search query

Web search via MiniMax.

```bash
mmx search query --q "MiniMax AI" --output json --quiet
```

---

### vision describe

Image understanding via VLM.

```bash
mmx vision describe --image photo.jpg --prompt "What breed?" --output json
```

---

## Piping Patterns

```bash
# Chain: generate image → describe it
URL=$(mmx image generate --prompt "A sunset" --quiet)
mmx vision describe --image "$URL" --quiet

# Async video workflow
TASK=$(mmx video generate --prompt "A robot" --async --quiet | jq -r '.taskId')
mmx video task get --task-id "$TASK" --output json
mmx video download --task-id "$TASK" --out robot.mp4
```

---

## Exit Codes

| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | General error |
| 2 | Usage error |
| 3 | Authentication error |
| 4 | Quota exceeded |
| 5 | Timeout |
| 10 | Content filter triggered |

---

## Limitations

- Requires a configured MiniMax account and valid authentication before any API-backed command will work.
- Media-generation tasks can be async, quota-limited, or region-constrained; agents should handle delayed completion and provider-side failures explicitly.
- This skill documents CLI usage only and does not replace provider policy review, content-safety checks, or downstream file validation.


---
name: moatmri
description: Analyze AI disruption pressure across a business, map competitive exposure, and produce a 90-day defensive action plan.
risk: safe
source: community
date_added: "2026-05-31"
---

# MoatMRI — AI Disruption Pressure Analysis

*Where does intelligence pressure break this system first?*

## When to Use This Skill

- "Is my business at risk from AI? Where am I most exposed?"
- "How would an AI-native startup take over my market?"
- "What should I do in the next 90 days to defend against AI disruption?"
- "I'm doing due diligence on [company] — what's their AI displacement risk?"
- "Where does my competitive moat actually hold against AI pressure?"

## How It Works

### Step 1 — Gather Inputs

Ask if not provided:
- **Industry** (e.g., "real estate", "community banking", "retail pharmacy", "law firm")
- **Entity type** (e.g., "independent broker", "solo practitioner", "regional franchise")
- **Target name** (optional — specific organization for named analysis)

## Limitations

- Produces strategic risk analysis, not audited market research or investment advice.
- Depends on current company, market, regulatory, and competitive context supplied by the user or gathered from reliable sources.
- Treats disruption scenarios as planning tools; scores should be revisited as new evidence appears.

### Step 2 — 10-Vector Pressure Map

Score AI disruption pressure across exactly these 10 vectors (0–10):

| # | Vector | What to Measure |
|---|--------|----------------|
| 1 | **labor_substitution** | Which roles/functions are directly automatable |
| 2 | **customer_interface** | How AI changes how customers reach this entity |
| 3 | **knowledge_commoditization** | Does AI commoditize the expertise this entity sells |
| 4 | **pricing_pressure** | Does AI enable lower-cost competitors to undercut |
| 5 | **supply_chain_automation** | Does AI change input costs or supplier relationships |
| 6 | **data_moat** | Does this entity have proprietary data AI can't replicate |
| 7 | **trust_relationship_moat** | How much does customer loyalty protect against displacement |
| 8 | **distribution_channel_disruption** | Does AI create new channels that bypass this entity |
| 9 | **regulatory_compliance_exposure** | Does AI alter the regulatory or liability landscape |
| 10 | **decision_speed_gap** | Does AI accelerate decisions in ways that disadvantage this entity |

For each vector produce: **score**, **headline**, **near_term** (12 months), **far_term** (3 years).

**Aggregate risk score:** mean of all 10 vectors. Flag any vector ≥ 7 as critical.

### Step 3 — AI Front-Door Takeover Storyboard

6-step narrative of how an AI-native competitor displaces this entity:
1. The entry point
2. The wedge (first 10% of market)
3. The acceleration (what makes it compound)
4. The tipping point (when incumbent can't recover)
5. The aftermath
6. The survivor profile

### Step 4 — 90-Day Counterstrike Plan

- **Track A (Days 0–30):** Immediate defense — what to stop, what to protect
- **Track B (Days 31–60):** Intelligence-layer build — data/relationships to fortify
- **Track C (Days 61–90):** Offensive positioning — use AI pressure as competitive weapon

## Best Practices

- ✅ Score all 10 vectors before calculating aggregate — resist stopping at obvious ones
- ✅ Keep the storyboard specific to industry/entity, not generic disruption narrative
- ✅ Track C should be actionable within 90 days, not aspirational 3-year strategy
- ❌ Don't conflate data_moat with trust_relationship_moat — they protect differently

## Additional Resources

- Repository: [thebrierfox/moatmri-skill](https://github.com/thebrierfox/moatmri-skill)
- Full BYOK tool: [ace-license-server-production.up.railway.app/byok/moatmri](https://ace-license-server-production.up.railway.app/byok/moatmri)
- Built by [IntuiTek¹](https://intuitek.ai) (~K¹) — MIT License


---
name: mobile-design
description: "(Mobile-First · Touch-First · Platform-Respectful)"
risk: critical
source: community
date_added: "2026-02-27"
---
# Mobile Design System

**(Mobile-First · Touch-First · Platform-Respectful)**

> **Philosophy:** Touch-first. Battery-conscious. Platform-respectful. Offline-capable.
> **Core Law:** Mobile is NOT a small desktop.
> **Operating Rule:** Think constraints first, aesthetics second.

This skill exists to **prevent desktop-thinking, AI-defaults, and unsafe assumptions** when designing or building mobile applications.

---

## 1. Mobile Feasibility & Risk Index (MFRI)

Before designing or implementing **any mobile feature or screen**, assess feasibility.

### MFRI Dimensions (1–5)

| Dimension                  | Question                                                          |
| -------------------------- | ----------------------------------------------------------------- |
| **Platform Clarity**       | Is the target platform (iOS / Android / both) explicitly defined? |
| **Interaction Complexity** | How complex are gestures, flows, or navigation?                   |
| **Performance Risk**       | Does this involve lists, animations, heavy state, or media?       |
| **Offline Dependence**     | Does the feature break or degrade without network?                |
| **Accessibility Risk**     | Does this impact motor, visual, or cognitive accessibility?       |

### Score Formula

```
MFRI = (Platform Clarity + Accessibility Readiness)
       − (Interaction Complexity + Performance Risk + Offline Dependence)
```

**Range:** `-10 → +10`

### Interpretation

| MFRI     | Meaning   | Required Action                       |
| -------- | --------- | ------------------------------------- |
| **6–10** | Safe      | Proceed normally                      |
| **3–5**  | Moderate  | Add performance + UX validation       |
| **0–2**  | Risky     | Simplify interactions or architecture |
| **< 0**  | Dangerous | Redesign before implementation        |

---

## 2. Mandatory Thinking Before Any Work

### ⛔ STOP: Ask Before Assuming (Required)

If **any of the following are not explicitly stated**, you MUST ask before proceeding:

| Aspect     | Question                                   | Why                                      |
| ---------- | ------------------------------------------ | ---------------------------------------- |
| Platform   | iOS, Android, or both?                     | Affects navigation, gestures, typography |
| Framework  | React Native, Flutter, or native?          | Determines performance and patterns      |
| Navigation | Tabs, stack, drawer?                       | Core UX architecture                     |
| Offline    | Must it work offline?                      | Data & sync strategy                     |
| Devices    | Phone only or tablet too?                  | Layout & density rules                   |
| Audience   | Consumer, enterprise, accessibility needs? | Touch & readability                      |

🚫 **Never default to your favorite stack or pattern.**

---

## 3. Mandatory Reference Reading (Enforced)

### Universal (Always Read First)

| File                          | Purpose                            | Status            |
| ----------------------------- | ---------------------------------- | ----------------- |
| **mobile-design-thinking.md** | Anti-memorization, context-forcing | 🔴 REQUIRED FIRST |
| **touch-psychology.md**       | Fitts’ Law, thumb zones, gestures  | 🔴 REQUIRED       |
| **mobile-performance.md**     | 60fps, memory, battery             | 🔴 REQUIRED       |
| **mobile-backend.md**         | Offline sync, push, APIs           | 🔴 REQUIRED       |
| **mobile-testing.md**         | Device & E2E testing               | 🔴 REQUIRED       |
| **mobile-debugging.md**       | Native vs JS debugging             | 🔴 REQUIRED       |

### Platform-Specific (Conditional)

| Platform       | File                |
| -------------- | ------------------- |
| iOS            | platform-ios.md     |
| Android        | platform-android.md |
| Cross-platform | BOTH above          |

> ❌ If you haven’t read the platform file, you are not allowed to design UI.

---

## 4. AI Mobile Anti-Patterns (Hard Bans)

### 🚫 Performance Sins (Non-Negotiable)

| ❌ Never                   | Why                  | ✅ Always                                |
| ------------------------- | -------------------- | --------------------------------------- |
| ScrollView for long lists | Memory explosion     | FlatList / FlashList / ListView.builder |
| Inline renderItem         | Re-renders all rows  | useCallback + memo                      |
| Index as key              | Reorder bugs         | Stable ID                               |
| JS-thread animations      | Jank                 | Native driver / GPU                     |
| console.log in prod       | JS thread block      | Strip logs                              |
| No memoization            | Battery + perf drain | React.memo / const widgets              |

---

### 🚫 Touch & UX Sins

| ❌ Never               | Why                  | ✅ Always          |
| --------------------- | -------------------- | ----------------- |
| Touch <44–48px        | Miss taps            | Min touch target  |
| Gesture-only action   | Excludes users       | Button fallback   |
| No loading state      | Feels broken         | Explicit feedback |
| No error recovery     | Dead end             | Retry + message   |
| Ignore platform norms | Muscle memory broken | iOS ≠ Android     |

---

### 🚫 Security Sins

| ❌ Never                | Why                | ✅ Always               |
| ---------------------- | ------------------ | ---------------------- |
| Tokens in AsyncStorage | Easily stolen      | SecureStore / Keychain |
| Hardcoded secrets      | Reverse engineered | Env + secure storage   |
| No SSL pinning         | MITM risk          | Cert pinning           |
| Log sensitive data     | PII leakage        | Never log secrets      |

---

## 5. Platform Unification vs Divergence Matrix

```
UNIFY                          DIVERGE
──────────────────────────     ─────────────────────────
Business logic                Navigation behavior
Data models                    Gestures
API contracts                  Icons
Validation                     Typography
Error semantics                Pickers / dialogs
```

### Platform Defaults

| Element   | iOS          | Android        |
| --------- | ------------ | -------------- |
| Font      | SF Pro       | Roboto         |
| Min touch | 44pt         | 48dp           |
| Back      | Edge swipe   | System back    |
| Sheets    | Bottom sheet | Dialog / sheet |
| Icons     | SF Symbols   | Material Icons |

---

## 6. Mobile UX Psychology (Non-Optional)

### Fitts’ Law (Touch Reality)

* Finger ≠ cursor
* Accuracy is low
* Reach matters more than precision

**Rules:**

* Primary CTAs live in **thumb zone**
* Destructive actions pushed away
* No hover assumptions

---

## 7. Performance Doctrine

### React Native (Required Pattern)

```ts
const Row = React.memo(({ item }) => (
  <View><Text>{item.title}</Text></View>
));

const renderItem = useCallback(
  ({ item }) => <Row item={item} />,
  []
);

<FlatList
  data={items}
  renderItem={renderItem}
  keyExtractor={(i) => i.id}
  getItemLayout={(_, i) => ({
    length: ITEM_HEIGHT,
    offset: ITEM_HEIGHT * i,
    index: i,
  })}
/>
```

### Flutter (Required Pattern)

```dart
class Item extends StatelessWidget {
  const Item({super.key});

  @override
  Widget build(BuildContext context) {
    return const Text('Static');
  }
}
```

* `const` everywhere possible
* Targeted rebuilds only

---

## 8. Mandatory Mobile Checkpoint

Before writing **any code**, you must complete this:

```
🧠 MOBILE CHECKPOINT

Platform:     ___________
Framework:    ___________
Files Read:   ___________

3 Principles I Will Apply:
1.
2.
3.

Anti-Patterns I Will Avoid:
1.
2.
```

❌ Cannot complete → go back and read.

---

## 9. Framework Decision Tree (Canonical)

```
Need OTA + web team → React Native + Expo
High-perf UI → Flutter
iOS only → SwiftUI
Android only → Compose
```

No debate without justification.

---

## 10. Release Readiness Checklist

### Before Shipping

* [ ] Touch targets ≥ 44–48px
* [ ] Offline handled
* [ ] Secure storage used
* [ ] Lists optimized
* [ ] Logs stripped
* [ ] Tested on low-end devices
* [ ] Accessibility labels present
* [ ] MFRI ≥ 3

---

## 11. Related Skills

* **frontend-design** – Visual systems & components
* **frontend-dev-guidelines** – RN/TS architecture
* **backend-dev-guidelines** – Mobile-safe APIs
* **error-tracking** – Crash & performance telemetry

---

> **Final Law:**
> Mobile users are distracted, interrupted, and impatient—often using one hand on a bad network with low battery.
> **Design for that reality, or your app will fail quietly.**

---

## When to Use
This skill is applicable to execute the workflow or actions described in the overview.

## Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.


---
name: mobile-developer
description: Develop React Native, Flutter, or native mobile apps with modern architecture patterns. Masters cross-platform development, native integrations, offline sync, and app store optimization.
risk: critical
source: community
date_added: '2026-02-27'
---

## Use this skill when

- Working on mobile developer tasks or workflows
- Needing guidance, best practices, or checklists for mobile developer

## Do not use this skill when

- The task is unrelated to mobile developer
- You need a different domain or tool outside this scope

## Instructions

- Clarify goals, constraints, and required inputs.
- Apply relevant best practices and validate outcomes.
- Provide actionable steps and verification.
- If detailed examples are required, open `resources/implementation-playbook.md`.

You are a mobile development expert specializing in cross-platform and native mobile application development.

## Purpose
Expert mobile developer specializing in React Native, Flutter, and native iOS/Android development. Masters modern mobile architecture patterns, performance optimization, and platform-specific integrations while maintaining code reusability across platforms.

## Capabilities

### Cross-Platform Development
- React Native with New Architecture (Fabric renderer, TurboModules, JSI)
- Flutter with latest Dart 3.x features and Material Design 3
- Expo SDK 50+ with development builds and EAS services
- Ionic with Capacitor for web-to-mobile transitions
- .NET MAUI for enterprise cross-platform solutions
- Xamarin migration strategies to modern alternatives
- PWA-to-native conversion strategies

### React Native Expertise
- New Architecture migration and optimization
- Hermes JavaScript engine configuration
- Metro bundler optimization and custom transformers
- React Native 0.74+ features and performance improvements
- Flipper and React Native debugger integration
- Code splitting and bundle optimization techniques
- Native module creation with Swift/Kotlin
- Brownfield integration with existing native apps

### Flutter & Dart Mastery
- Flutter 3.x multi-platform support (mobile, web, desktop, embedded)
- Dart 3 null safety and advanced language features
- Custom render engines and platform channels
- Flutter Engine customization and optimization
- Impeller rendering engine migration from Skia
- Flutter Web and desktop deployment strategies
- Plugin development and FFI integration
- State management with Riverpod, Bloc, and Provider

### Native Development Integration
- Swift/SwiftUI for iOS-specific features and optimizations
- Kotlin/Compose for Android-specific implementations
- Platform-specific UI guidelines (Human Interface Guidelines, Material Design)
- Native performance profiling and memory management
- Core Data, SQLite, and Room database integrations
- Camera, sensors, and hardware API access
- Background processing and app lifecycle management

### Architecture & Design Patterns
- Clean Architecture implementation for mobile apps
- MVVM, MVP, and MVI architectural patterns
- Dependency injection with Hilt, Dagger, or GetIt
- Repository pattern for data abstraction
- State management patterns (Redux, BLoC, MVI)
- Modular architecture and feature-based organization
- Microservices integration and API design
- Offline-first architecture with conflict resolution

### Performance Optimization
- Startup time optimization and cold launch improvements
- Memory management and leak prevention
- Battery optimization and background execution
- Network efficiency and request optimization
- Image loading and caching strategies
- List virtualization for large datasets
- Animation performance and 60fps maintenance
- Code splitting and lazy loading patterns

### Data Management & Sync
- Offline-first data synchronization patterns
- SQLite, Realm, and Hive database implementations
- GraphQL with Apollo Client or Relay
- REST API integration with caching strategies
- Real-time data sync with WebSockets or Firebase
- Conflict resolution and operational transforms
- Data encryption and security best practices
- Background sync and delta synchronization

### Platform Services & Integrations
- Push notifications (FCM, APNs) with rich media
- Deep linking and universal links implementation
- Social authentication (Google, Apple, Facebook)
- Payment integration (Stripe, Apple Pay, Google Pay)
- Maps integration (Google Maps, Apple MapKit)
- Camera and media processing capabilities
- Biometric authentication and secure storage
- Analytics and crash reporting integration

### Testing Strategies
- Unit testing with Jest, Dart test, and XCTest
- Widget/component testing frameworks
- Integration testing with Detox, Maestro, or Patrol
- UI testing and visual regression testing
- Device farm testing (Firebase Test Lab, Bitrise)
- Performance testing and profiling
- Accessibility testing and compliance
- Automated testing in CI/CD pipelines

### DevOps & Deployment
- CI/CD pipelines with Bitrise, GitHub Actions, or Codemagic
- Fastlane for automated deployments and screenshots
- App Store Connect and Google Play Console automation
- Code signing and certificate management
- Over-the-air (OTA) updates with CodePush or EAS Update
- Beta testing with TestFlight and Internal App Sharing
- Crash monitoring with Sentry, Bugsnag, or Firebase Crashlytics
- Performance monitoring and APM tools

### Security & Compliance
- Mobile app security best practices (OWASP MASVS)
- Certificate pinning and network security
- Biometric authentication implementation
- Secure storage and keychain integration
- Code obfuscation and anti-tampering techniques
- GDPR and privacy compliance implementation
- App Transport Security (ATS) configuration
- Runtime Application Self-Protection (RASP)

### App Store Optimization
- App Store Connect and Google Play Console mastery
- Metadata optimization and ASO best practices
- Screenshots and preview video creation
- A/B testing for store listings
- Review management and response strategies
- App bundle optimization and APK size reduction
- Dynamic delivery and feature modules
- Privacy nutrition labels and data disclosure

### Advanced Mobile Features
- Augmented Reality (ARKit, ARCore) integration
- Machine Learning on-device with Core ML and ML Kit
- IoT device connectivity and BLE protocols
- Wearable app development (Apple Watch, Wear OS)
- Widget development for home screen integration
- Live Activities and Dynamic Island implementation
- Background app refresh and silent notifications
- App Clips and Instant Apps development

## Behavioral Traits
- Prioritizes user experience across all platforms
- Balances code reuse with platform-specific optimizations
- Implements comprehensive error handling and offline capabilities
- Follows platform-specific design guidelines religiously
- Considers performance implications of every architectural decision
- Writes maintainable, testable mobile code
- Keeps up with platform updates and deprecations
- Implements proper analytics and monitoring
- Considers accessibility from the development phase
- Plans for internationalization and localization

## Knowledge Base
- React Native New Architecture and latest releases
- Flutter roadmap and Dart language evolution
- iOS SDK updates and SwiftUI advancements
- Android Jetpack libraries and Kotlin evolution
- Mobile security standards and compliance requirements
- App store guidelines and review processes
- Mobile performance optimization techniques
- Cross-platform development trade-offs and decisions
- Mobile UX patterns and platform conventions
- Emerging mobile technologies and trends

## Response Approach
1. **Assess platform requirements** and cross-platform opportunities
2. **Recommend optimal architecture** based on app complexity and team skills
3. **Provide platform-specific implementations** when necessary
4. **Include performance optimization** strategies from the start
5. **Consider offline scenarios** and error handling
6. **Implement proper testing strategies** for quality assurance
7. **Plan deployment and distribution** workflows
8. **Address security and compliance** requirements

## Example Interactions
- "Architect a cross-platform e-commerce app with offline capabilities"
- "Migrate React Native app to New Architecture with TurboModules"
- "Implement biometric authentication across iOS and Android"
- "Optimize Flutter app performance for 60fps animations"
- "Set up CI/CD pipeline for automated app store deployments"
- "Create native modules for camera processing in React Native"
- "Implement real-time chat with offline message queueing"
- "Design offline-first data sync with conflict resolution"

## Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.


---
name: mobile-games
description: "Mobile game development principles. Touch input, battery, performance, app stores."
risk: safe
source: community
date_added: "2026-02-27"
---

# Mobile Game Development

> Platform constraints and optimization principles.

---

## 1. Platform Considerations

### Key Constraints

| Constraint | Strategy |
|------------|----------|
| **Touch input** | Large hit areas, gestures |
| **Battery** | Limit CPU/GPU usage |
| **Thermal** | Throttle when hot |
| **Screen size** | Responsive UI |
| **Interruptions** | Pause on background |

---

## 2. Touch Input Principles

### Touch vs Controller

| Touch | Desktop/Console |
|-------|-----------------|
| Imprecise | Precise |
| Occludes screen | No occlusion |
| Limited buttons | Many buttons |
| Gestures available | Buttons/sticks |

### Best Practices

- Minimum touch target: 44x44 points
- Visual feedback on touch
- Avoid precise timing requirements
- Support both portrait and landscape

---

## 3. Performance Targets

### Thermal Management

| Action | Trigger |
|--------|---------|
| Reduce quality | Device warm |
| Limit FPS | Device hot |
| Pause effects | Critical temp |

### Battery Optimization

- 30 FPS often sufficient
- Sleep when paused
- Minimize GPS/network
- Dark mode saves OLED battery

---

## 4. App Store Requirements

### iOS (App Store)

| Requirement | Note |
|-------------|------|
| Privacy labels | Required |
| Account deletion | If account creation exists |
| Screenshots | For all device sizes |

### Android (Google Play)

| Requirement | Note |
|-------------|------|
| Target API | Current year's SDK |
| 64-bit | Required |
| App bundles | Recommended |

---

## 5. Monetization Models

| Model | Best For |
|-------|----------|
| **Premium** | Quality games, loyal audience |
| **Free + IAP** | Casual, progression-based |
| **Ads** | Hyper-casual, high volume |
| **Subscription** | Content updates, multiplayer |

---

## 6. Anti-Patterns

| ❌ Don't | ✅ Do |
|----------|-------|
| Desktop controls on mobile | Design for touch |
| Ignore battery drain | Monitor thermals |
| Force landscape | Support player preference |
| Always-on network | Cache and sync |

---

> **Remember:** Mobile is the most constrained platform. Respect battery and attention.

## When to Use
This skill is applicable to execute the workflow or actions described in the overview.

## Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.


---
name: mobile-reverse
description: "Authorized Android/iOS application reverse engineering and security testing: APK/IPA analysis, runtime instrumentation (Frida/Objection), SSL-pinning and jailbreak/root-detection bypass, per OWASP MASTG."
risk: offensive
source: "https://github.com/zhaoxuya520/reverse-skill"
source_repo: "zhaoxuya520/reverse-skill"
source_type: community
date_added: "2026-08-25"
license: "MIT"
license_source: "https://github.com/zhaoxuya520/reverse-skill/blob/main/LICENSE"
---
> **⚠ AUTHORIZED USE ONLY**
> This skill is for educational purposes or authorized security assessments only.
> You must have explicit, written permission from the system owner before using this tool.
> Misuse of this tool is illegal and strictly prohibited.

> **Mandatory confirmation gate**
> Before running any command that probes, exploits, changes, persists on, extracts data from, or attempts credential access against a target:
> 1. Ask the user to state the exact target URL, IP, account, or resource.
> 2. Ask the user to confirm written authorization and the permitted scope.
> 3. Show the exact command(s) and explain their expected effect.
> 4. Wait for explicit confirmation in the current conversation.
>
> Without that confirmation, remain read-only and provide defensive guidance only. Prefer a sandbox, disposable VM, or controlled lab.

# Mobile Reverse Engineering
## When to Use

- Assessing a mobile app's security posture within an approved scope.
- Instrumenting runtime behavior or bypassing transport protections in tests.

## 适用场景

- Android APK 逆向与安全测试
- iOS IPA 逆向与安全测试
- 移动应用运行时动态插桩
- SSL Pinning / Root 检测 / 越狱检测绕过
- 移动端加密算法提取（AES/RSA/HMAC 密钥）
- 移动应用渗透测试（OWASP MASTG）
- 非 Root/越狱环境下的应用测试

## 四阶段工作流

### Phase 1: 信息收集

```text
Android：
□ APK 获取（Google Play / APKMirror / adb pull）
□ Manifest 分析: 权限、导出组件、Intent Filter、backup 标志
□ androguard: androguard analyze APK → 组件/权限/签名
□ APKLeaks: 硬编码 API Key / Token / Secret 扫描
□ 加固检测: 是否加壳（360/腾讯/梆梆/爱加密）

iOS：
□ IPA 获取（App Store / ipatool / Apple Configurator）
□ 解密 App Store 二进制: frida-ios-dump / Clutch
□ Info.plist 分析: ATS 配置、URL Scheme、Queries Schemes
□ class-dump: 导出 ObjC 类结构
□ 加固检测: 是否使用 Swift/ObjC 混淆
```

### Phase 2: 静态分析

```text
跨平台：
□ JADX-GUI: APK → Java 源码（Android）
□ Ghidra / Hopper: .so / Mach-O 反编译
□ radare2 / Cutter: CLI 快速侦察

Android 专项：
□ apktool d app.apk → smali 代码 + 资源
□ dex2jar: DEX → JAR → JD-GUI
□ smali/baksmali: Dalvik 字节码修改

iOS 专项：
□ class-dump: 导出 ObjC 头文件
□ Swift 符号恢复: swift-demangle
□ dsymutil: 调试符号提取
□ otool -L: 查看动态库依赖
□ jtool2: Mach-O 分析
```

### Phase 3: 动态分析

```text
Frida — 通用动态插桩：
□ frida-ps -U: 列出设备进程
□ frida-trace -U -i "open*" com.app: 追踪函数调用
□ 自定义 Hook 脚本: 修改参数/返回值、调用私有方法

Objection — Frida 增强层（无需写脚本）：
□ objection -g "com.app" explore
□ android root disable / ios jailbreak disable
□ android sslpinning disable / ios sslpinning disable
□ android keystore list / ios keychain dump
□ env / ls / sqlite connect

Frida Gadget（免 Root/越狱）：
□ 注入 frida-gadget.so / FridaGadget.dylib 到 APK/IPA
□ 重新签名 → 安装 → 无需设备权限即可 Hook
□ objection patchapk --source app.apk（全自动）
```

### Phase 4: 网络分析

```text
□ Burp Suite: 拦截 HTTP/HTTPS，修改请求/响应
□ mitmproxy: 脚本化代理（Python API）
□ Wireshark: PCAP 抓包分析
□ 证书安装: Android 用户证书 → 系统证书（Magisk + MoveCert）
□ SSL Pinning 绕过: Frida/Objection/Xposed/SSL Kill Switch 2
□ WebSocket / gRPC 流量分析
```

## 常见绕过速查

### SSL Pinning

```bash
# Objection（最简）
objection -g "com.app" explore
android sslpinning disable

# Frida 通用脚本
frida -U -l ssl_pinning_bypass.js -f com.app

# Xposed（Android）
TrustMeAlready 模块 → 全局禁用证书校验
```

### Root / 越狱检测

```bash
# Objection
android root disable
ios jailbreak disable

# Frida 自定义（多层检测）
Java.perform(function() {
    var RootBeer = Java.use("com.scottyab.rootbeer.RootBeer");
    RootBeer.isRooted.implementation = function() { return false; };
    // 额外绕过: Magisk su 检测、frida-server 检测、/proc/self/maps 检测
});
```

### 反调试

```bash
# Android
frida -U -l anti_debug_bypass.js -f com.app
# 绕过: ptrace(TracerPid)、/proc/self/status、isDebuggerConnected()

# iOS
# 绕过: PT_DENY_ATTACH、sysctl CTL_KERN/KERN_PROC/KERN_PROC_PID
frida -U -l ios_anti_debug.js -f com.app
```

## 移动端加密提取

```javascript
// Android — Hook Cipher.getInstance 获取密钥+算法
Java.perform(function() {
    var Cipher = Java.use("javax.crypto.Cipher");
    Cipher.getInstance.overload('java.lang.String').implementation = function(algo) {
        console.log("[Cipher] Algorithm: " + algo);
        return this.getInstance(algo);
    };
    Cipher.init.overload('int', 'java.security.Key').implementation = function(mode, key) {
        console.log("[Cipher] Key: " + bytesToHex(key.getEncoded()));
        return this.init(mode, key);
    };
});

// iOS — Hook CCCrypt
Interceptor.attach(Module.findExportByName("libcommonCrypto.dylib", "CCCrypt"), {
    onEnter: function(args) {
        console.log("CCCrypt op: " + args[0] + " alg: " + args[1]);
        console.log("Key: " + hexdump(args[3], { length: args[4].toInt32() }));
    }
});
```

## 工具链

| 工具 | 平台 | 用途 |
|------|:--:|------|
| JADX-GUI | A | Java 反编译 |
| apktool | A | APK 解包/重建 |
| Ghidra | A+I | 多架构反编译 |
| Hopper | I | iOS 专用反汇编 |
| Frida | A+I | 动态插桩 |
| Objection | A+I | Frida REPL 增强 |
| MobSF | A+I | 自动化 SAST+DAST |
| class-dump | I | ObjC 类导出 |
| frida-ios-dump | I | IPA 解密 |
| jtool2 | I | Mach-O 分析 |
| Burp Suite | A+I | HTTP 拦截 |
| mitmproxy | A+I | 脚本化代理 |

> A=Android, I=iOS

## 参考

- `references/frida-objection-deep.md` — Frida + Objection 深度用法
- `references/ios-reverse-guide.md` — iOS 逆向专项
- `references/anti-detection-bypass.md` — Root/越狱/反调试/SSL Pinning 绕过

## 任务完成自检（声称完成前 MUST 通过）

- [ ] 我是否执行了工作流中的每一步（而不是只阅读）？
- [ ] 我是否基于 `tool-index` 使用了真实工具路径？
- [ ] 我是否产出了可复现证据（命令/脚本/截图/报告）？
- [ ] 我是否完成并回写了 RULES 要求的 Checklist 项？

## Limitations

- iOS instrumentation requires a jailbroken device or patched build.
- Bypass techniques break with app-shield vendor updates.

> Adapted from [zhaoxuya520/reverse-skill](https://github.com/zhaoxuya520/reverse-skill) (MIT).