simota Skills

Authoring unified specification packages across Business/Development/Design teams via staged elaboration (L0 Vision → L1 Requirements → L2 Team Detail → L3 Acceptance Criteria). No code. Use when authoring cross-team specs, building L0-L3 packages, or aligning Biz/Dev/Design on a single source of truth.

Building terminal UIs, CLI tools, and dev-tool integrations (linter/test-runner/build-tool wiring). Use when CLI/TUI design or implementation is needed. Language-agnostic — supports Node.js, Python, Go, and Rust.

Designing new skill agents via gap analysis, overlap detection, SKILL.md + reference generation, and Nexus integration. Do not use for task orchestration (Nexus), app architecture (Atlas), or format-only audits (Gauge).

Implementing production frontend code for React/Vue/Svelte. Handles hooks design, state management, Server Components, form handling, and data fetching. Converts Forge prototypes to production-quality code.

Orchestrating design-to-implementation pipelines (code-to-visual-to-code closed loop). Persists a project design system across downstream agents. Use when a request spans design extraction, prototypes, visual assets, slides, and production together. Not for single-token tweaks (Muse), single prototype (Forge), direction only (Vision), or generic orchestration (Nexus).

Analyzing dependencies, circular references, and God Classes; authoring ADRs/RFCs. Use for architecture improvement, module decomposition, and technical debt assessment.

Verifying spec compliance by extracting ACs from specs, adversarially checking implementation conformance, and generating BDD scenarios, traceability matrices, and evidence-based compliance reports. No code. Use when verifying impl matches spec (PRD/SRS/AC) or producing machine-adjudicated conformance proof for a PR.

Orchestrating super-premium landing-page studio chains. Orchestrates the full LP pipeline (Discover → Audience → Strategy → Structure → Design → Build → Optimize → Verify → Launch) across 6 craft axes (Design/Animation/Branding/Marketing/SEO/IA) with explicit rubrics and quality gates. Use when a request asks for a complete, conversion-tuned, brand-defining LP. Not for single LP section (Funnel), design-only pipeline (Atelier), product-wide build (Titan), generic orchestration (Nexus), or A/B execution (Experiment).

Engineering observability and reliability through SLO/SLI design, distributed tracing, alerting, dashboards, capacity planning, toil automation, and reliability review. Use when designing observability instrumentation, defining SLOs/SLIs, building dashboards/alerts, or reviewing reliability posture.

Optimizing frontend (re-render reduction, memoization, lazy loading) and backend (N+1 fix, indexing, caching, async) performance, including continuous auto-tuning loops (profile → parameter → optimize → verify for GC/threadpool/pool/cache/worker settings — absorbed from dial). Use when one-shot speed improvement or continuous tuning is needed.

Designing retention strategy, re-engagement, and churn prevention. Covers retention analysis frameworks, re-engagement trigger design, gamification elements, habit formation design, and loyalty programs. Use when engagement tactics are needed.

Designing red team attack scenarios, building threat models, applying MITRE ATT&CK/OWASP frameworks, running Purple Team exercises, and performing AI/LLM red teaming. Use when adversarial security validation is needed.

Implementing robust business logic, API integrations, and data models with type safety and production readiness. Use when business logic implementation or API integration is needed. Offers an interactive pair-programming mode (co-implement, confirming each increment).

Assessing standards compliance and analyzing gaps. Evaluates codebases against OWASP/WCAG/OpenAPI/ISO 25010 standards, detects violations, provides actionable remediation with citations. Use when checking industry-standard compliance (security/a11y/API/quality) or producing citation-backed audit reports.

Visualizing code/designs/context as Mermaid, ASCII, or draw.io diagrams. Reverse-generates flowcharts and sequence/state/class/ER diagrams from code or specs. Also handles Journey Maps, Emotion Score, Persona, Team Structure, DX Journey, and test telemetry visualizations (coverage heatmaps, traceability matrices, test-shape views — absorbed from vista). Use when generating diagrams from code/specs or reverse-documenting systems visually.

Casting personas via rapid generation, persistence, lifecycle management, and inter-agent sync. Generates personas from diverse inputs, manages via a registry, evolves data-driven, and distributes in unified format. Use when creating, updating, or syncing personas across agents. Not for UI walkthroughs (Echo) or user research design (Field).

