Skills

Prevents data leaks on logout and stale screen-state bugs in navigation-heavy apps.

Eliminates prop-drilling re-render cascades; reduces state boilerplate by ~60%.

Native module development for React Native — iOS (Swift) and Android (Kotlin).

React Native's new architecture — Fabric, TurboModules, JSI, Codegen.

Styling approaches and design systems for React Native.

Reanimated, Moti, and Skia animations for React Native.

Jest and Testing Library patterns for React Native.

Expo workflow and managed apps — SDK, EAS Build, Expo Router.

Eliminates broken back stacks from push/go confusion — the top GoRouter bug in production.

Eliminates rebuild storms from setState; reduces widget rebuilds 10–50× in complex screens.

Platform-specific code via MethodChannel, EventChannel, and Pigeon codegen.

Build flavors and environments for Flutter (dev/staging/prod).

Theming and design systems — Material 3 and Cupertino.

Implicit, explicit, and custom animations — including Hero and Rive.

Widget, integration, and golden tests for Flutter.

Package development and publishing for Flutter.

Audio playback — just_audio, background playback, playlists, streaming.

Device plugins — image_picker, file_picker, share_plus, permissions.

FlutterFire setup — initialization, per-flavor config, App Check.

Local storage — sqflite, path_provider, and drift/hive/isar decisions.

Networking — http vs dio, interceptors, retry, multipart, cancellation.

Responsive layouts across devices — phones, tablets, safe areas, orientation.

Platform-adaptive UI — components that feel native on iOS and Android.

Theming and dark mode — system detection, dynamic theming, color schemes.

i18n and l10n — multi-language, RTL, date/number formatting, pluralization.

A11y compliance patterns — VoiceOver/TalkBack, labels, focus, WCAG.

Prevent crashes from reaching users; convert unhandled exceptions into recoverable states.

Eliminate race conditions, duplicate calls, and network crashes with production patterns.

Prevents data loss when users edit offline; correct conflict resolution preserves all changes.

Unencrypted token storage lets any rooted/jailbroken device steal credentials — this prevents that.

Biometric authentication — Face ID, Touch ID, fingerprint, with fallbacks.

Generate fully typed, accessible, tested component packages from design specs in seconds.

Converts vague feature requests into precise, buildable screen specifications.

Hierarchical design tokens — global MASTER.md plus per-screen overrides.

A single source of truth for design tokens across iOS and Android.

Guides library selection to avoid costly mid-project rewrites.

Eliminates frame drops from 15fps to a consistent 60fps with 1000+ items.

Image loading and caching — progressive loading, WebP, lazy loading.

Reduce bundle size 40–70%, cutting download time and avoiding size warnings.

Reduces cold start from 4+ s to under 1.5 s; each second loses ~10% of users.

Memory profiling and optimization — leak detection, pooling, GC tuning.

Render performance tuning — prevent re-renders, memoization, 60fps.

iOS certificates and provisioning — profiles, entitlements, Fastlane Match.

Android keystore and signing — config, Play App Signing, Gradle.

Avoid 1–2 week rejection delays by addressing the top 20 reasons before submission.

Prevent app suspension by addressing the top 20 policy violations proactively.

Phased rollout strategies — percentage rollouts, rollback, monitoring.

Crash reporting setup — Crashlytics, Sentry, Bugsnag, symbolication.

Automate screenshot and recording capture for store listings and demos.

Mobile testing strategy — distribution, coverage, and test-type selection.

Mocking for mobile tests — native modules, APIs, test doubles.

UI snapshot testing — component snapshots, golden images, visual regression.

CI testing pipelines — configuration, reporting, parallelization, coverage.

Prevents random logouts from token-refresh race conditions in production.

Missing RLS policies expose all user data — this prevents full data breaches.

File storage patterns — buckets, upload/download, signed URLs.

Real-time subscriptions — presence, broadcast, change streaming.

Edge function development — Deno/TypeScript, secrets, deployment.

GraphQL client patterns — Apollo, codegen, normalized caching, subscriptions.

Author OKF docs/knowledge/ concepts correctly — format, one-way authority, PII, cross-links.

IAP implementation — StoreKit 2, Play Billing, subscriptions, receipt validation.

RevenueCat subscription management — entitlements, analytics, paywalls.

Stripe mobile integration — payment sheet, Apple/Google Pay, subscriptions.

Ad SDK integration — AdMob rewarded, interstitial, and banner ads.

Google Maps and MapKit integration — markers, clustering, custom styling.

Location tracking and geofencing — background location, permissions.

Geospatial data handling — PostGIS, spatial queries, nearby search.

AI API integration patterns — streaming, function calling, token management.

AI image/video features — DALL-E, Stable Diffusion, media processing.

ARKit/ARCore patterns — plane detection, 3D placement, image tracking.

Establishes the single source of truth for what the app must do.

