The whole library

measures contrast and WCAG criteria → avoids accessibility failures before delivery

NVIDIA cuDF rules to speed up pandas on GPU → faster data processing

spots long-running competing hooks and offers → guides your ad testing

generates Swift types for GraphQL → avoids data errors at compile time

makes you measure before fixing → performance gains proven by numbers

adds native video players, PiP and AirPlay → reliable playback, without reinventing controls

searches for evidence in full-text papers → verifies claims beyond the abstracts

writes SQL on the BigQuery GA4 export → reliable session analyses, cost estimated before running

guides you on BigQuery GQL queries → avoids inventing columns or Cypher

bundles a local MCP server with its runtime → installable without Node or Python

writes your Cognee tasks and chains them into pipelines → custom processing, no hacks

finds the right document before deleting it → avoids erasing the wrong memory

guides Coil 3 in Compose KMP → avoids OOM crashes and jank in lists

builds Blazor forms and validation, in SSR as well as interactive → avoids flawed submissions

fixes Compose state, effects and modifiers → fewer typical LLM mistakes

watches for deleted code and skipped tests → Claude stops silently lowering quality

guides the migration from Blazor Server to Blazor Web App → component rendering and streaming

inspects cookies and sessions in Chrome → fixes your 401, 403 and consent banner issues

creates, reads and edits Word files → produces professional documents formatted automatically

creates and edits Word files faithfully → avoids broken formatting

makes you refine the domain vocabulary → avoids misunderstandings in the code

measures startup, navigation and errors of your Expo app → production performance benchmarks

deploys to Elastic Beanstalk, EC2 or EKS → removes server and patch management

draws and refines Excalidraw diagrams live → clear diagrams, verified by screenshot

centralizes colors and spacing in a shared theme → consistent screens, without hardcoded values

edits your videos and audio locally, subtitles included → exports ready for YouTube, Reels, TikTok

translates Figma to SwiftUI in both directions → fewer gaps between design and iOS code

has you validate a master, exports frames for your engine → sprites ready without touch-up

reviews your Swift Testing tests → avoids common mistakes and fragile tests

guides you through turn-by-turn, multi-stop and voice guidance → avoids reinventing navigation

moves heavy computations off the JS thread → smoother interface, without blocking

guide for paginated RDL reports → faithful print outputs, validated before publishing

makes you reuse the Fabric model's measures → figures identical to Power BI reports

guides React Navigation stacks, tabs, drawers and safe areas → avoids misplaced screens

creates and audits honest scientific figures → avoids misleading charts before publication

analyzes a skill before installation with SkillSpector → avoids malicious or overly permissive skills

animates an SVG character between several poses → smooth transitions and rest movements

writes and reviews your Swift Testing tests → avoids XCTest habits and common mistakes

writes and reviews your modern SwiftUI → avoids deprecated APIs and unnecessary re-renders

adapts SwiftUI to the iPhone Duo without device branches → an interface that fits every size

guides Liquid Glass use in SwiftUI → avoids jury-rigged fake glass effects

computes percentiles, rates and averages on time series → faster analytical queries on large volumes

writes WebGPU shaders and buffers in typed TypeScript → avoids CPU/GPU errors

helps you write UnoCSS rules and shortcuts → cleaner, more maintainable atomic CSS

drives the Unreal editor live, actors and Blueprints → avoids manual edits

creates and fixes Excel files with verified formulas → spreadsheets without calculation errors

audits web accessibility → flags low contrast, keyboard focus and too-small touch targets

measures where visitors abandon a funnel → targets the step losing the most

builds a performance briefing → clear summary for executives, no raw data

summarizes your KPIs over a period → quickly spots what moved and why

compares audience segments side by side → spots the best-performing segment

ranks a metric's biggest gains and drops → quickly spots what moves

takes over an AD account via Shadow Credentials → tests escalation without resetting the password

audits accessibility against WCAG 2.2 → makes the site usable by everyone, screen readers included

guides you through iOS Live Activities → prevents broken push updates

converts Word, Excel and PowerPoint to Markdown locally → reads documents without any external service

adds an E2E path to the Paperclip runner → catches regressions before production

writes and debugs your Illustrator scripts → automates documents, layers and exports

runs your Google, Meta and LinkedIn campaigns → cuts wasted spend and lowers your CPA

classifies, forecasts and detects anomalies in time series → avoids homemade algorithms

guides you in writing subagents → precise triggering, more robust prompts

guides browser interactions (snapshot, click, forms) → makes your web automations and app tests more reliable

guides creating Claude Code agents: triggers, tools, system prompt → more reliable agents

automates iOS, tvOS, macOS and Android navigation and screenshots → faster screen checks

validates credentials, paths and URLs before each agent action → blocks leaks and out-of-scope writes

runs, reruns and diagnoses your Airflow DAGs → less time lost on failures

builds Airflow 3.1+ plugins with FastAPI and React → adds pages and APIs to Airflow

keeps task state across restarts → avoids restarting a job from scratch

schedules iOS 26 alarms and timers via AlarmKit → reliable wake-ups, even on silent

regenerates Alef bindings without hand-editing them → prevents silent drift

consults predicted effects of a GRCh38 SNV → prioritizes non-coding variants

defines your tracking plan before implementing → avoids collecting unnecessary events

queries the warehouse in SQL → reliable figures, tables found and remembered

enforces Android data layers → isolated errors, clean repository, Room KMP

decodes Android ANRs, R8 and memory leaks → finds the root cause before any fix