Auditing skill/plugin/MCP supply chains. Treats SKILL.md, bundled scripts, MCP server defs, hooks, and `.claude/` config as third-party software. Generates sha256 manifests, scans for Unicode Tag injection, detects curl-pipe + credential-exfil patterns, enforces third-party intake checklist, and pins MCP tool descriptions against rug-pulls. Use when auditing skill/MCP supply chain. Not for app SAST (Sentinel), CI/CD (Gear/Pipe), hook design (Latch), SKILL.md format (Gauge), or runtime exploit (Probe).

Reviewing legal documents for Terms of Service, Privacy Policy, and Tokushoho compliance. Detects clause gaps, flags risks, and aligns regulatory requirements. Don't use when legal advice is needed — consult a lawyer.

Engineering privacy and data governance via PII detection, data flow mapping, consent management patterns, GDPR/CCPA-compliant code implementation, and DPIA facilitation. Use when privacy-by-design implementation is needed.

Navigating the skill ecosystem and guiding onboarding. Lists agents, recommends best fit for tasks. Don't use for task execution (Nexus), agent design (Architect).

Researching competitors, analyzing differentiation, and shaping strategic positioning. Covers feature matrices, SWOT, benchmarking, positioning maps, battle cards, win/loss, and LLM brand visibility. Research only — no code. Use when scoping competitive landscape, building positioning artifacts, or assessing LLM brand visibility.

Building engineer self-branding by transforming technical contributions into a professional brand. Use when GitHub/LinkedIn/blog/conference/SNS positioning, profile optimization, or content strategy is needed.

Designing cryptographic architecture: algorithm selection, key management, E2EE, KMS integration, signature verification, and TLS configuration. Use when designing cryptographic protocols, key rotation flows, or end-to-end encryption architectures.

Writing video scripts, storyboards, and narration designs. Used for product videos, explainer videos, and onboarding content planning.

Scanning supply-chain malware infections via IoC-based local scan + safe eradication for npm/PyPI worm campaigns (Shai-Hulud, S1ngularity, lottie-player). Detects OS persistence (LaunchAgent/systemd), IDE-hook implants (.claude/.vscode/.github/workflows), lockfile-pinned malicious versions, and C2/exfil traces. Sequences credential rotation so revocation does not trigger `rm -rf ~/` retaliation payloads. Use when worm infection is suspected. Not for SAST (Sentinel), skill/MCP audit (Chain), Sigma/YARA (Vigil), or incident coordination (Triage).

Orchestrating ecosystem self-evolution by detecting project lifecycle phases, evaluating agent relevance, synthesizing cross-agent knowledge, and proposing evolution actions (health checks, fitness scoring, structural proposals). Use when auditing skill-ecosystem health, scoring agent fitness, or proposing structural evolution.

Producing automated feature demo videos via Playwright E2E tests. Covers scenario design, recording configuration, implementation patterns, and quality checklists for product demos and onboarding materials.

Simulating users (beginners, seniors, mobile users, etc.) via persona-based cognitive walkthroughs to evaluate UI flows, report confusion points, and score emotional friction. Use when usability validation or UX problem discovery is needed.

Designing A/B tests, documenting hypotheses, calculating sample sizes, implementing feature flags, and analyzing statistical significance. Covers CUPED variance reduction, SRM detection, and switchback experiments. Use when hypothesis validation is needed.

Conducting user research via interview guides, usability test plans, qualitative data analysis, persona creation, and journey mapping. Complements Echo's UI validation. Use when user research design or analysis is needed.

Implementing CSS/JS animations for hover effects, loading states, modal transitions, and gesture interactions. Use when adding meaningful motion, improving interaction feedback, or implementing performance-safe animations.

Refracting thinking by challenging assumptions, combining cross-domain knowledge, and shifting perspectives to reframe problems. Use when breaking through stuck situations or paradigm shifts are needed. Does not write code.

Building rapid prototypes for both frontend (UI components/pages) and backend (API mocks/simple servers). Use when validating new features or turning ideas into working demos. Prioritize working software over perfection.

Extracting and structuring design context from Figma via MCP Server for downstream implementation agents. Use when Figma-to-code bridging, Code Connect management, or design system rule extraction is needed.

Constructing landing pages end-to-end via structure design, conversion strategy, CTA optimization, and responsive design. Use when creating or improving landing pages.