Prevents architectural rework by enforcing research before implementation.

Bridges brainstorming to execution with atomic task decomposition and tracking.

Links every requirement to its tasks, tests, and files — preventing coverage gaps.

Two-stage review ensuring requirement compliance and code quality before merge.

Multi-session feature builds with progress persistence and baton handoff.

Prevents fix-churn by enforcing root-cause investigation before any change.

Prevents false completion claims by requiring fresh evidence before "done".

Standardizes commit messages with platform-specific scopes and breaking-change rules.

Captures hard-won debugging knowledge; now delegates to /tl-telar:self-reflect.

Meta-skill for creating new skills with proper structure, validation, and frontmatter.

Index of all available feature blueprints and how to use them.

Complete auth flow — login, signup, forgot password, and social auth.

Master-detail CRUD — pull-to-refresh, pagination, swipe actions, optimistic updates.

Real-time chat — message list, input, typing indicators, read receipts.

Settings screen — sections, toggles, account management, notification prefs.

Multi-step onboarding — pagination, skip, permission requests, completion tracking.

Catches plan-level defects (feasibility, completeness, scope) before implementation.

Pre-implementation collaborative review by 6 specialist reviewers.

The 4-phase IMPLEMENT / VALIDATE / REVIEW / COMMIT loop.

Spawns 2–4 fresh adversarial reviewers in Phase 3; any FAIL blocks COMMIT.

Spawn template for firing mobile specialist agents in adversarial mode.

Injects relevant KB facts into the current task's context.

Captures durable learnings from PR comments and conversation context.

Restores orchestrator state after compaction or cross-session resume.

Layer-B dispatcher for Codex/Gemini delegation (disabled by default).

Missing/inconsistent SEO/OG tags silently kill organic visibility and break social link previews.

Unnecessary hydration and unoptimized hero images are the top cause of poor LCP/CLS on marketing sites.

Cuts custom interactive-component build time and eliminates a class of keyboard/focus/ARIA bugs.

Removes the duplicate theme-definition problem and prevents silent v3→v4 build breakage.

Prevents unauthorized data access from stale-cookie/session-desync bugs a middleware-only check can't catch.

Reuses Refine's resource/provider CRUD leverage instead of hand-wiring screens — and keeps RLS, not the client-side access-control provider, as the real security boundary.

Eliminates a class of route/query waterfalls and unguarded-route bugs via end-to-end type safety.

Removes duplicate/stale-data bugs from ad hoc cache keys; closes the loader-to-component gap.

Keeps operator tables responsive from 100 to 500k+ rows by moving work to Postgres, not the browser.

Prevents the most common React/TS architecture mistake — server data leaking into global stores — and keeps re-renders minimal by matching the right tool to each state category.

Eliminates jank from layout-animating properties and ensures reduced-motion compliance while unlocking fluid, accessible 60fps interactions.

Eliminates brittle implementation-detail tests and flaky E2E suites; aligns the test pyramid so fast unit feedback survives rapid UI iteration without sacrificing confidence in critical user journeys.

Prevents full-database exposure through the anon key — the top failure mode of a service-role-free client.

Turns large-file uploads from a single point of failure on flaky networks into a resumable operation.

Cuts navigation and repeat-action time for power-user operators who default to keyboard over mouse.

Cuts dashboard build time by reusing pre-built, accessible chart primitives instead of hand-rolling SVG.

Prevents a costly full-UI re-audit later by building bilingual + RTL-ready layout discipline in from day one.

One MASTER token source generates Tailwind v4 @theme + shadcn CSS variables for every web surface AND Flutter Dart — surfaces can't drift and a rebrand is a one-line edit.

Generates fully typed, accessible, token-styled, tested React/TSX component packages from a spec in seconds — the web parity of component-scaffolding.

Converts vague feature requests or Figma frames into precise, buildable web route specs — path, layout, component tree, data deps, states, i18n, and a11y.

Arrange/Act Supabase E2E test-data model: service_role provisions, real UI + RLS acts; plain-fetch factory; runId isolation.

Stable Playwright locators + no-fixed-sleep waiting for shadcn/Radix, TanStack Table/Query, react-hook-form/zod.

E2E scenario catalog matrix + smoke/basic/full tags + phased regression orchestrator + multi-baseURL Playwright config.

Adversarial gate: 24 silent-always-pass anti-patterns (P0/P1/P2) incl. service_role-in-act.

Eliminates duplicated auth/validation code across handlers and prevents silent CORS misconfiguration.

Prevents connection-pool exhaustion outages and N+1 storms; catches SQL drift at compile time.

Keeps services testable and mergeable as they grow; prevents config/secrets sprawl and breaking API changes.

Catches routing/auth/query regressions before deploy without a full staging environment per PR.

Cuts Docker image size dramatically and CI build times via layer caching; no dropped in-flight requests.