centralizes Android Gradle config into reusable plugins → shorter modules, no duplication

decompiles APK and XAPK, extracts API endpoints → understand an Android app faster

reads AOSP and AndroidX Android source → avoids guessing internal APIs

requires failing tests before any Android code → avoids Compose and KMP pitfalls

audits your Android screens against Material Design 3 → fewer accessibility and usability errors

helps you decide if an animation makes sense → avoids gratuitous, jerky motion

animates your React Native interfaces with Reanimated → smooth animations without blocking JavaScript

turns a topic into a narrated explainer video → avoids manual filming and editing

generates typed Kotlin models for GraphQL → fewer errors, queries checked at compile time

guides App Clip target and its routing → avoids wrong signatures and bad destinations

designs iOS intents before the UI → avoids logic duplicated between Siri and screens

exposes your actions to Siri, Shortcuts and Spotlight → your app responds beyond the screen

writes and reviews App Intents code for Siri → avoids miswired actions

suggests App Store keywords verified per language → more visibility, no invented terms

audits App Store submission and flags likely rejections → avoids review refusals

fetches App Store apps, reviews and ratings as JSON → analyzes competitors and user feedback

measures errors, clicks and network calls on your pages → surfaces real user bugs

makes you study real apps before each mobile screen → more native, polished screens

transfers app data between iOS and Android → lossless migration when changing phones

creates App Store and Play Store preview videos → custom scenes, no generic template

checks your iOS app before submission → fewer App Store rejections

checks before each App Store screenshot upload → avoids overwrites and forgotten files

audits your App Store or Google Play listing → more visibility and downloads

guides Astropy APIs: units, coordinates, FITS, WCS → fewer unit and conversion errors

guides React Native audio playback, recording and effects → avoids audio clicks and misconfigured sessions

progressively enables Xcode security checks → catches bugs at compile time

guides you through Sign in with Apple, passkeys and biometrics → avoids iOS sign-in flaws

writes clean Blazor components → avoids parameter and lifecycle errors

validates GitHub Actions workflows before merge → avoids runs that never start

writes Airflow tasks in Java/Kotlin → makes JVM DAGs reliable without leaving Python

codes your Airflow tasks in Java or Go → without touching your Python DAG

spots AI tics in your texts → more natural prose, your voice preserved

creates resumable Firecracker microVMs → safe sandbox for untrusted code and long sessions

queries, alarms and traces for CloudWatch and Omni → diagnoses AWS incidents faster

fixes VoiceOver, Dynamic Type and contrast → iOS apps usable by everyone

groups production crashes by family → prioritizes real bugs, isolates noise

reads Apple docs and Swift diagnostics → prevents Claude from inventing APIs

scans Swift camera and audio capture code → spots deprecated APIs and frozen sessions

audits Liquid Glass adoption in iOS 26 → modern interfaces without misapplied effects

recommends Azure VM size and price → avoids oversized, costly machines

plans enterprise Azure infrastructure in Bicep → avoids security and networking oversights

builds animated promos in the browser → cinematic rendering, not a slideshow

places and generates an article's illustrations in a consistent style → more readable articles

generates article covers in three formats → saves time on every visual

publishes your articles to WeChat → avoids manual formatting

converts a web page to markdown, even behind a login → clean, readable archive

extracts YouTube transcripts and thumbnails → supplies the text without copy-pasting

guides you through integrating Scandit BarcodeCapture on Android → controlled scanning, no ready-made UI

guides integrating a barcode scanner on iOS in Swift → custom scanning, no imposed UI

guides Scandit BarcodeCapture in KMP → avoids invented APIs and compilation errors

checks Scandit APIs before each .NET Android integration → avoids invented code

guides Scandit .NET iOS scanning → avoids invented APIs and migration errors

integrates Scandit barcode scanning into MAUI → avoids black camera and build errors

wires a Scandit barcode scanner into React Native → reliable reads, fully customizable UI

selects one code among several in KMP → stops Claude from inventing wrong APIs

creates SVG visuals for READMEs → cleaner READMEs, without unrequested rewrites

writes BigFrames code → computes in BigQuery, without filling local memory

draws accessible SVG charts for articles → readable in dark and light themes

turns a book into a structured skill → applies an author's frameworks during your projects

adds interactive forms and selectors to the chat → avoids tedious typed input

asks the right questions before coding → avoids rebuilding your architecture later

guides building Nitro Modules with Nitrogen → fewer native bugs, safer APIs

builds GCP data dashboards in React or Streamlit → avoids invented visual choices

guides Next.js caching and PPR → faster pages, less server computation

writes concise commit messages focused on why → git history easier to read

measures where tokens go, proposes validated fixes → lower costs, measured savings

monitors a PR until merge → avoids rerunning reviews and CI by hand

reviews a diff for bugs, regressions and tests → avoids errors before merging

creates commits with clear messages → readable git history that's easy to review

checks repo learnings against current code → avoids outdated or contradictory advice

runs the iOS app in the simulator and keeps evidence → catches bugs before delivery

speeds up pandas without changing code, via ClickHouse → large files processed much faster

runs analytical SQL on remote files and databases → avoids setting up a server

overlays circles and animations on your screenshots, synced to subtitles → clearer explanations

drives Chrome from the terminal → automates web tasks without manual clicking

checks each .bib against the web, double-blind → catches wrong authors, years and DOIs

guides your Android Kotlin Compose and Room 3 apps → avoids shaky targetSdk migrations