Designing and reviewing APIs via OpenAPI spec generation, versioning strategy, breaking change detection, and REST/GraphQL best practices. Ensures API quality and consistency. Use when API design or OpenAPI specs are needed.

Auditing SKILL.md normalization and self-evolving compliance. Scans SKILL.md files against the 19-item checklist, classifies violations, produces fix snippets, and researches emerging best practices. No code. Use when auditing SKILL.md compliance, generating fix recommendations, or running ecosystem health dashboards.

Managing dependencies, CI/CD optimization, Docker configuration, and operational observability (logging/alerting/health checks). Use when build errors, dev environment issues, or operational config fixes are needed.

Designing regex, parsers, and DSLs for grammar authoring and ReDoS-safe regex. Not for REST APIs (Gateway) or DB schemas (Schema).

Designing, optimizing, and auditing repository structure. Covers directory design, docs/ layout (PRD, specs, ADR), test/script organization, anti-pattern detection, and migration planning for existing repositories.

Optimizing SEO (meta/OGP/JSON-LD/heading hierarchy), SMO (social sharing), CRO (CTA/form/exit-intent), and GEO (AI citation optimization) across four pillars. Use when search ranking, conversion, or AI visibility improvement is needed.

Gatekeeping Git/PR by classifying change essence and recommending granularity, naming, and strategy. Use when PR preparation or commit strategy is needed.

Collecting GitHub PR data and generating work reports. Retrieves PR info via gh commands to auto-generate weekly/monthly reports and release notes. Use when work reporting or PR analysis is needed.

Generating, optimizing, and auditing personal development environment config files (zsh/tmux/neovim/ghostty), and automating the macOS desktop via AppleScript/JXA/osascript (Finder, Mail, Safari, Calendar, Notes, System Events). Use when dotfile management, shell/terminal/editor configuration, or Mac app automation and Apple Events scripting is needed.

Simulating business strategy via short/mid/long-term scenario planning from financial, market, and competitive data. Applies SWOT/PESTLE/Porter analysis, KPI forecasting, and strategic roadmap generation. Does not write code.

Auditing and optimizing AI CLI configuration. Audits Codex CLI (~/.codex/), Antigravity CLI (~/.gemini/ — `agy`), and Claude Code (~/.claude/) configs (config.toml/settings.json/CLAUDE.md/hooks/MCP) and proposes Before/After diff improvements. Never edits configs directly. Use when auditing AI CLI configs, optimizing prompt cache hierarchy, or reviewing hooks/MCP/plugins security posture.

Generating SVG icons/illustrations, designing icon systems, and constructing sprite symbols. Use when vector assets are needed.

Reviewing code via multi-engine orchestration. Orchestrates parallel review via subagents with grounding verification, shipping only findings worth fixing. Reviews on three axes — secure, correct, and lean. Default Claude + Codex (dual-engine); agy optional third axis. Use for PR review or pre-commit checks — detects bugs, vulnerabilities, logic errors, waste, and intent misalignment. Offers an interactive pair-review mode (fix-as-you-go). Complements Zen refactoring.

Proposing, configuring, debugging, and maintaining Claude Code hooks (PreToolUse/PostToolUse/Stop and other lifecycle events). Use when workflow automation, quality gates, or security enforcement via hooks is needed.

Planning, executing, and tracking releases in a unified workflow. Covers versioning strategy, CHANGELOG generation, release notes, rollback plans, and feature flag design for safe, predictable delivery.

Optimizing FinOps and cloud costs. Cost estimation from IaC, right-sizing, RI/SP recommendations, anomaly detection, budget alerts, AI/GPU workload cost analysis. Use when forecasting cloud spend, optimizing instance/reservation mix, designing budget alerts, or modeling AI/GPU economics.

Comprehending and investigating codebases. Systematically performs structure mapping, feature discovery, and data flow tracing for "does X exist?", "how does Y work?", or "what is this module's responsibility?". Includes a conversational Q&A mode ("ask") for navigator-style, multi-turn questions about a project. Does not write code.

Designing a project's operating layer — the blueprint of which project-local skills, repo-tailored recipes (task playbooks), and skill-and-agent orchestration workflows a repository needs, designed together as a coherent system. Analyzes the repo, designs the layer, then delegates skill-body authoring to Sigil and runtime routing to Nexus. Use when a repository needs a coordinated set of project agents, recipes, and orchestration workflows designed together. Don't use for authoring a single skill body (Sigil), runtime request orchestration (Nexus), autonomous loop runners (Orbit), application or business-process workflows and code-level state machines (Weave), or ecosystem-wide global agents (Architect).

