vercel-react-best-practices
vercel-labs/agent-skillsApplies Vercel's React and Next.js performance rules when writing, reviewing or refactoring code.
Most installed first. Copy the install command into a terminal; Claude Code loads the skill when a task needs it.
Applies Vercel's React and Next.js performance rules when writing, reviewing or refactoring code.
Guides web page and app screen design with researched art directions and a strict anti-template style.
Steers React components toward compound components, lifted state and composition instead of boolean prop sprawl.
Guides adding, finding, styling and debugging shadcn/ui components in registry-based projects.
Builds gesture-driven web interfaces with Apple-style springs, momentum, interruptible motion, and typography.
Audits a codebase's animation code and writes prioritized, self-contained fix plans without editing source.
Scans a UI or codebase for spots that should animate and rejects the rest, proposing exact motion values without editing code.
Upgrades Remotion and related packages to one matching version while keeping workspace conventions and the lockfile consistent.
Guides the agent to get audio or video duration and video dimensions in the browser with Mediabunny.
Recommends one frontend library for a UI task from a curated list, preferring dependencies already installed.
Builds a UI animation from scratch, settling purpose, properties, easing and timing before writing code.
Guides native-feeling React animations with the View Transition API, covering shared elements, lists and routes.
Guides setup, toast calls, styling and troubleshooting for the Sonner React toast library.
Builds, edits and deploys React websites, apps and games through the Higgsfield CLI.
Scaffolds and bundles React, TypeScript, Tailwind and shadcn/ui apps into one HTML file.
Audits page load and interaction performance and Core Web Vitals, then recommends measured fixes.
Recreates a screenshot or mockup as a 1:1 UI implementation, then renders it and fixes visible differences.
Guides GSAP core tweens, easing, stagger, defaults, and responsive or reduced-motion animation.
Builds scroll-linked animations with GSAP ScrollTrigger, covering triggers, pinning and scrubbing.
Sequences multi-step GSAP animations with timelines, position parameters, labels and nesting.
Guides building a Tailwind CSS v4 design system with CSS-first tokens, variants and responsive patterns.
Guides building accessible, responsive, production-quality UI components, layouts, and state handling.
Guides registering and using GSAP plugins such as ScrollToPlugin, Flip, Draggable, SplitText and SVG plugins.
Guides using GSAP in React and Next.js with the useGSAP hook, scoping, and cleanup on unmount.
Explains gsap.utils helpers such as clamp, mapRange, snap, random and toArray for GSAP animations.
Audits and fixes web pages for WCAG 2.2 accessibility using Lighthouse, a11y snapshots and keyboard testing.
Shows how to run and clean up GSAP animations in Vue, Svelte and other non-React frameworks.
Guides building terminal user interfaces with OpenTUI's Core, React or Solid APIs, including layout and input.
Builds accessible, themed UI with shadcn/ui components, Tailwind utility classes, and dark mode support.
Turns an approved design into production-quality HTML and CSS code.
Walks a contributor through adding a new interaction card kind to Paperclip's issue thread, end to end.
Guides the agent to build custom interactive d3.js visualisations for charts, networks, maps and transitions.
Fills missing Lingui translation catalog entries across all app locales and checks catalog completeness.
Rebuilds existing web pages as editable local code, matching content, assets, responsive layout and interactions.
Guides adding and checking translations for AionUi's user-facing text across its configured languages and modules.
Builds animated, zero-dependency 16:9 HTML slide decks, or converts PowerPoint files into web slides.
Turns the user's live browser feedback on a working feature into focused UX fixes and local commits.
Guides integrating the IMA DAI SDK to play HLS or DASH streams with server-side ad insertion.
Guides integrating the IMA SDK to load and play VAST or VMAP video ads on web, mobile, and TV.
Enforces React and TypeScript feature-module rules under src/, including @ source-root imports and barrels.
Launches the AO Electron desktop app from the current checkout to verify frontend changes with isolated or real data.
Applies a Tailwind-based UI baseline to fix spacing, typography, and small layout issues in interface code.
Builds a pan-and-zoom canvas that shows existing UI components and their variants without modifying them.
Builds a freeform live-preview canvas for exploring and comparing UI content kept in source files.
Finds WCAG gaps in UI code (labels, keyboard, focus, forms, contrast) and applies minimal fixes.
Fixes animation jank from layout thrashing, costly properties, scroll motion and blur effects.
Guides React and TypeScript work: Suspense fetching, lazy loading, MUI v7 styling and TanStack Router.
Builds a consumer-style dating or community dashboard with a signal ticker, KPIs, and match trend charts.
Builds React and Vite dashboards from Stitch screens, with TanStack Query and DESIGN.md tokens.
Guides shadcn/ui component discovery, installation, customization and best practices in React projects.
Converts existing frontend code into a Stitch design by extracting HTML and design system, then uploading.
Extracts a self-contained static HTML file from a running or built web app by inlining CSS and images.
Turns Stitch designs into modular Vite React components and syncs existing components to the latest designs.
Core anti-slop filter that steers the agent away from generic AI-looking UI and sets up companion skills.
Checks UI for contrast, keyboard use, focus, states and mobile details so real people can use it.
Makes layouts reflow properly across screen sizes, covering grids, overflow, tap targets and navigation.
Guides UI and visual work away from generic AI styling in color, layout, components and motion.
Edits websites and app interfaces in the active iPolloWork session, keeping tokens, IDs and runtime intact.
Reuses iPolloWork UI components, colors and interaction rules when building new plugin interfaces.
Adds coordinated spring, summer, fall and winter states to a 3D scene through one blended season control.
Builds or integrates detailed 3D models with smooth silhouettes, believable bevels and practical runtime LODs.
Plans texture resolution, PBR maps, UV scale and mip budgets so close-up 3D materials stay sharp.
Builds physically based Three.js metals with measured tints, varied roughness, patina and a bright studio environment.
Makes a Three.js object lean on hover and open a drag-to-turn inspect view on click.
Builds a Three.js paper sheet with fibre texture, torn edges, thickness, ink wicking and back-light glow.
Renders a Three.js canvas at explicit 200 percent or auto Retina scale with synced sizes and pointer coordinates.
Creates a camera-correct sky background with horizon haze, a shared sun direction and matching environment light.
Adds occlusion-aware sun shafts to a Three.js scene, so trees and roof edges cut the light.
Renders a realistic open sea in Three.js with Gerstner waves, sun glitter, foam, wakes and horizon haze.
Adds volumetric underwater light shafts, caustic streaks and fish dappling to a Three.js scene.
Builds guided 3D virtual tours in Three.js with authored camera routes, room navigation and floor plans.
Lights carved wood in a dark Three.js room with one window key, then scores the render against a rubric.
Builds procedural wood for Three.js with grain, pores, rays, checks and finishes, without image textures.
Asks discovery questions and collects design references before generating frontend UI code.
Applies React composition patterns like compound components and context to avoid boolean prop sprawl.
Rebuilds an app from a recon map: shell first, then the core flow, then every screen, all code written fresh.
Adds Preline UI components and page blocks to HTML files through the Preline MCP server.
Generates, previews, saves and validates Preline theme CSS with a bundled local generator script.
Makes the agent build UI from a core component library and design tokens, not hard-coded values.
Makes the agent build Formik forms with yup validation, touched-aware errors and submit handling.
Makes the agent write GraphQL operations in .gql files and use generated Apollo hooks after codegen.
Makes the agent handle loading, error and empty states so UI never shows stale or missing data.
Guides the agent through Nuxt apps: SSR, file routing, useFetch, middleware, server routes and rendering modes.
Guides the agent in defining and using Pinia stores for Vue state, including getters, actions, plugins and tests.
Guides the agent in configuring UnoCSS presets, rules, shortcuts, theme and variants for atomic CSS.
Guides the agent through Vite config, plugin API, library and SSR builds, and the Vite 8 Rolldown migration.
Makes agents write Vue 3 code with Composition API, script setup macros, reactivity and built-in components.
Guides writing Blazor components with correct parameters, render fragments, lifecycle and disposal.
Guides building Blazor forms with validation, EditForm binding and SSR-compatible submission patterns.
Migrates a pre-.NET 8 Blazor Server app to a .NET 8+ Blazor Web App with the new hosting model.
Teaches React and Next.js component, state, and performance patterns with TypeScript examples.
Audits UI against WCAG 2.2, keyboard, focus, screen reader and target size gates.
Makes the agent translate and update CoStrict extension and WebView strings across its supported locale files.
Builds scroll-driven landing pages with layered heroes, restrained motion, and checked mobile layouts.
Guides three.js animation: keyframe, skeletal and morph-target clips, mixing, and WebGPU/TSL motion.
Shrinks glTF models for three.js with gltf-transform, covering Draco, meshopt, KTX2 textures and loader setup.
Sets up three.js scenes: cameras, renderer, animation loop, resize handling, object hierarchy and cleanup.
Builds three.js geometry: built-in shapes, text, custom vertex buffers, instancing, merging and point clouds.
Audits a UI against WCAG 2.2 and ARIA patterns, returning findings with severity and specific fixes.
Builds dense data dashboards and trading views with accessible charts drawn from design tokens.
Generates accessible, token-driven component code for many frameworks, from React to SwiftUI to Flutter.
Overrides Markstream node renderers and adds trusted custom tags across Vue, React, Svelte, and Angular.
Installs markstream-vue, react, angular, or svelte into an existing repo with the minimal peer set.
Migrates other Markdown renderers to Markstream or upgrades markstream-vue 1.x integrations to 2.x.
Applies web security, compatibility and code quality best practices, verified by audits and source review.
Diagnoses and fixes LCP, INP and CLS problems using field CrUX data and browser traces before re-measuring.
Guides web performance optimization using real-user metrics and browser traces to fix slow page loads.
Reference for GSAP tweens, easing, stagger, and timelines in HyperFrames compositions.
Adds a line, bar, area, pie or scatter chart to a dataset showcase in a PortalJS portal using recharts.
Adds a Leaflet map view for GeoJSON datasets in a PortalJS dataset showcase.
Renders interactive HTML and SVG charts, tables and metric cards inline in chat via ShowWidget.
Builds a live, served interactive web dashboard in the sandbox and returns a preview URL.
Routes three ad-blocker-flagged PostHog recorder scripts through Next.js rewrites so session replay still loads.
Builds a local interactive 3D knowledge globe from the user's AIOS files, with category colors and growth replay.
Rebuilds a creative website 1:1 by reverse-engineering its bundles and checking the result against the original.
Guides building UIs with Material Design 3 in Jetpack Compose, Flutter and web, covering tokens and components.
Measures LCP, CLS and INP in Chrome with scripts, following decision trees to pick the next analysis step.
Analyzes slow interactions, INP, jank and main thread blocking with scripts and guided attribution steps.
Runs React Doctor to scan React code for security, performance and correctness issues and report a health score.
Guides adding or upgrading npm packages in the Electron app across its main, preload and renderer builds.
Guides building renderer UI in vanilla TypeScript, reusing the project's custom select and modal components.
Builds production resource center pages from existing markdown content using the site's own stack and design system.
Builds WebXR, VR and AR scenes with A-Frame's declarative HTML entity-component framework.
Selects and wires pre-built animated React components from Magic UI and React Bits.
Writes timeline, stagger, SVG and keyframe animations with the Anime.js engine.
Adds smooth page transitions and SPA-like navigation to multi-page sites with Barba.js.
Guides the agent through GSAP tweens, timelines and ScrollTrigger for scroll-driven web animations.
Adds lightweight 3D decoration to web pages with Zdog illustrations, Vanta backgrounds and tilt cards.
Guides the agent through Locomotive Scroll smooth scrolling, parallax and scroll-triggered effects.
Guides the agent in rendering After Effects Lottie JSON and dotLottie animations in web and React apps.
Guides React component patterns, Hooks usage and performance tuning, loading chapters on demand.
Keeps all five localization surfaces of the dashboard in parity across every supported language.
Scaffolds a Cloudflare full-stack app with React, Hono, D1, auth, R2 and Workers AI from a template.
Creates and edits Power Apps canvas apps via the Canvas Authoring MCP, with compile and check loops.
Guides building, debugging, and packaging Power BI custom visuals as .pbiviz with the pbiviz toolchain.
Requires checking original code and real API fields during refactors of table and enum mappings.
Applies Vue 3 and TypeScript frontend conventions, with restrained admin UI style rules and naming.
React guidance on when not to use useEffect, favoring render-time derivation, event handlers and keys.
Applies Vercel's React and Next.js performance rules when writing, reviewing or refactoring components and data fetching.
Builds complete web pages and multi-screen products in one design system, checked by an anti-slop linter.
Sets up the empty current folder with the AI App Starter for a Next.js, Supabase and Vercel app.
Routes UI build, layout, token, review and verify tasks through StyleSeed, keeping project design choices.
Adds Temps analytics to React apps: page views, custom events, scroll, Web Vitals and session replay.
Adds privacy-aware session recording and replay to React apps using the Temps SDK and rrweb.
Guides Next.js Cache Components and PPR: 'use cache', cacheLife, cacheTag, and cache invalidation.
Runs a multi-agent pipeline that builds or redesigns a whole website, looping reviews and fixes until done.
Builds algorithmic generative art on Canvas 2D: particles, flow fields, noise, fractals and L-systems.
Adds motion and micro-interactions to a UI, adapting the effects to the stack and scope.
Applies React and TypeScript decision criteria, flags frontend anti-patterns, and runs UI quality checks.
Applies Apple macOS guidelines to SwiftUI and AppKit apps, covering menu bars, toolbars, windows and shortcuts.
Applies Apple tvOS guidelines for focus-based navigation, Siri Remote input and 10-foot viewing UI.
Looks up named text animation specs and translates them into WAAPI, Motion, GSAP, CSS, Lottie, or Rive.
Uses the Better Design MCP to build, improve, and review production UI, UX, components, and motion.
Installs and uses shadcn-based ai-elements components to build AI chat interfaces in Next.js projects.
Gives WCAG patterns for news and academic sites, covering audits, alt text, accessible charts, and assistive tech.
Builds three website design directions with a review picker, asset catalog, and deployable static ZIP.
Runs a responsive pass on a UI covering breakpoints, touch targets, safe areas, and fluid type.
Guides UI design and build with anti-slop rules, a discovery phase, and layout, type, and motion advice.
Guides writing semantic markup and stable test IDs so tests and agents can locate UI elements reliably.
Refactors overly complex Dify React components by splitting code and extracting hooks.
Patterns for prompting, reviewing and refactoring UI generated by AI tools such as v0 and Stitch.
Motion and View Transitions patterns for component animation, page transitions and reduced-motion support.
Applies WCAG web accessibility practices: semantic HTML, ARIA and accessible forms for inclusive UIs.
Guides the agent to build lightweight reactive UI with Alpine.js, Tailwind CSS and backend frameworks.
Guides the agent to build scalable Angular and TypeScript apps with standalone components and signals.
Guides adding i18next localization to an app: wrapping strings, extracting keys, and optional Locize sync.
Guides use of Aceternity UI animated React components in Next.js with Tailwind and the shadcn CLI.
Builds HTML email templates from React components, previews them, and sends them through Resend.
Connects running UI to source code so the agent can edit components from captured annotations and runtime context.
Guides CesiumJS 3D Tiles work: loading, styling, feature picking, voxels, point clouds and clipping.
Guides CesiumJS camera work: flyTo, lookAt, setView, input limits, custom controllers and picking.
Runs a workflow that analyzes and documents frontend component structure, state management and conventions.
Writes Stimulus controllers that attach client-side behavior to HTML through data attributes in Symfony UX.
Builds React UI with the project's own design system, checking components, tokens and props via MCP tools.
Generates paste-ready Power Apps Canvas App YAML from a mockup, existing screen, or text description.
Guides building and reviewing product UI behavior, state, data flow and layout, with test checks.
Runs a focused finishing pass on a website's accessibility and performance details.
Audits frontend UI for generic AI design patterns and rewrites it around one deliberate design direction.
Builds a scroll-scrubbed 3D landing page from AI-generated scene videos, guided by brand and story interviews.
Audits built HTML against WCAG 2.2 A/AA, auto-fixes clear issues, and flags contrast and focus problems.
Crawls a live site read-only and paced into a capture folder that a rebuild is checked against.
Converts a live website to a static Astro site, keeping URLs, content, redirects and visuals matched.
Sets up Tailwind CSS v4 lint rules for oxlint and fixes the diagnostics they report.
Guides Firebase Authentication setup, sign-in flows, user management and auth-based data security rules.
Scaffolds a minimal Next.js and Convex project locally from one sentence, then starts the dev servers.
Guides building reusable Convex components with isolated tables and a small app-facing API.
Guides writing and reviewing Cloudflare Workers code and config against current docs and runtime rules.
Configures Better Auth server, client, database adapters, sessions and plugins in TypeScript apps.
Guides building, debugging, and reviewing Cloudflare Durable Objects for stateful coordination.
Guides building, debugging, and reviewing Cloudflare Agents SDK apps, retrieving current docs first.
Routes backend, database, and persistence tasks to the bundled Convex skills and capability catalog.
Guides setup and troubleshooting of Cloudflare Email Sending and Email Routing, checking current docs first.
Guides Stripe integration choices on sandboxes, payment APIs, Connect, billing, tax, and webhook security.
Guides upgrading Stripe API versions, webhook endpoints, server SDKs, Stripe.js and mobile SDKs safely.
Applies REST and GraphQL design principles to naming, methods, versioning and API usability.
Guides first-time Google Ads API setup, including credentials, client library choice, and a campaign retrieval script.
Guides Node.js, Express and TypeScript backend work: layered routes, services, Prisma, Zod and error handling.
Guides changes to Xberg's axum REST routes, middleware, cache endpoints and MCP tools.
Guides changes to Xberg's extraction pipeline: format detection, extractor routing and post-processing.
Explains Xberg's MIME detection, FORMATS registry and how files route to the right extractor.
Builds clone backend parts: auth, database access rules, Stripe payments, email and jobs via official APIs.
Guides adding an LLM provider to the DeepChat repo through reviewed source changes and provider config.
Guides the agent through Nitro server config, routes, caching, storage, tasks and deployment presets.
Guides adding ASP.NET Core Web API endpoints with correct HTTP semantics, OpenAPI metadata and errors.
Guides backend API design, repository and service layers, and database optimization for Node.js and Express.
Guides caching choices: invalidation, TTLs, cache keys, layers, and when not to cache.
Integrate PinMe Worker projects with email-password sign-up, id token checks, and user lookup.
Makes the agent write Worker TypeScript code that sends email through the PinMe send_email API.
Makes the agent write Worker code that stores, reads and lists files in the project's bound R2 bucket.
Makes the agent write PinMe Worker payment code with the UniwebPay SDK for checkout, refunds and webhooks.
Guides registering a new tool the RedAmon agent can call, including dispatch and parallel execution paths.
Creates, debugs, and deploys Apify Actors, and writes their input and output schema files.
Converts existing JavaScript, Python, or CLI projects into Apify Actors using the SDK or a wrapper.
Guides the agent through REST API design: resource naming, status codes, pagination, filtering, errors, versioning and rate limits.
Ktor client and remote API pitfalls in Kotlin Multiplatform: parsing, auth, retries, downloads and websockets.
Applies Convex backend conventions to functions, validators, schemas, queries, mutations, actions and scheduling.
Guides REST and GraphQL API design: resources, endpoints, status codes, errors, versioning and docs.
Implements server APIs, authentication, and data access using the project's existing backend stack.
Sets up Akka.NET actor systems under .NET Aspire, covering clustering, persistence, Akka.Management, and deployment.
Lists Akka.NET practices for event streams, supervision, error handling, and testable cluster abstractions.
Guides backend API design, REST conventions, database schema patterns and auth for server code.
Applies API conventions for REST URL naming, response envelopes, status codes, auth and versioning.
Generates API endpoint code, route handlers and docs from specs, with OpenAPI output on request.
Turns a business strategy into a deployed MVP with payments, database, auth and post-deploy checks.
Guides REST API response design to avoid field misplacement and type ambiguity, with Java overload examples.
Guides connecting a Spring Boot service to ReachAI through SDK registration, heartbeat and capabilities.
Integrates the Temps Node.js SDKs for platform API calls, KV storage and Blob file storage.
Lists production patterns for Convex apps: validators, indexes, idempotent mutations, and avoiding write conflicts.
Builds self-contained Convex components with their own schema, typed client wrapper, and npm publish setup.
Schedules Convex cron jobs and one-off delayed functions, including batching, cancellation, and debugging of missed runs.
Creates, edits and publishes Flowable BPMN workflows and OA approval forms in JeecgBoot via its APIs.
Generates full JeecgBoot CRUD code (Java, Vue3, menu SQL) from requirements and adds fields to modules.
Generates JeecgBoot CRUD modules from Freemarker templates and edits fields on existing modules.
Enforces JeecgBoot coding conventions: update-begin/end change markers, naming, entity and API patterns.
Guides implementing secure API authentication with JWT, OAuth 2.0, API keys, and token handling.
Maps entities to API Platform DTO resources with Symfony Object Mapper for separate input and output.
Adds search, range, date, boolean and sort filters to API Platform collections via the Parameters API.
Guides the agent through Alpaca Broker API account creation, KYC, documents, and status lifecycle.
Odoo 16 reference for models, views, security, controllers, migrations and tests in custom addons.
Scaffolds a layered Controller, Manager and Repository CRUD endpoint with models and tests.
Adds a JobPilot API route or module with schemas, controller, service and web hooks per repo rules.
Gives React Native and Expo best practices for list performance, animations, images, and native modules.
Adds Swift Package dependencies and links files in Xcode projects safely, using a Swift script.
Builds Expo development clients for testing native code on devices, locally or via TestFlight.
Migrates an Android app from the legacy Google Mobile Ads SDK to the Next-Gen SDK, mapping imports and method signatures.
Guides implementing Google Mobile Ads banner ads in Android, iOS, or Unity apps, defaulting to adaptive banners.
Guides installing and initializing the Google Mobile Ads SDK in Android, iOS, or Unity apps.
Guides adding interstitial ads to Android, iOS, or Unity apps, covering load, callbacks, and show.
Guides adding rewarded ads to Android, iOS, or Unity apps, including the opt-in reward flow.
Turns Stitch HTML designs into React Native StyleSheet components and updates existing ones to match.
Guides writing and reviewing SwiftUI for iOS and macOS covering state, layout, performance, and API updates.
Plan and build smooth React Native and Expo animations, gestures, and haptics that hold up on device.
Migrates an Expo Swift native module from the Expo Modules API 1.0 DSL to the 2.0 macro API.
Guides building native-feeling Expo/React Native screens to Apple HIG standards, research-first.
Guides planning, building and optimizing iOS App Clips for no-install experiences under 15MB.
Diagnoses Apple or Google app review rejections and drafts the fix, appeal and resubmission.
Makes the agent check Compose screen code for navigation, layout, inset, pager and gesture traps.
Makes the agent check Compose visual code for colour tokens, gradients, animation, images and charts.
Media3 and ExoPlayer playback pitfalls: crossfade, audio focus, loudness, queues and service lifecycle.
Scans an iOS or macOS Xcode project for common App Store rejection patterns before submission.
Builds, tests and drives iOS apps in the Simulator by tapping accessibility labels, not coordinates.
Uses AccessorySetupKit's privacy-preserving picker to discover and set up Bluetooth and Wi-Fi accessories.
Builds Live Activities and Dynamic Island UI with ActivityKit, including lifecycle and push updates.
Implements AdAttributionKit impressions, postbacks and conversion values for private ad measurement.
Schedules AlarmKit alarms and countdown timers that appear on Lock Screen, Dynamic Island and Apple Watch.
Implements App Intents so Siri, Shortcuts, Spotlight, widgets and Control Center can run app actions.
Audits App Store submissions for rejection risks in privacy manifests, StoreKit, metadata and entitlements.
Guides building an AppMigrationKit extension that moves app data between iOS and other platforms.
Guides iOS and macOS accessibility fixes and audits: VoiceOver, Dynamic Type, contrast, touch targets and WCAG.
Scans SwiftUI and UIKit code for missing accessibility labels, gesture gaps and assistive tech support.
Scans Swift camera and capture code for deprecated APIs, missing interruption handlers and permission issues.
Guides Apple Intelligence features like on-device Foundation Models, Visual Intelligence and App Intents.
Guides Core ML, Vision and Natural Language integration for on-device ML in Apple apps.
Guides AttributedString formatting, alignment, selection and SwiftUI integration for rich text.
Picks the macOS API and permission for hotkeys, menu bar, window control, screen capture, and more.
Guides Android Java work with MVVM, ViewBinding, Gradle setup and Espresso tests.
Guides advanced Compose visuals: expressive motion, AGSL shaders, DrawScope and graphicsLayer effects.
Guides creating Cubits and Blocs, sealed or status-enum state, flutter_bloc widgets and bloc tests.
Applies Material Design 3 and Android platform rules to Compose or XML UI, theming and accessibility.
Applies Apple iPhone Human Interface Guidelines to SwiftUI and UIKit screens, covering touch targets and safe areas.
Applies Apple iPad guidelines for adaptive layouts, multitasking, pointer support and keyboard shortcuts.
Builds Android apps in Kotlin and Compose with Hilt, Room and modular architecture from NowInAndroid.
Guides Core Data on iOS and macOS: stack setup, fetching, threading, migrations, performance, and CloudKit.
Enforces the house contract for Compose apps: module graph, MVI, error tiers, state, DI and coroutines.
Guides repositories, DTO-to-domain mapping, Ktor, Room, DataStore and Paging in Compose apps.
Builds or reviews a Compose screen end to end: repository, ViewModel, UI, navigation, DI and tests.
Places Compose Multiplatform code across commonMain and platform sets, and checks iOS, desktop and web interop.
Bootstraps and maintains Compose Multiplatform projects: modules, convention plugins, version catalog, CI.
Guides the agent to build Kotlin Android apps with clean architecture, MVI and Material Design.
Guides building or modernizing a Kotlin Compose Android app with architecture, policy, tests and release evidence.
Turns a website or PWA into an iOS app, with an audit, a shell or native choice and a build plan.
Builds and debugs SceneKit product scenes in SwiftUI: lighting, shadows, keyframe motion, gestures.
Guides writing and reviewing modern Jetpack Compose UI code for state, effects, navigation and Material 3.
Audits an existing game project's artifacts for template format compliance and writes a migration plan.
Audits game assets for naming, file size budgets and format standards, flagging orphans and missing references.
Writes per-asset visual specs and AI image prompts from game design docs and character profiles.
Finds balance outliers, broken progressions and economy imbalances in game formulas and data.
Guides the user from a rough idea to a written game concept brief, with optional director review gates.
Audits game design doc content counts against implemented systems, showing planned versus built.
Plans a launch-day game patch with scoped fixes, a QA gate, and a rollback plan before shipping.
Converts generated art into engine-ready sprites, sheets, masks and Blender-rendered frames for games.
Decompile a Blitz3D game to readable source with B3DDecomp and port its logic to another engine.
Identify an installed game's engine, version, loaders, saves and mod route before writing any mod code.
Search the web for game modding knowledge, using archive snapshots for dead pages and citing source URLs.
Plan and build cross-game mashups, such as bringing one game's mechanics or world into another.
Take a PC game mod idea from recon to a verified in-game result with a lab, tests and a showcase clip.
Port an existing mod to a newer game version or another loader while keeping its behavior and values.
Checks, packages and uploads a finished game mod to platforms like Nexus Mods and Steam Workshop.
Decompiles game code, dumps data formats and reads live memory so a mod can hook real game internals.
Generates game images, 3D models, rigged characters, sound and voice using local GPU tools or paid APIs.
Guides Three.js woven cloth with weave normals, sheen, folds that keep texture scale, and thin hems.
Builds Three.js falling leaves with instancing, tumbling motion, shared wind, and camera-aware recycling.
Teaches the agent melonJS 20.x changes: async Application.init, WebGL 2 baseline, post effects, removed APIs.
Guides 3D and 2.5D in melonJS: cameras, meshes, billboards, lights and fog, using its Y-down convention.
Loads glTF, GLB and OBJ 3D models into melonJS levels, with scale, right-handed conversion and lights.
Guides sound and music in melonJS: audio init formats, loading, playback, spatial audio, tones and effects.
Guides melonJS camera follow, shake, extra cameras and custom shape or gradient drawing in draw().
Guides creating, building and publishing melonJS games, including Capacitor wrapping and WeChat builds.
Guides melonJS canvas scaling and sharpness, covering scale modes, integer scaling and texture filters.
Guides melonJS post effects, blend modes and custom GLSL/WGSL shaders, noting the Canvas fallback limits.
Explains the melonJS event bus: subscribing, unsubscribing without leaks, and lifecycle event names.
Guides setting up a melonJS 20.x game: async init, world container, renderer choice, and first scene.
Covers melonJS keyboard, pointer, touch and gamepad input through named actions and common pointer event pitfalls.
Guides 2D dynamic lighting in melonJS with Light2d, ambient light, and normal-mapped sprites.
Explains melonJS asset loading: resource descriptors, asset types, preloading, retrieval and CORS settings.
Explains melonJS vector and matrix maths, in-place versus allocating methods, and interpolation helpers.
Guides melonJS particle emitters and trails, covering emission modes, sprite sheets and 3D motion settings.
Guides diagnosing and speeding up melonJS games through profiling, pooling, batching, atlases and culling.
Guides melonJS collision, bodies and queries, and choosing between built-in SAT and physics adapters.
Shows how to register melonJS plugins, use the plugin cache, patch behavior and write custom plugins.
Guides custom melonJS Renderable draw code, pointer events, post effects and draw order.
Explains melonJS WebGPU, WebGL 2 and Canvas fallback, per-backend features and capability detection.
Plans 2D game maps and scenes with collision checks, playable previews and Tiled, Godot or LDtk export.
Builds, runs and ships procedural 3D city games in Godot 4, including web export and cloud GPU streaming.
Checks Blender assets against polycount, UV, material and naming budgets before export to game engines.
Builds real-time 3D scenes, physics and PBR materials with the Babylon.js engine.
Exports Blender models and animations to web-ready glTF, with batch scripts and optimization.
Builds a runnable game prototype or production game from approved design docs, with replayable evidence.
Chooses a playable game direction for a novel by comparing concepts against hard vetoes and explicit trade-offs.
Turns a chosen game concept into a design document covering player promise, loops, feedback, failure and a playable slice.
Guides 2D work in Godot 4.3+: TileMaps, parallax scrolling, 2D lights, canvas layers, and custom drawing.
Guides 3D work in Godot 4.3+: materials, lighting, shadows, environment, fog, LOD, and decals.
Builds Godot ability systems from Resource-based abilities with cooldowns, buffs, stat modifiers, and HUD binding.
Guides creating Godot 4.3+ editor plugins with EditorPlugin, @tool scripts, custom inspectors, and dock panels.
Turns a two-camera AI clip into a rigged GLB animation, checking view agreement and fit quality.
Sets up a new creature for anymove: mesh, skeleton, skinning, limb colours and camera framing.
Designs unique game zones with layouts, NPCs and signs for Dorothy's overworld via MCP tools.
Makes the agent scan a codebase for shallow modules and present deepening options in an HTML report.
Builds a throwaway prototype, a logic walkthrough or UI variants, to answer one design question.
Sharpens a project's domain language, glossary and ADRs as design decisions are made.
Gives the agent a shared vocabulary and principles for designing deep modules with clean seams.
Restructures code while preserving behavior, bracketing each structural edit with the same verification.
Guides the agent to build narrow feature slices end to end, reusing existing seams and avoiding overbuilding.
Plans reversible schema, data, or API migrations with rollback paths and staged verification.
Has the agent explore an Nx workspace's projects, targets, and dependencies, and debug failed nx tasks.
Guides designing stable, hard-to-misuse APIs, module boundaries, and public interfaces.
Guides delivering multi-file changes in thin, tested slices, verifying and committing each step.
Guides agents to find and fix wasteful work in REA analysis providers while keeping results correct.
Guides removing old systems and migrating users or database schemas safely, without downtime.
Guides building a Paperclip agent adapter across its server, UI, and CLI packages.
Guides adding a new provider adapter to the native Paperclip Runner, from research to acceptance testing.
Analyzes a codebase into an interactive knowledge graph of architecture, components and relations.
Answers codebase questions by querying its saved knowledge graph of files, functions and dependencies.
Starts a local web dashboard that visualizes the project's saved knowledge graph of code relationships.
Guides phased, test-backed refactoring based on Martin Fowler's method, with user approval at each phase.
Applies Clean, Hexagonal and DDD patterns to set layer boundaries, dependency rules and test seams.
Guides implementing CQRS to separate read and write models for scalable, query-optimized systems.
Guides designing event stores for event-sourced systems, covering schema, ordering, versioning, and scaling.
Guides microservices design covering service boundaries, inter-service communication, data ownership and resilience patterns.
Builds read models and projections from event streams for CQRS, materialized views and query optimization.
Designs saga workflows with compensating actions for distributed transactions across microservices without 2PC.
Designs durable Temporal workflows covering workflow and activity separation, saga patterns and determinism rules.
Decides where new files and modules belong in the AionUi Electron project's process and renderer layers.
Guides the agent to write an architecture decision record covering context, alternatives and consequences.
Maps game design requirements to architecture decisions and flags coverage gaps, conflicts and engine issues.
Writes a whole-system architecture blueprint from approved game designs, checked against the pinned engine.
Builds per-system must-do and never-do coding rules from accepted architecture decision records.
Turns design docs and architecture into one epic per module, ready for story breakdown.
Breaks one epic into implementable stories, each with acceptance criteria tied to its requirements.
Traces control flows and data structures in code and draws them as compact ASCII tree diagrams.
Guides work in the ccusage monorepo, covering the npm packaging seam, just recipes, and validation steps.
Maps RDF context into BDI beliefs, desires and intentions for building explainable cognitive agents.
Enforces TypeScript feature-module rules for backend code under server/, including barrels and shared utilities.
Designs REST or GraphQL APIs with OpenAPI 3.1 specs, resource models, versioning and pagination rules.
Guides system architecture design, trade-off analysis, component diagrams and ADR writing.
Guides editing Xberg's Alef-generated language bindings, including regeneration, verification and the alef.toml config.
Explains how Xberg resolves config from CLI flags, inline JSON, files and defaults, so new settings take effect.
Describes the Xberg Rust workspace layout, version source, crate members and where new code belongs.
Finds duplicated business logic across components and suggests where to consolidate it.
Finds misplaced root-level classes and suggests flattening component hierarchies for cleaner structure.
Maps architectural components and measures their size to pick which module to extract first.
Analyzes module coupling using strength, distance, and volatility to flag architecture problems.
Builds step-by-step plans and roadmaps for splitting a monolith into services.
Maps business subdomains and bounded contexts to suggest service boundaries using DDD.
Groups existing components into business domains to plan service-based architecture.
Guides designing evolutionary modular-monolith platforms with DDD, ACL, outbox events and resilience patterns.
Produces evidence-based strangler fig migration plans for legacy systems, rewrites and framework upgrades.
Runs a staged monolith-to-modules pipeline covering sizing, coupling, duplication and domain grouping.
Gives technology-neutral guidance on module boundaries, contracts, coupling and split or merge decisions.
Detects anemic domain models and refactors them toward entities, value objects, aggregates and domain events.
Turns an app recon map into a stack, database schema, API routes and a thin slice build order.
Maps an app's screens, user flows, components and feature matrix from public pages and store listings.
Makes the agent sketch several radically different interface designs for a module and compare them.
Reviews system architecture from repo evidence, simplifies module boundaries and compares interface designs.
Maps a codebase's key files, symbols, callers and dependencies before making changes.
Implements a new-project slice and checks it against a working user journey before reporting the outcome.
Adds one bounded feature to an existing app while preserving current behavior and running affected checks.
Writes an MVP technical design from agreed requirements, covering architecture and tradeoffs.
Turns a rough idea into a design doc and implementation plan through iterative requirements and research.
Guides cloud system design with Azure Architecture Center principles, design patterns and Well-Architected reviews.
Applies Ousterhout-style rules to reduce complexity in module boundaries and API design.
Applies Clean Architecture rules to separate business policy from frameworks and infrastructure.
Applies DDD rules for modeling complex domains, bounded contexts, ubiquitous language, and aggregates.
Applies lightweight DDD rules for bounded contexts, context maps, and tactical modeling.
Applies implementation DDD rules to aggregates, repositories, domain events, and context integration.
Applies enterprise architecture patterns to choose layers, service layers, domain models, mappers, and DTOs.
Guides a resumable, phased journey to make a working but slow, tangled codebase faster and cleaner.
Guides an app idea through validation, design and architecture to a first version, logged in docs.
Recommends a data portal architecture from stated needs, then points to the matching PortalJS build skills.
Gives style and structure rules for contributing to the Claude Code source, such as file layout and naming.
Caches costly file processing results keyed by SHA-256 content hash, so moves hit and edits invalidate.
Kotlin Multiplatform structure and language pitfalls: module splits, expect/actual, Koin scoping and formatting limits.
Reactive state and background work pitfalls: StateFlow conflation, job lifecycles, WorkManager and ViewModel bases.
Explains existing behavior with checked Mermaid state diagrams, including bug and recovery paths, on request.
For non-perishable choices, the agent weighs proven options by survival age and checks for domain drift.
Guides the design review phase: checks feature design against requirements and resolves trade-offs before approval.
Guides adding ClaudeBar report cards that compare local usage data across periods, test first.
Guides adding ClaudeBar features with design-first steps, TDD, rich domain models, and Swift 6.2 patterns.
Guides improving existing ClaudeBar features with TDD and domain design, separate from new features or bug fixes.
Improves an existing app from its code, goals, past work and competitor evidence, and verifies the change.
Maps a codebase's structure, tech stack, patterns and dev workflow to explain how it works.
Guides software architecture choices, picking patterns and directory structure by project size and team.
Guides the agent to move duplicated operational logic into shared services separate from action orchestration.
Guides safe retirement of old code, duplicate owners and fallbacks, confirming before destructive deletes.
Evaluates system boundaries and architecture tradeoffs, and writes design reviews and ADRs.
Adds a new platform writer module that generates and writes agent config files for a supported AI tool.
Makes the agent build Akka.NET entity actors with Akka.Hosting that run locally or in a sharded cluster.
Finds the shallowest module in a green codebase and proposes a deeper design while keeping behavior and tests fixed.
Runs a script that renders the project's file tree as an interactive HTML map and opens it.
Guides the agent to write efficient code for large inputs, covering I/O, complexity and language tips.
Audits a multi-client codebase for blurred core and client code, producing a boundary map and refactor plan.
Refactoring checklist: read all original code first, then verify branches, fields and columns still match.
Maps knowledge components and skill hierarchies for a cognitive tutoring or adaptive learning system.
Scans a repository and produces an annotated directory tree with module roles and entry-point hints.
Reviews a growing macOS Swift codebase for hot spots and refactors it in small, behavior-safe steps.
Applies design decision criteria, flags anti-patterns, and runs quality gates for backend and general code.
Makes the agent follow language-neutral principles for simple, readable, maintainable code.
Reviews architecture with source-backed current and proposed diagrams, tradeoffs and verification steps.
Defines measurable architecture drivers and constraints in one architecture doc before system design.
Documents the architecture implemented in a repo from code evidence, without scoring or proposing changes.
Drafts a target system design from requirements, covering boundaries, contracts, data flow and tradeoffs.
Records one architecture decision with context, alternatives, consequences and status in a compact document.
Creates a few evidence-backed current or target architecture diagrams for architecture documentation.
Gives the agent the Balanced Coupling model to judge module coupling and split or merge decisions.
Makes the agent write minimal new code that reuses existing helpers and mirrors the surrounding code style.
Maps a codebase as an interactive node graph of modules, files and HTTP routes, saved as HTML.
Guides the agent to spot repeated patterns in concrete examples and extract a reusable abstraction from them.
Guides robot perception work: cameras, LiDAR, calibration, point clouds, detection and sensor sync.
Gives architecture patterns for robot software: layered stacks, behavior trees, state machines, watchdogs.
Researches a project's architecture, stack, and costs, then recommends a prioritized build plan.
Acts as a DSA mentor: explains problems, gives progressive hints, reviews code and runs mock interviews.
Writes module behavior specs and integration contracts precise enough to rebuild a product.
Tests a solution for accidental complexity, separating necessary complexity from layers added over time.
Guides structured content schema design, covering references vs embedding, reuse and taxonomies.
Runs a workflow that analyzes and documents backend API design, data access and service structure.
Makes a read-only architecture overview via LSP: languages, packages, entry points and hotspot files.
Makes the agent explain code and design questions from the source, without making any changes.
Helps the agent turn reverse-engineer-anything results into a software spec or a validated rebuild.
Turns a system design's components and connections into a self-contained dark-theme HTML and SVG diagram.
Evaluates a new dependency's license, CVEs, size and maintenance, and records an approve or reject verdict.
Guides TypeScript types: generics, conditional and mapped types, template literals, and utility types.
Guides building Fastify Node.js APIs with schemas, plugins, hooks, auth, performance and deployment.
Iterates on the Cardputer MicroPython app bundle: adds apps, pushes changed files, tails device logs.
Guides building a production-ready FastAPI project with async patterns, dependency injection, and error handling.
Guides writing and validating ccusage Nushell scripts, including Nix shebangs and GitHub Actions callers.
Guides ccusage Rust work on adapter crates, crate boundaries, and behavior parity with the existing CLI.
Guides shrinking the ccusage Rust release binary, measuring size and dependency features before editing.
Guides the remaining ccusage TypeScript and JavaScript work: the npm launcher, tests, fixtures, and typed literals.
Walks you through installing Wasp agent plugins that add Wasp framework guidance to your AI coding tools.
Walks you through setting up the Open SaaS project: checks Wasp, reads the docs, and starts the database and app.
Gives a section-by-section tour of the Open SaaS project structure, features and customization checklist.
Builds Angular 17+ standalone components, routes with guards, NgRx stores and RxJS patterns.
Writes, optimizes and debugs modern C++20/23 code, with concepts, ranges, memory care and CMake setup.
Builds .NET 8+ APIs, ASP.NET Core and Blazor apps with EF Core, async patterns and MediatR CQRS.
Builds Django apps and DRF APIs: models with indexes, optimized ORM queries, serializers and JWT auth.
Configures Django to store static and media files on AWS S3 via django-storages, including presigned URLs.
Guides building .NET 8 apps with minimal APIs, clean architecture, Entity Framework Core, and JWT auth.
Guides firmware work on microcontrollers, covering RTOS tasks, interrupts, DMA, and power optimization.
Guides building async FastAPI APIs with Pydantic V2, async SQLAlchemy, JWT auth, WebSockets and OpenAPI docs.
Sets shared Cargo feature flag names and meanings for otel, mcp, allocators and acceleration in Xberg.
Guides writing, reviewing and debugging JavaScript in n8n Code nodes and when a Code node is justified.
Guides writing Python in native n8n Code nodes and fixing their sandbox, import and input errors.
Reviews SwiftUI code for deprecated APIs, data flow, accessibility, performance and layout issues.
Makes the agent follow Anthony Fu's JS and TS conventions for file layout, imports and runtime code.
Adds authentication and authorization to a Blazor Web App, accounting for each page's render mode.
Shares state across unrelated Blazor components via cascading values, scoped services, or DI-based sources.
Scaffolds a new ASP.NET Core Blazor web app and picks the right render mode for its interactivity needs.
Runs single-file C# apps with the .NET CLI for quick experiments without creating a project.
Guides correct P/Invoke and LibraryImport declarations for calling native C/C++ libraries from .NET.
Guides Blazor components to call APIs, load and submit data, and handle loading and error states.
Plans a complex Blazor UI by splitting it into focused components with clear parent-child data flow.
Designs, optimizes and reviews SIMD code in .NET using TensorPrimitives and hardware intrinsics.
Applies general coding standards for TypeScript, JavaScript, React and Node.js covering naming, immutability and structure.
Guides writing and debugging MATLAB and GNU Octave scripts for matrix math, signal processing and plotting.
Guides the agent to scaffold and verify TinyBase local-first apps, including persistence and sync setup.
Adds three.js picking with raycasting, camera controls, transform gizmos, drag and box selection on WebGL or WebGPU.
Guides three.js light types and units, shadow maps, HDR environment lighting and light probes, on WebGL or WebGPU.
Loads three.js models and textures, including Draco, meshopt and KTX2 compression, with progress tracking and disposal.
Chooses and configures three.js materials, from unlit and toon to PBR, with WebGPU node material equivalents.
Measures and speeds up three.js scenes using render stats, instancing, LOD, merging and GPU compute.
Builds three.js post-processing chains with composer passes for bloom, depth of field, ambient occlusion and custom shaders.
Guides building and reviewing Go CLI tools with Cobra, Viper, flags, exit codes and shell completion.
Guides Go code style for clarity: variable declarations, control flow, line length and when comments help.
Guides Go concurrency: goroutine lifecycles, channels, mutexes, errgroup, singleflight and worker pools.
Guides idiomatic context.Context use in Go: propagation, cancellation, deadlines and WithoutCancel.
Guides choosing and using Go data structures: slices, maps, container packages, strings.Builder and generics.
Guides Go dependency injection: constructor wiring and choosing between wire, dig, fx or samber/do.
Manages Go modules: adding and upgrading dependencies, resolving conflicts, vulnerability scans and vendoring.
Integrates the alpha markstream-angular package into an Angular 20+ app using standalone components.
Integrates markstream-vue into Nuxt 3 or 4 apps with client-only boundaries and SSR-safe setup.
Integrates the beta markstream-react renderer into React 18+ or Next apps with client-safe boundaries.
Integrates the beta markstream-svelte renderer into Svelte 5 or SvelteKit apps with smooth streaming.
Guides adding the markstream-vue renderer to a plain Vue 3 app, including CSS, modes, and code blocks.
Guides adding markstream-vue2 to Vue 2 CLI or Webpack 4 apps, including CDN workers and code block limits.
Guides adding markstream-vue2 to Vue 2 apps built with Vite, covering worker imports and CSS ordering.
Sets up ESLint 9 flat config with neostandard for JavaScript and TypeScript, and migrates legacy configs.
Gives Node.js best practices for native TypeScript stripping, async code, streams, errors and testing.
Makes the agent check desktop JVM and build code for native libs, packaging, signing, R8 and CI traps.
Diagnoses Swift concurrency issues and guides async/await refactors and Swift 6 migration.
Enforces TypeScript conventions such as const, explicit exported return types, and no any.
Guides the agent to write, review and refactor idiomatic, maintainable Rust code.
Ports C, C++, Python, Go or JS/TS code to idiomatic Rust while keeping its observable behavior.
Guides Simulink code interface setup: names, types, storage classes, deployment type, and service interfaces.
Configures Simulink models for Embedded Coder, Simulink Coder, or AUTOSAR code generation and target selection.
Guides building motor control models with Motor Control Blockset, covering FOC, six-step control, tuning and code generation.
Customizes Simulink-generated A2L (ASAP2) files with COMPU_METHODs, GROUPs, and calibration-tool settings.
Estimates a Simulink model's frequency response from simulation data with frestimate when linearization fails.
Guides optimization of Simulink generated code for speed, RAM, ROM, stack, and MISRA, with rollback.
Converts a double-precision Simulink model or subsystem to single precision using Fixed-Point Designer.
Reviews WooCommerce code for HPOS-safe order access, server-side checkout checks, and safe money handling.
Reviews WordPress code for escaping, nonces, capability checks, prepared SQL, and translatable strings.
Analyzes Swift Package Manager dependencies, plugins, and module graph to find causes of slow Xcode builds.
Measures clean and incremental Xcode build times repeatably and writes timestamped JSON baseline results.
Applies approved Xcode build fixes one at a time, then re-benchmarks to confirm the time saved.
Runs an end-to-end Xcode build audit: benchmark, analyze, get approval, apply fixes, re-benchmark.
Finds slow Swift type checks and compile hotspots from build timing and produces a source-level optimization plan.
Audits Xcode build settings, scheme order, and script phases for build-time fixes, pending approval.
Makes the agent make .NET code trimming-safe and Native AOT compatible by fixing IL2xxx and IL3xxx warnings.
Audits Swift code for ARC, allocation and generic specialization overhead in hot paths.
Audits SwiftUI code for costly view bodies, per-render formatters and missing lazy containers.
Generates minimal reproducible MATLAB code for the approved main method and baseline, with run summaries.
Sets Bash style rules: no trailing comments, tee for file writes, and heredoc quoting conventions.
Go coding standards: naming, error wrapping, goroutine lifecycle, table-driven tests and tooling.
Java coding standards for naming, class layout, Lombok DTOs, exception handling and Spring Boot.
Python coding standards: PEP 8 style, type hints, exception handling and testing with pytest.
Sets Swift 6 and SwiftUI rules for concurrency, state, SwiftData, AppKit, and common compiler errors.
Reviews Java code for thread safety, race conditions, deadlocks, and modern virtual thread and async patterns.
Guides Makepad 2.0 animations, covering Animator states, hover effects, ease functions and timelines.
Sets up Makepad 2.0 apps, covering project scaffolding, Rust and Splash integration, hot reload and wasm deploy.
Explains Makepad 2.0 script_mod DSL syntax, colon property assignment, named instances and merge operators.
Handles Makepad 2.0 events and actions, covering inline Splash handlers, MatchEvent and Rust bridge macros.
Guides Angular code and architecture: signals, forms, routing, SSR, testing, and build checks.
Walks the agent through creating a new Angular app with the Angular CLI using current best practices.
Guides Flutter app structure: feature-first folders, layered architecture, and where logic and dependency injection belong.
Applies Dart 3 patterns, switch expressions and records to modernize if-else chains and data classes.
Gives Compose and Compose Multiplatform guidance for UI, navigation, state, and PR reviews across platforms.
Guides Blender 5.x add-on work: manifest, operators, panels, bpy.props rules, builds, and headless tests.
Creates INVENTORY-COMMANDS-JAVA.md, a fixed-template checklist of embedded command files for Java projects.
Creates a fixed-template checklist of embedded agent roles for Java projects.
Builds a checklist of every Java system prompt skill declared in skills.xml, using a fixed section template.
Plans Rails upgrades from 2.3 to 8.1 with breaking-change reports and step-by-step migration guides.
Removes Rails dual-boot scaffolding and NextRails branches, keeping either the new or the current version.
Creates a Python project layout with uv for dependencies and pytest for testing.
Automates Revit BIM work with Dynamo Python: batch edits, schedules, data export and external data links.
Guides explicit API versioning for Spring Boot 3 MVC and WebFlux via URL, header, or media type.
Guides typed, validated Spring Boot configuration properties and safe handling of secrets.
Generates production-ready Bash scripts from captured requirements, validating them before iterating.
Writes, reviews, and validates readable synthesizable Verilog-2001 RTL, with optional Vivado simulation.
Parses C source code into an abstract syntax tree printed to stdout for structural or static analysis.
Writes ACSL specifications for C code: function contracts, loop invariants and assertions for Frama-C.
Reviews WordPress PHP code for performance problems in queries, hooks, caching and templates, with severity levels.
Guides ROS 2 coding, review, debugging and ROS 1 migration across rclcpp, rclpy, colcon and Nav2.
Set up Symfony API Platform resources with explicit operations, pagination, and typed OpenAPI docs.
Shape Symfony API Platform output with serialization groups, IRI links, and custom context builders.
Gives guidance for Obsidian plugin development covering ESLint rules, API usage, UI standards and submission.
Guides Elixir Ecto data work: schemas, changesets, queries, migrations, transactions and performance.
Guides idiomatic Elixir code: pattern matching, error tuples, control flow, and when processes are needed.
Guides MATLAB code optimization through vectorization, preallocation, built-in functions and profiling.
Guides building MATLAB web apps with HTML and JavaScript interfaces connected to MATLAB via uihtml.
Checks, compiles, runs and debugs Python scripts, explaining tracebacks and asking before editing code.
Builds Symfony LiveComponents that re-render over AJAX on user input, with no custom JavaScript.
Explains CrystalJson in SnowBank for building, parsing and source-generated serializing of JSON in .NET.
Guides writing compile-clean, edit-safe TikZ and LaTeX figure code using construction-based layout.
Guides Java 17+ code toward modern features, specific exception handling, and standard project structure.
Nothing matches. Try a shorter word.