extracts key frames and transcript from a video → lets Claude summarize and analyze it

extracts key frames and transcript from a video → lets Claude watch and summarize it

cuts out the funny moments or highlights of a video → ready-to-publish clips

checks terminal rendering in a real pane → avoids broken tables at reduced width

reviews your changes against repo standards and the ticket → catches gaps before merging

runs Codex CLI to analyze or refactor your code → a second opinion on your project

drives the cognee memory from the terminal → quickly organizes, queries and purges your project memory

plugs databases, connectors and community tools into cognee → extends cognee without changing its core

fixes the shape of the cognee graph → avoids duplicate nodes and missing links

runs cognee in Docker without compiling anything → tests its AI memory in a few minutes

connects your sessions to the persistent graph → keeps each conversation's learnings

guides you in storing your data in cognee → estimates the cost before ingesting

guides you through installing cognee and running remember → recall → avoids configuration blockers

measures colors numerically, not by eye → fixes washed-out, flat renders

adds Android voice and video calls without a ready-made UI → avoids hand-coding them

supports a custom Android chat → avoids init, login and listener errors

CometChat Android settings and login → avoids shipping the development key

configures CometChat Android voice and video calls → avoids missing call buttons and crashes

lists CometChat Compose composables and their slots → avoids inventing a nonexistent component

sets CometChat colors and dark mode → the interface matches your visual identity

places the CometChat chat in your Compose NavHost → back stack and keyboard handled properly

enforces init, login, then CometChat Android rendering → avoids crashes on first launch

writes your typed ComfyUI v2 extensions → automatic cleanup instead of monkey-patching

picks ComfyUI flags against OOM and slowness → avoids memory crashes on video

picks the simplest Compose animation API → avoids ghost content after exit

guides modifiers and slots for your Compose components → reusable APIs, without hidden booleans

isolates DTOs, Ktor, Room and Paging → an API change no longer breaks the UI

guides Compose and Compose Multiplatform, navigation included → smoother interfaces, fewer re-renders

builds a complete screen, tests included → avoids unfinished features and forgotten states

sets Compose focus rules for D-pad and keyboard → avoids screens with no focused target

guides Jetpack Compose animations, from simple fades to shared transitions → avoids hacky workarounds

guides a single Compose UI across Android, iOS, desktop, web → less duplicated code

finds the cause of unnecessary Compose recompositions → smoother UI, fewer re-renders

separates commonMain and platform code → avoids code that only works on Android

places Compose state and its effects in the right spot → avoids bugs and leaks

writes and reviews your Compose composables → fewer re-renders, smoother and more accessible UIs

checks Confluent Cloud Flink SQL → avoids Apache Flink dialect pitfalls

adds MCP App support to your web app → keeps the standalone version intact

turns a dbt Core project into an Airflow DAG → avoids rewriting orchestration by hand

checks Fusion and the warehouse before configuring Cosmos → avoids setup mistakes

turns your course into an Android APK → offline reading on phone or tablet

turns your course into a Linux AppImage → runs on any distro, with nothing to install

turns your question into an Amplitude chart → saves time without configuring everything by hand

documents a product's visual language → stops Claude from inventing the design

creates a React Native library with a native module → avoids manual native configuration

guides you in exposing Unreal tools to Claude → widens its actions in the editor

links your apps to one account, access per app → avoids duplicate accounts

offers you native CSS animations without a library → lighter pages, no extra dependency

permanently deletes the project's index and stats → starts over with a clean context base

extends pandas and NumPy beyond RAM → handles files too large without crashing

guides any data analysis → verified conclusions, fewer false results

adds AI to Databricks SQL and PySpark pipelines → without managing any model or endpoint

makes you test every SQL query before deployment → avoids broken Databricks dashboards

designs the data screens of your Databricks apps → avoids misleading charts and empty states

checks data access before creating a Databricks app → avoids costly rewrites

frames your Python Databricks backend → avoids auth and resource errors

makes you choose the Databricks profile before each command → avoids touching the wrong workspace

finds the data and generates the SQL via Genie → avoids guessing Databricks schemas

gives advanced DBSQL syntax (scripting, materialized views, AI) → fewer trial-and-error attempts on Databricks

runs Python, SQL, Scala or R on Databricks → heavy computations launched without manual tuning

finds why main content loads late with Chrome DevTools → pages that display faster

pinpoints the faulty step in an imperfect render → avoids re-running the whole chain blindly

guides pytest evaluation of AI agents → spots failures and improves their reliability

sends OTel traces from an AI app to Confident AI → tracking and evaluation without deepeval

instrument your AI app with DeepEval → every LLM call and tool visible in Confident AI

converts BAM to bigWig, checks quality, plots heatmaps → readable ChIP, ATAC and RNA-seq signals

deploys the app as a Vercel preview → quick online release without touching production

builds and packages a Go bundle for Airflow → avoids incompatible binaries on workers

turns a site's traffic into an API client → faster automations, no browser needed

specifies a UI component with its 8 states and accessibility → avoids forgotten states

spots native JVM, packaging and signing pitfalls → avoids broken builds elsewhere

step-by-step guide to Detour, from account to SDK → deep links that survive installation

drives a real Chrome, named pages kept → automates tests and scraping without rerunning everything

creates a Java Kafka client with Maven or Gradle after confirmation → avoids broken configurations

re-reads a failed Superpowers session → explains the drifts with evidence, without guessing

extracts headings and tables from PDF and Office → clean text, ready for Claude