Curating cross-agent knowledge and guarding institutional memory. Extracts patterns from agent journals into METAPATTERNS.md, detects knowledge decay, propagates best practices, prevents organizational forgetting. Use when consolidating cross-agent insights, curating memory, or auditing knowledge decay.

Deliberating decisions via multi-perspective lenses (Logos/Pathos/Sophia) for architecture arbitration, trade-offs, Go/No-Go, and strategic decisions. Does not write code. Don't use for architecture (Atlas), requirements (Accord), or implementation (Builder).

Controlling combinatorial explosion across multi-dimensional axes via universal combinatorial analysis. Selects minimum coverage sets, generates execution plans, and prioritizes across test/deploy/UX/risk/compatibility. No code. Use when scoping multi-axis combinations or selecting minimum-coverage subsets under combinatorial explosion.

Remediating known failure patterns automatically. Receives Triage diagnoses and Beacon alerts, executes runbooks with safety-tier classification, staged verification, and rollback. Use when automated incident remediation is needed.

Generating test data and fixtures. Use when factory pattern design, boundary value data generation, synthetic data generation, or seed data management is needed.

Converting document formats (Markdown/Word/Excel/PDF/HTML). Converts specs from Scribe and reports from Harvest into distributable formats; generates reusable conversion scripts. Use when converting documents, building accessibility-compliant PDFs, or creating Pandoc/LibreOffice pipelines.

Defining and managing design tokens, applying token systems to existing codebases, and building design system foundations. Covers token architecture for spacing, color, typography, dark mode, and cross-platform output.

Implementing pure-native app features for iOS (Swift 6.3 + SwiftUI + Liquid Glass), Android (Kotlin 2.4+ + Jetpack Compose + Material 3 Expressive), and macOS desktop (SwiftUI for Mac + AppKit interop, scenes/menu bar/document apps, sandbox + notarization + Sparkle, Mac HIG). Builds production features with @Observable/Swift Concurrency, Compose Strong Skipping, SwiftData/Room, Passkeys, Privacy Manifest, App Intents, Foundation Models/Gemini Nano, and store-compliance staged rollout. Also runs the agent visual loop for screen implementation and visual debugging against a reference design (Xcode MCP RenderPreview, XcodeBuildMCP, mobile-mcp, screenshot diffing). Use when building production iOS/Android/macOS features or iterating a native screen until it matches a design. Not for cross-platform (RN/Flutter/KMP/CMP), porting design (Port), prototypes (Forge), mockup-to-code (Pixel), automating existing Mac apps via AppleScript/JXA (Hearth), test suites (Snap/Voyager), or web (Artisan).

Designing LLM-optimized folder structures. Audits and restructures directories for context efficiency, progressive disclosure, and prompt cache performance. Don't use for general repo structure (Grove), config audit (Hone), or skill generation (Sigil).

Orchestrating specialist AI agent teams as a meta-coordinator. Decomposes requests into minimum viable chains, spawns each as an independent session in AUTORUN modes, and drives to final output. Use when a task spans multiple specialist domains, requires parallel agent execution, or needs hub-and-spoke routing across the skill ecosystem.

Auditing regulatory compliance and mapping business requirements (SOC2/PCI-DSS/HIPAA/ISO 27001), checking control implementations, designing audit trails, and implementing Policy as Code. Use when compliance auditing is needed.

Enumerating failure modes via pre-mortem analysis. Systematically identifies failure scenarios for plans, designs, and features, scoring them with RPN/AP. Does not write code.

Designing and evaluating AI/ML systems across prompt engineering, RAG design, LLM application patterns, AI safety, evaluation frameworks, MLOps, and cost optimization. Use when designing AI/ML pipelines, RAG architectures, prompt strategies, evaluation harnesses, or LLM cost models.

Running autonomous loops for nexus-autoloop. Generates script sets from goals, designs operation contracts, audits live loops, and recovers state — delivering end-to-end runners that complete reliably.

Improving usability, interaction quality, cognitive load reduction, feedback design, and a11y compliance. Use when improving UX usability or interaction feel.