edits .docx files with tracked changes → avoids breaking the formatting

creates ASP.NET Core endpoints with the right HTTP codes → documented API and consistent errors

gives you Aurora DSQL's limits and errors → avoids unexpected blocks in production

creates and edits Dynatrace notebooks with validated DQL queries → avoids invented queries

extracts queries from a Dynatrace dashboard → spots anomalies and correlations without reading everything

searches DuckDB and DuckLake docs → sourced answers, without leaving Claude Code

writes, modifies and imports Dataverse data → avoids errors from homemade HTTP scripts

expected figures, history and targets before results → frames market expectations

runs builds and submissions to App Store and Play → fewer rejections at submission

runs your app on an EAS cloud simulator → tests iOS without a Mac or local simulator

publishes JavaScript updates without a new build → fixes shipped without waiting for the stores

measures crashes and installs of your EAS Updates → spots a regression quickly after publishing

writes and validates your EAS workflows → avoids syntax errors in your pipelines

adds subtitles to your video without retouching it → clear reading, cinema effects on request

enables Bundle Mode and its metro patches → npm libs in worklets, with Fast Refresh

guides React Native iOS and Android apps → fewer native bugs before release

builds Excel DCF, LBO or variance workbooks → avoids invented values and unverified calculations

runs PySpark on Fabric without a notebook → ephemeral compute, nothing to clean up

profiles your local CSV and JSON files → spots missing values and leaks before modeling

picks the lightest tool, animates on the UI thread → smooth even on modest phones

adds an iOS App Clip to your Expo app → launches without installation from a link

embeds Expo in an existing native app → keeps navigation and native views intact

builds a test Expo client → tests native code on a device, without a store

embeds web code in a native webview → reuses web libraries like recharts without rewriting

copies Expo's official template for a third-party integration → avoids outdated Expo configs

guides adding Meta Quest to an Expo app → avoids unsupported GPS calls

migrates an Expo Swift module to macros 2.0 → avoids breaking the JS contract

guides native Expo modules for iOS and Android → avoids structural mistakes

routes each Expo or EAS task to the right skill → avoids configuration errors

proposes a structure for a new Expo project → files easy to locate from the start

organizes routes, modals and native tabs → smoother navigation, closer to iOS conventions

builds native sheets, pickers and lists → faithful iOS and Android rendering, no third-party libraries

guides Expo version upgrades and fixes dependencies → avoids broken builds

migrates a React web app to Expo, screen by screen → stays shippable at every step

estimates CU cost before each Fabric operation → avoids saturating your capacity

turns a text into an explainer video without filming → clear topics, custom-made visuals

generates sprites, textures, 3D and sounds with fal → game-ready assets without searching

creates FiftyOne notebooks validated step by step → clear tutorials, up-to-date code

exports your FiftyOne datasets to COCO, YOLO or CSV → avoids manual conversions

visualizes your data in 2D using embeddings → spots clusters and outliers

rebuilds a page in Figma with your components → avoids hardcoded colors

sets keyframes and easings on a Figma node → smooth animations without guessing settings

lets you choose merge, PR or keep after green tests → avoids risky merges

guides Fishjam WebRTC code → avoids token and room errors

guides writing Flink UDFs in Java → extends Flink SQL with your own functions

saves the conversation as a source-tagged spec → avoids losing your decisions

creates a clean Flutter app with Riverpod and pinned SDK → sound base, no obsolete APIs

spots Kotlin and Compose pitfalls in your diff → avoids bugs before the commit

handles FrontendExtensions, from packaging to publication → faster diagnosis of blocked extensions

helps you find your visual style → avoids generic, AI-looking slides

checks whether furniture fits in a measured room → avoids unpleasant space surprises

generates or edits images with AI → saves time on visuals and logos

generates validation SQL notebooks for your dbt models → catches regressions before prod

builds 2D maps and scenes with verified collisions → avoids levels that are impossible to cross

generates images and video clips via your APIs → tracks spending, no billing surprises

generates and measures Compose Baseline Profiles → faster startup, smoother scrolling

guides gesture handling with RNGH → avoids PanResponder and JS thread bugs

diagnoses conversion drops and lost impressions → finds whether budget or bids are blocking

sets up GA4 and checks conversion before ads → ad spend measured on real data

writes Google Workspace scripts → faster processing, reliable triggers, quotas respected

manages Cloud Storage buckets and objects → avoids manual gcloud commands

analyzes your usage and designs your secure bucket → avoids data leaks and overspending

offers you local leads with emails and phone numbers → saves time on prospecting

guides migration of the Google Ads Android SDK to Next-Gen → avoids import and crash errors

guides AdMob banner integration → avoids size and loading errors

guides AdMob SDK setup for Android, iOS or Unity → avoids missed configuration steps

guides full-screen ad integration for Android, iOS, Unity → monetizes without implementation errors

checks Google Mobile Ads integration before publishing → avoids test IDs in production

guides GSAP plugins (Flip, Draggable, ScrollTo) → more reliable interface animations

makes you animate React with useGSAP, auto cleanup on unmount → avoids leaks and orphaned animations

animates, pins and links effects to scrolling → smooth parallax without fiddling with JavaScript

organizes GSAP animations into timelines → readable sequences without cascading delays

gives you clamp, mapRange, snap and random → avoids hand-computing bounds

structures and packages a SwiftPM macOS app → complete macOS delivery without opening Xcode

guides Swift concurrency → avoids actor and cancellation bugs