Navigating project delivery status as a PdM-style read-only navigator. Reconciles planned scope (specs/issues/roadmap/PRD) against implemented code to produce feature inventories, unimplemented-feature lists, roadmap rollups, and WBS views. Use for "what's built / what's left / where are we". Don't use for code comprehension (Lens), priority scoring (Rank), spec authoring (Scribe), AC conformance (Attest), or live task execution (Sherpa).

Designing GitHub Actions workflows in depth — covering trigger strategy, security hardening, performance optimization, PR automation, and Reusable Workflow design. Use when new GHA workflow design or advanced optimization is needed.

Generating pixel-accurate HTML/CSS code from image mockups (PNG/JPG/screenshots) and performing visual verification for faithful reproduction. Use when mockup-to-code generation is needed.

Role-playing as end users to generate authentic feature requests, surface unmet needs, and challenge team assumptions as a synthetic user advocate. Don't use for real feedback analysis (Voice) or UI evaluation (Echo).

Implementing internationalization (i18n) and localization (l10n). Extracts hardcoded strings to t() functions, integrates Intl API for date/currency/number formatting, manages translation keys, and adds RTL layout support.

Designing web-to-iOS/Android porting strategies. Produces feature parity matrices, native architecture maps, platform-UX adaptation, data/auth/CRDT strategies, BFF redesigns, and Strangler-Fig phased roadmaps from React/Vue/Svelte/Angular SPAs (RSC/SSR included). Optionally proposes a hybrid path (pure-native UI + KMP shared logic). 2026 spec aware (Swift 6.3 / Compose 1.11 / Privacy Manifest / 16KB / Passkey / DMA / EAA). Use when designing web-to-native ports. Not for cross-platform UI (Native — RN/Flutter), same-language framework migration / dependency upgrades / modernization (Shift), legacy archaeology (Trail `static-rules`), or pure-native impl (Native).

Integrating OWASP ZAP/Burp Suite/Nuclei, planning penetration tests, executing DAST, and scanning for vulnerabilities. For dynamic security testing, pentesting, or runtime vulnerability validation. Complements Sentinel static analysis.

Writing user-facing UX text including microcopy, error messages, voice and tone design, onboarding copy, and accessibility text. Use when UX writing or content strategy is needed.

Cleaning up the skill ecosystem by auditing the agent roster for overlap, redundancy, and inactivity; proposes merge candidates and sunset plans with evidence + archive instructions. Propose-only (no execute). Use when the ecosystem needs portfolio cleanup, agent consolidation, or sunset planning. Not for individual skill quality (Architect IMPROVE), strategic ecosystem direction (Darwin), code-level YAGNI (Void), file-level dead code (Sweep), or SKILL.md format audit (Gauge).

Defining KPIs, designing tracking events, and specifying dashboards. Covers North Star Metric, funnel analysis, cohort analysis, and test-intelligence dashboards (flake rate, regression timeline, mutation-overlaid coverage — absorbed from vista). GA4/Amplitude/Mixpanel/PostHog integration. Use when metrics or test-telemetry dashboards are needed.

Adding JSDoc/TSDoc, updating READMEs, replacing any types with proper definitions, and adding high-value comments to complex logic. Use when documentation gaps, unclear intent, or type safety improvements are needed.

Adding edge-case tests, repairing flaky tests, and improving coverage. Use when test gaps need filling, reliability needs raising, or regression tests need adding. Multi-language support (JS/TS, Python, Go, Rust, Java).

Orchestrating multi-session parallel execution using Claude Code Agent Teams API and Codex CLI Subagents to launch, manage, and coordinate concurrent task execution across multiple instances. Use when parallel work is needed.

Quantifying priority by scoring and ordering competing items using ICE/RICE/WSJF/MoSCoW/Cost of Delay/Kano frameworks. No code. Use when prioritizing features/bugs/initiatives, ranking by ICE/RICE/WSJF/etc., or arbitrating Must-have vs Should-have at MVP scoping.

Integrating messaging platforms, developing bots, and designing/implementing real-time communication. Covers channel adapter patterns, webhook handlers, WebSocket servers, event-driven architecture, bot command frameworks. Use when integrating Slack/Discord/Teams bots, designing webhook receivers, or wiring event-driven messaging.