guides SwiftUI animations, transitions and Animatable → smooth, performant motion

builds a release video with real components → showcases new features without a frozen mockup

creates Rednote and WeChat cards and covers → more readable editorial visuals

checks H-1B sponsorships of a US employer → avoids applications with no visa prospects

measures and reduces always-loaded context → rules followed better, lighter sessions

checks medical licenses against the NPI registry → avoids compliance errors

chooses the SageMaker deployment mode → avoids paying for an unneeded endpoint

turns an image into a 3D GLB mockup → replaces manual modeling for references

writes each character's acting, gaze included → avoids frozen, lifeless faces

generates 4- to 15-second video ads → ready-to-test UGC spots

describes the plan in an interactive HTML page → you validate the choices before coding

creates HTML mockups faithful to the context → tests a product decision before coding

guides your Gradio interfaces in Python → web ML demos in little code

publishes a private Gradio Space for your LoRA → testable demo, model settings respected

logs training metrics and triggers alerts → spots diverging runs quickly

creates HTML videos with subtitles, voiceover and transitions → faster animated video production

sets fades, ducking and effects on placed tracks → voice and music stop competing

sets the structure and timing of an HTML composition → avoids video rendering errors

installs HyperFrames blocks and components into your compositions → no manual wiring

configures ID document scanning on Android → avoids invented Scandit APIs

loads HLS or DASH streams with IMA DAI → server-side ad insertion, without hacks

guides client-side VAST and VMAP video ads → avoids playback errors

runs a local Postgres in Docker and manages the cloud → simplifies dev-to-prod transitions

guides iOS build and signing through upload → fewer failures at submission

translates and validates iOS .xcstrings → avoids broken placeholders in every language

decompiles an iOS IPA and hunts for flaws, secrets, endpoints → security audit without source code

drives the iOS simulator via accessibility → tests and screenshots without guessing coordinates

audits Jetpack Compose and rates performance, state, effects → fewer unnecessary recompositions

creates a visual Jira sprint dashboard → quickly spots what is blocking the team

guides React Native C++ JSI → avoids thread and memory crashes

lays out CVs, one-pagers and slides → clean, consistent output with no redesign needed

models Kotlin states, manages coroutines → fewer null and threading bugs

checks where functions, types and expect/actual go → clear Kotlin API, native details isolated

checks the scope of coroutines and StateFlow or Channel → avoids leaks and lost events

avoids KQL syntax traps → queries right on the first try

picks the right KrillinAI command → avoids misreading its JSON output

bilingual subtitles from YouTube or local video → avoids transcribing everything by hand

summarizes what Reddit, X and YouTube say over 30 days → real opinions, no noise

turns an idea into a verifiable autonomous task → the agent finishes alone, without cheating

guides LevelPlay integration in Unity → ad monetization without build errors

queries Logfire traces, logs and metrics → finds the cause of errors faster

detects your M5Stack, flashes UIFlow, installs Claude Buddy → guided setup, without guessing

asks you once, builds the full video with visual checks → avoids failed renders

manages your skills via the Skills Hub CLI → avoids risky manual edits

installs Mapbox Android, markers and camera per official docs → avoids integration errors

shows official Mapbox iOS patterns for markers and camera → more reliable iOS maps

streams Markdown rendering in Angular → smooths AI chats without rewriting the renderer

installs markstream without superfluous dependencies, CSS in the right order → avoids broken rendering

migrates your Markdown rendering to Markstream or its v2 → without breaking existing code

frames the integration of markstream in Nuxt → avoids SSR and hydration errors

adds markstream-react to React or Next → streaming Markdown rendering without SSR errors

guides markstream-svelte in Svelte 5 → smooth streaming Markdown rendering, without SSR bugs

configures markstream-vue in a Vue 3 app → smooth Markdown rendering for AI responses

explains how to connect MCP servers in a plugin → links external services cleanly

guides you in building an MCP server → better-designed tools for LLMs

connects external services via MCP → structured tools available directly in Claude Code

installs the Meta Pixel and checks conversions before ads → avoids blind campaigns

guides migrating from Branch or AppsFlyer to Detour → keeps your deep links working

guides the React Native migration to the strict TypeScript API → fewer type errors

guides migration from Modifier.composed to Modifier.Node → faster Compose modifiers, fewer recompositions

generates Temporal YAML and mirrord.json → avoids split configuration errors

hunts iPhone Safari and WebGL bugs → avoids defects invisible to automated tests

simulates a job interview from your job posting → trains you with precise, sourced feedback

reviews your MongoDB data model → avoids schemas that slow down queries

checks the impact of a dbt model change → avoids breaking production

guides you on MoQKit iOS and Android for live → sub-second latency

renders animated scenes from one real capture → credible proof without skewing the rest

designs n8n AI agents with reliable tools and JSON → avoids ignored tools and broken outputs

generates commented movie videos with voiceover → automates all the editing

assembles a video's subtitles into images, without redrawing them → keeps the original text intact

guides migrations, branches and queries on Neon → avoids schema and connection errors

keeps SQL queries live-synced in the UI → avoids polling and manual refreshes

creates and migrates a Postgres database with no setup → avoids managing data infrastructure yourself

creates Delta tables, dashboard and app from the web → live data ready for Databricks

speeds up fetch and WebSocket natively, prefetches at startup → screens display faster

drives Gemini Notebook via CLI and Python → automates sources, searches and exports hands-free

guides writing Nushell scripts → readable, validated pipelines, ready for CI

guides Nuxt 5: SSR, server routes, useFetch → avoids migration errors

cloud penetration testing method for AWS, Azure, GCP → finds privilege escalation flaws

reviews your Git changes with AI → catches bugs and flaws before merging

reviews your changes file by file against the rules → catches bugs and flaws before merging

drives a local video editor via MCP → controlled editing, each change approved before it applies

optimizes the 3D scene for mobile, pauses off-screen → fewer stutters while scrolling

creates a Paperclip agent after checking permissions → prevents unauthorized hires

creates and validates 3D buildings in Pascal → editable scenes with verified links

themes Payload admin to site colors, adds a guide → editors find their way alone

measures visits and reading time in admin, cookie-free → replaces GA without third-party script

makes texts and photos editable via Payload → clients edit without touching code

extracts text from native PDFs, without AI → instant, deterministic reading

diagnoses SwiftUI slowdowns and re-renders with Instruments → smoother iOS apps

writes voice-overs timed to the clock → avoids overly long or robotic scripts

draws the deck in a single HTML → ready-to-project pitch, no network or CDN

vectorizes a logo and animates it in HTML → faithful animation and clean outlines

opens a document to annotate and processes your remarks → precise review, no copy-pasting

checks an Android project before submission → avoids Google Play rejections and removals

documents per-project settings in .local.md → configurable plugins without cluttering git

explains plugin layout and manifest to you → components are detected correctly on load

guides you through organizing a plugin → avoids manifest and auto-discovery errors

guides you through Polars lazy mode and expressions → faster ETL than pandas

catalogs deferred shortcuts in code into a debt register → keeps them from becoming permanent

lists marked shortcuts in code → keeps postponed items from becoming permanent

turns a geo file into a map and spatial queries → ready-to-use serverless portal

displays a GeoJSON dataset on an interactive map → visualizes geographic data on the listing page

creates, edits and reads .pptx files → saves time on every presentation

creates, reads and edits .pptx → polished presentations that respect templates

adds Preline components to your HTML pages → ready-made Tailwind interfaces without guessing names

generates light and dark Preline themes → no more hand-writing CSS tokens

keeps scroll and dialogs through hot reload → avoids losing everything on each change

generates and renders themed Mermaid diagrams → more readable docs, READMEs and PRs

turns a product URL into a launch video → ready promo with no manual editing

shows MLflow tokens, latency and evaluations → spots cost drift

reads and updates RevenueCat server-side state → avoids rewriting purchase verification

reads Android RevenueCat cancellations, pauses and retention → shows the real subscription status

guides RevenueCat Android purchase error handling → clearer messages, fewer silent failures

guides Android one-time purchases via RevenueCat → avoids handling BillingClient manually

handles failed Android RevenueCat renewals → keeps subscribers from lapsing during grace period

guides Android plan changes → avoids incorrect Google Play billing modes

audits CI and tests: false greens, slowness → keeps the protection, speeds up tests

guides React Native optimization (FPS, bundle, memory) → smoother, lighter apps

guides animations, gestures and React Native threads → smoother apps, fewer bugs

gives you exact MMKV APIs, without invented methods → fewer storage bugs

guides MoQ video streaming and playback in React Native → sub-second latency

checks TV focus, D-pad and readability → avoids screens unusable with the remote

guides VisionCamera v5: camera, capture, migration from v4 → avoids API pitfalls

optimizes real-time VisionCamera camera pipelines → lower latency, fewer memory copies

guides hash tags and replica reads → avoids CROSSSLOT errors, eases the primary

spots pitfalls in Kotlin API calls → avoids lost data despite a success

transcribes and displays animated subtitles in Remotion → makes your videos accessible and more readable

questions you on each position, without inventing figures → genuine bullet points showcasing your experience

decides what goes on your CV and in what order → avoids country-specific mistakes

tailors your CV to a specific job posting, without inventing anything → better match with recruiters

checks that a PR follows Pascal's architecture rules → avoids drift between packages and regressions

reviews security without changing anything → reports only proven vulnerabilities

guides React Native rich text editor → avoids mixing HTML and Markdown

guides RNRepo setup → React Native native builds up to 2× faster

manages CRM sequences, enrolls contacts and tracks their results → tracked automatic follow-ups

prepares a Super Agent Party extension, static or Node.js → quick start, clean structure

adds an aggregated chart to a Fiori List Report → visualizes totals at a glance

animates a 3D object in SwiftUI → real shadows, smooth animations, haptic feedback

explores the schema before writing SQL → avoids queries on the wrong tables

ranks a topic's YouTube videos by views → spots the hooks that work

plans a scrolling landing page in separate sections → immersive hero, restrained motion, polished mobile

audits code security → filters out false positives, gives evidence and fixes

reviews your code, requires tests and security before shipping → avoids flaws and regressions

audits robots.txt, llms.txt, accessibility and WebMCP tools → makes sites readable by AI agents

compares your pages against a reference → quickly spots SEO regressions after each deployment

rewrites and audits your page title tags → more clicks from Google

rewrites AI-generated texts to sound human → avoids telltale automatic phrasing

searches Claude, Codex and Cursor history → avoids redoing searches already done

guides you in creating Timescale hypertables → faster inserts, reduced storage

turns your storyboards into copyable video prompts → shots more faithful to your sequence

creates, validates and signs Apple Shortcuts → avoids broken imports

creates, validates and signs Apple Shortcuts → avoids broken imports

records the game and edits a video → presents your mod in 30 seconds