Brainstorming interactively to deepen ideas via iterative dialogue using four modes (Expand/Propose/Evaluate/Subtract). Does not write code. Don't use for decisions (Magi), feature specs (Spark), or single-shot reframing (Flux).

Analyzing pre-change impact by evaluating risk across vertical (dependency chains, affected files) and horizontal (pattern consistency, naming) dimensions. Does not write code. Use when estimating blast radius before a refactor, audit, or migration — or when a PR's risk surface is unclear.

Designing narratives that tell product and feature use cases as customer-centric stories. Use when customer experience storytelling, scenario stories, or product narratives are needed.

Advising founders YC-style by surfacing the #1 bottleneck via socratic probing, giving pattern-matched honest feedback, detecting founder anti-patterns, and extracting 1-2 week action items. Use when seeking founder-mode advisory. Not for brainstorming (Riff), triadic deliberation (Magi), long-term scenarios (Helm), feature gen (Spark), or impl (Builder).

Provisioning infrastructure via cloud IaC (Terraform/OpenTofu/CloudFormation/Pulumi) and local development environments (Docker Compose/dev setup/env vars). Use when IaC design, environment setup, or multi-cloud provisioning is needed.

Designing database schemas, planning migrations, and authoring ER diagrams. Handles normalization, index strategies, and relation definitions. Use when DB schema design is needed.

Investigating bugs via root cause analysis (RCA), reproduction steps, and impact assessment. Investigation-only — identifies why bugs occur and where to fix them, no code. Use when a bug needs RCA, reproduction must be established before fix, or impact radius needs assessment.

Authoring specifications, design documents, implementation checklists, and test specifications. Handles PRD/SRS/HLD/LLD technical documents, review checklists, and test case definitions. Does not write code. Use when technical documentation is needed.

Designing search engines and vector DBs for full-text, vector, and hybrid retrieval. Use when full-text search, vector search, or hybrid search design, index optimization, or RAG retrieval layer implementation is needed.

Analyzing code statically for security flaws: hardcoded secret detection, SQL injection prevention, input validation, security headers, and dependency CVE scanning. Don't use for runtime exploit verification (Probe), general code review (Judge), CI/CD management (Gear), or detection rule authoring (Vigil).

Designing multi-tenant architectures with tenant isolation strategies, RLS, routing, and scale design for SaaS. Use when designing multi-tenant SaaS systems or tenant isolation.

Guiding workflows by decomposing complex tasks (Epics) into Atomic Steps under 15 minutes each. Manages progress tracking, drift prevention, risk assessment, and timely commit proposals. Use when complex task decomposition is needed.

Orchestrating migrations, upgrades, and modernization across frameworks, libraries, APIs, databases, native runtimes, and dependencies. Detects deprecated libraries, suggests native API replacements, runs technology radar, generates codemods, applies incremental strategies (Strangler Fig/Branch by Abstraction), verifies behavioral equivalence, and produces rollback plans.

Verifying system resilience via load testing, contract testing, chaos engineering, and mutation testing. Use when system limit verification, non-functional testing, or reliability validation is needed.

Generating, updating, auditing, and sync-repairing project-specific Claude Code skills. Analyzes the repo stack and conventions, synthesizes Micro or Full skills matched to project patterns, and installs to both .claude/skills/ and .agents/skills/. Use when authoring project-local skills.

Generating AI image-generation code using the Gemini API. Handles text-to-image generation, image editing, and prompt optimization. Use when image generation code is needed.

Automating iOS UI via XCUITest, accessibility-identifier-driven queries, programmatic screenshot capture, and fastlane snapshot pipelines for App Store assets. Authors XCUITest targets with XCUIApplication/XCUIElement/XCUIElementQuery patterns, Page Objects in Swift, status-bar-clean sessions, and xcodebuild+xcresulttool CI. Use when authoring iOS UI tests or store-screenshot pipelines. Not for cross-platform E2E (Voyager — Appium/Detox/Maestro), iOS feature impl (Native), demo recording (Director), or unit tests (Radar).

Proposing new features leveraging existing data/logic as Markdown specifications. Use when brainstorming new features, product planning, or feature proposals are needed. Does not write code.

Generating slides via Marp, reveal.js, or Slidev, designing narrative arcs, and optimizing conference talks with WPM-calibrated timing. Use when creating or pacing presentations.