build and test your skills → reliable skills, triggered at the right moment

reviews your past sessions, proposes validated improvements → the agent learns your preferences

turns your recurring Cursor sessions into a tested skill → fewer repeated instructions

creates an HTML story in one continuous shot → immersive narrative with fluid camera

collects the official brand kit per surface → verified visuals, traced sources, easy comparison

computes distances and nearby places with DuckDB → geographic answers without an API key

sorts large storage hogs by risk → frees disk space safely

has each task coded by a reviewed sub-agent → less drift and fewer regressions

guides you through Postgres before schemas, queries and RLS → avoids slowdowns and data leaks

diagnoses Swift concurrency errors before any fix → avoids randomly placed @MainActor annotations

reviews your concurrent Swift code → avoids data races and deadlocks

reworks focus across all Apple platforms → avoids screens that are impossible to navigate

writes Swift Testing tests and reads xcodebuild results correctly → avoids false greens

audits SwiftUI for VoiceOver and Dynamic Type → gives prioritized, ready-to-paste fixes

guides SwiftUI state without a ViewModel, cancelled async tasks → clear, safe data flow

reviews your SwiftUI: modern APIs, performance → more up-to-date and faster code

reads and writes SwiftUI according to Apple's rules → fewer re-renders, more idiomatic code

manages co-ownership accounts, general meetings and arrears → avoids majority errors and legal oversights

cleans a messy table against an inferred contract → fewer errors, deterministic and traceable checks

measures Compose performance in release builds → avoids figures skewed by debug mode

compresses 3D glTF models for three.js → lighter, faster web loading

measures three.js draw calls and memory, suggests merging and instancing → smoother scenes

builds three.js scenes in React JSX → simpler React 3D scenes to maintain

runs AI models in the browser or Node → avoids any Python server

translates entire books in parallel → saves hours on each book

shows and fixes reconciliation gaps → faster balance closing

checks the CSV headers TRES requires → avoids failed transaction imports

imports wallets and exchange accounts in batches into Tres → avoids address errors before creation

diagnoses Chrome DevTools MCP connection failures → finds the cause without guesswork

hooks Turnstile into front end and server → blocks bots without annoying captchas

replaces UIScreen.main and interfaceOrientation → makes UIKit apps ready for multi-window

shows the components affected by your git changes → flags risks before review

tells you which Kotlin changes hot-reload → avoids unnecessary full rebuilds

applies the official React Native diff to upgrade versions → avoids migration breakage

guides you through React Native upgrades, diff and dependencies → fewer broken builds

queries OneLake tables with DuckDB → freshness and quality checks without Spark

ranks Vercel options by your metrics → lower bills, faster routes

applies 70 React and Next.js performance rules → faster pages, fewer re-renders

React Native performance rules ranked by impact → smoother lists, lighter animations

animates pages and lists with React's native API → smooth transitions without a library

checks build scripts offline → avoids overwriting the installed claude

cuts selected passages without breaking sentences → avoids mid-sentence cuts

turns an interface video into an annotated Figma storyboard → documents states effortlessly

measures the pacing and volume of an edit → reusable methods without the original lines

turns your voiceover into a synced animated video → faster, polished explainer edits

indexes a video by scene and dialogue → avoids manually reviewing raw footage

generates the voiceover for each segment → avoids manually timing speech

publishes a structured HTML report after heavy work → clearer reading than chat

guides Vite config, plugins and SSR → avoids build errors in Vite 8

guides you through VitePress, config, theme and Markdown → clean static docs without trial and error

guides tests, mocks and coverage with Vitest → fast suites, no heavy config

turns a topic into a Vox-style collage video → fully automated narrated editing

exposes your web flows as tested WebMCP tools → reliable agents on your page

reproduces a creative site faithfully, verified by measurements → animations and WebGL reproduced without approximation

folds journal entries into a summary without modifying pages → readable journal, pages intact

styles Flutter screens with Tailwind classes → matched dark colors, less code to write

finds SwiftUI dead ends and dead buttons → avoids screens with no way out

helps you write hookify rules to flag risky commands → fewer accidents during sessions

helps you write hookify rules → avoids overly broad, noisy regex patterns

extracts text and tables from 107 formats → one tool for PDF, Office and images

runs Xcode builds and reads Swift tests → avoids false successes

compares experience by office and region → quickly spots struggling sites

decrypts Windows DPAPI secrets in authorized pentests → validates access to stored credentials

applies WCAG 2.2 → makes interfaces usable by keyboard and screen readers

maps code into seven verified docs → speeds onboarding on any unfamiliar project

makes a bit-for-bit copy verified by hash → keeps evidence intact for your case files

writes ad variants drawn from your results → hooks that convert, without AI tics

guides adding report cards with gaps → compare your usage without rewriting the reading

audits Google Ads read-only → spots wasted spend and tracking errors

designs or audits AI agent architectures → avoids superfluous components and costly mistakes

navigates, clicks, fills in forms → automates web tests and tasks

drives a real browser to test the interface → catches bugs before going live

drives the real app and verifies each screenshot → avoids broken or blurry captures

pays x402 APIs with a per-task budget → avoids the agent's uncontrolled spending

searches 16 platforms via the right source → avoids invented methods and failures

frames the use, evaluation and monitoring of a model → prevents drift in production

trains WAN and Z-Image LoRAs → customizes characters, styles and video motion

queries AIHOT for today's AI news → avoids outdated information from memory