Designing ETL/ELT pipelines, visualizing data flows, selecting batch/streaming approaches, and architecting Kafka/Airflow/dbt systems. Use when building data pipelines or managing data quality.

Channeling the documented thinking of named notable figures (an 'itako' medium) — applies their mental models, heuristics, and decision-style to your problem as advisory lenses. Don't use for decisions/verdicts (Magi), synthetic user personas (Cast), or fixed founder-mentor coaching (Sage).

Detecting unnecessary files, unused code, and orphaned files, and proposing safe deletion. For repo cleanup, dead code removal, or tidying. Don't use for removal execution (Builder), deletion review (Judge), repo structure (Grove), or scope cutting (Void).

Designing scheduling and time-aware logic for cron, timezone/DST, retry/backoff, and business-calendar systems. Use when schedule design is needed.

Delivering working code fastest via build-first product delivery. Routes through minimum agent chains scoped to the task. S/M scopes skip planning and build immediately. Use when shipping the shortest path to working code, fast-tracking S/M scopes, or compressing time-to-first-PR on small-to-medium features.

Converting repository changes into detailed learning documents. Use when turning diffs into teaching materials, recording design decisions, or creating onboarding materials for new members.

Analyzing session replays, extracting persona-based behavioral patterns, and storytelling UX issues. A behavioral archaeologist that reads the 'why' from actual user operation logs. Collaborates with Field/Echo for persona validation.

Investigating git history, analyzing regression root causes, and performing code archaeology. Time-travels through commit history to uncover truth. Use when git history investigation or regression analysis is needed.

Architecting crawl and scraping systems — distributed crawler topology, URL frontier, politeness, and compliance. Architecture-only (no execution code). Don't use for single-page scraping (Vector) or ETL pipelines (Stream).

Responding to incidents, identifying impact scope, formulating recovery procedures, and creating postmortems. Use when incident response or disaster recovery is needed. Does not write code (delegates fixes to Builder).

Tuning database queries via EXPLAIN ANALYZE, query plan optimization, index recommendations, and slow query detection/fixing. Complements Schema's schema design. Don't use for schema/migrations (Schema), app rewrites (Builder), non-DB performance (Bolt), or unknown root cause (Scout).

Automating browsers via Playwright and Chrome DevTools for data collection, form interaction, screenshot capture, and network monitoring. Task completion focus (vs Voyager for E2E testing).

Engineering detection rules (Sigma/YARA), mapping detection coverage, designing threat hunting hypotheses, executing Purple Team Blue side, and integrating Detection-as-Code CI/CD. Use when defensive security verification is needed.

Directing UI/UX creative work — complete redesigns, new designs, and trend application. Use when design direction decisions, Design System construction, or orchestration of Muse/Palette/Flow/Forge is needed. Does not write code. Offers an interactive co-design pair mode (decide direction together, one decision at a time).

Authoring Storybook stories, managing component catalogs, and integrating Visual Regression. Covers UI component docs, visual testing, CSF 3.0/Factories. Supports Storybook 10 (ESM-only) and React Cosmos. Use when authoring Storybook stories, building a component catalog, or wiring Visual Regression into CI.

Collecting user feedback via NPS surveys, review analysis, sentiment analysis, feedback classification, and insight extraction reports. Use when establishing feedback loops.

Verifying YAGNI, cutting scope, pruning, and proposing complexity reductions. A 'subtraction' agent that questions the justification for every code, feature, process, document, design, spec, dependency, and config. Does not write code.

Authoring E2E tests for web (Playwright/Cypress/WebdriverIO) and native mobile (Appium/Detox/Maestro/XCUITest/Espresso). Covers Page Object design, auth flows, parallel execution, visual regression, a11y, CI, and remote device-farm (BrowserStack/Sauce Labs/AWS/Firebase). Use when authoring E2E suites. Not for unit (Radar), load/chaos (Siege), ad-hoc browser (Vector), or native impl (Native).

Designing workflows and state machines. Use when state transition design, invalid transition detection, Saga patterns, or approval flow design is needed.

Refactoring code via variable name improvement, function extraction, magic number constants, dead code removal, and code review. Does not change behavior. Don't use for bug/security (Judge), new tests (Radar), architecture (Atlas), or feature implementation (Builder).

Authoring tech blog/article series for note/Zenn/Qiita/dev.to. Not for specs (Scribe) or microcopy (Prose).