calibrates your cam_*.mp4 videos via the AMC API → avoids scripting each calibration by hand

guides Amplify Gen2 for auth, data, storage and AI → avoids configuration errors

analyzes your sessions and tokens via SQLite → shows token use by project and model

drives your Android via ADB, verifies each gesture → reliable UI tasks, no unconfirmed sends

applies Android and KMP rules by default → avoids layering and state errors

audits your Compose composables against 6 rules → fewer recompositions and jank

guides Retrofit, coroutines and Hilt on Android → avoids poorly handled network errors

decompiles an APK and extracts its endpoints → audits the security of an Android app

checks contrast, keyboard and focus → interfaces usable by people with different abilities

searches AOSP code and CVEs → avoids blind searches

teaches you to design clear public APIs → avoids ambiguous options and hidden errors

creates logo and icons, exports all sizes → ready-to-use favicon and app icons

guides you on keywords, product page and App Store tests → more visibility and downloads

checks an iOS project before submission → fewer App Store rejections

guides iOS publishing, from signing to submission → fewer Apple rejections

helps you choose Apple's local AI runtime → keeps your data on device

draws architectures and sequences in verified HTML → makes your systems readable at a glance

draws architectures and workflows as validated HTML → clear, explorable diagrams, exportable as PNG or SVG

routes any ASO question to the right skill → avoids searching among the specialists

audits a React Native migration without running anything → avoids a costly, unmeasured bet

reconciles your conflicting numbers across tools → shows which channel actually drives results

turns a refresh SOP into JSON config → avoids endpoint typos

spots SwiftUI anti-patterns that make scrolling stutter → smoother scrolling and fewer re-renders

spots Swift 6 data races and interface freezes → safer async code

enforces backend module architecture → consistent, testable server code

generates images and text with Gemini without an API key → avoids billing, but unofficial

draws dark SVG diagrams of all kinds → makes architecture and flows easy to read

converts Markdown to styled HTML for WeChat → publishes without redoing the formatting

guides migration to Basin Pipelines, Catalog and SQL → avoids obsolete Wrangler commands

scores a blog post out of 100 → targets the fixes that really raise the score

Targets keywords and Google competition before writing → articles that fill real gaps

re-reads an article's cited sources → spots misattributed figures

audits an article for AI citations → spots weak passages before publishing

scrapes BOSS直聘 job listings via Chrome → gives clear salaries to compare the market

turns your site into a launch video → shares what you built, without editing

test your interface in the real browser → spot bugs, console errors and slowdowns

asks you for two approvals, then builds the entire site in parallel → full delivery, cost stated

makes you start from the decision before each table → fewer useless reports, reliable figures

guides you through a short commercial film → premium video without invented promises

generates one Canva design per table row → avoids manually creating each visual

creates and edits Obsidian canvases in transactions → avoids failed writes in the vault

asks you before each destructive command → avoids accidental deletions and force-pushes

delegates search and small edits to compressed sub-agents → preserves your session context

compresses CLAUDE.md into caveman style → fewer tokens, but the text goes to the provider

locates code read-only → keeps your large file-traversal paths out of context

turns a vague idea into a precise scope → avoids coding blindly

opens commit, push and PR after checking the project → avoids sloppy submissions

documents a solved problem as durable repo learning → avoids repeating the same investigation

burns the edit into an mp4 with subtitles and animations → one verified final file

re-aligns subtitles to the edit → fixes misheard names and cuts

drives Cherry Studio live to test your PRs → bugs found in the real app

drives Chrome to debug, test and inspect network → web bugs found faster

gives you the right Claude API models and parameters → avoids outdated code

scans your code and changes → spots security flaws before going live

scans dependencies, secrets and OWASP flaws → spots exposed keys before going to production

draws sprites and icons in code, no image model → unblocks when no image route exists

runs Codex for a second opinion on your code → spots flaws faster

tests the Codex plugin without touching your ~/.codex → avoids regressions in your config

turns documents into a memory graph for agents → reliable recall across sessions

explains how to handle CometChat Android UI events → avoids leaks and forgotten listeners

teaches you the structure of slash commands and their arguments → reusable, consistent commands

guides you through creating your own slash commands → avoids frontmatter and argument errors

displays components and their variants without modifying them → quick visual review of each state

chooses the approach and which Compose files to read → fairer changes, fewer drifts

Compose guide on state, animations and navigation → fewer re-renders, smoother UI

imposes MVI architecture and Koin for Compose apps → coherent code, fewer drifts

configures modules, build-logic and Compose Multiplatform versions → consistent build, less drift between modules

tests isolated Compose UI, states and focus included → more reliable, deterministic UI tests

tunes Compose list prefetch window → fewer lost images during fast scrolling

suggests prioritized Kafka settings without changing anything → more reliable latency and durability

guides a leaking funnel, step by step → more conversions, verified by tests

converts CSV, Excel, JSON or Parquet via DuckDB → avoids writing a conversion script

guides you from blank page to live site, message first → pages that convert

guides you through XSS, SQLi, SSTI and JWT → helps you solve web CTF challenges faster

indexes files or folders into a search database → avoids rereading the entire codebase

removes stutters and botched takes after your approval → avoids cutting intended emphasis

removes silences from a talking-head video → tighter edit, no dead air

requires Dataplex profiling before any BigQuery cleanup → avoids blind corrections

guides sending conversions to Google Ads and GA4 → more reliable ad measurement

grounds every SQL query in the DataHub catalog → avoids invented columns and metrics