Anti Slop

Use this skill when the user is designing any visual system, UI, graphic, layout, brand asset, or interface and needs structured, high-quality, communication-first design decisions across typography, layout, color, imagery, and UX.

Use when code is hard to read, has duplication, is too complex, has grown beyond 300 lines, or needs restructuring without changing behavior. For extracting functions, simplifying nested logic, removing dead code, improving naming, splitting large files, and applying clean code principles. Activate when user says "clean this up", "this is messy", "simplify", "extract", or "improve readability".

Use when investigating a bug, runtime error, unexpected behavior, test failure, or crash. For systematic root cause analysis, error message interpretation, stack trace reading, reproduction steps, and targeted fixes. Activate when the user says "it's broken", "this doesn't work", "I'm getting an error", or "help me debug".

Use when the team needs API routes, action contracts, request and response shapes, error handling, pagination, or webhook patterns for a backend or BFF. Trigger on requests to design APIs before implementation.

Use this when reviewing code changes for correctness, maintainability, security-sensitive logic, boundary separation, and likely regressions across any supported runtime or framework.

Use when an existing Antigravity skill has weak triggers, vague instructions, missing constraints, or poor structure and needs to be improved. Trigger on requests to rewrite, tighten, split, or review a skill for better routing and reuse.

Use this when reviewing a full system design, architecture plan, or cross-service implementation for operational risk, boundary clarity, security posture, deployability, and maintainability.

Use when user flows already exist and the team needs a screen inventory, screen responsibilities, key states, and view hierarchy for a product or feature. Trigger on requests to break a flow into pages, views, or screen-level structure.

Use when debugging slow SQL queries, designing database indexes, or rewriting queries for better performance. For EXPLAIN analysis, index strategy, N+1 problem resolution, and query optimization patterns.

Design user journeys and task flows for a product concept or MVP. Use when the team needs primary flows, branch conditions, edge cases, onboarding paths, and end-to-end user movement before screen planning or UI implementation.

Use when the team needs a repeatable multi-step workflow, pipeline, or operating sequence that connects multiple skills, systems, or product stages. Trigger on requests to design a workflow from idea to launch, onboarding to retention, or request to execution.

Use this when the deliverable is a CLI tool, command suite, operator utility, or local developer tool and the team needs command structure, UX, config, packaging, and safety planning across languages.

Use this when reviewing a feature, service, API, auth design, integration, job system, or deployment plan for security weaknesses, unsafe trust assumptions, input risks, or privilege issues.

Use when the team needs to understand how data moves through frontend, backend, database, jobs, auth, and external integrations. Trigger on requests to map data flow, event flow, or state transitions across the system.

Use this when designing or scaffolding a Python API service, endpoint structure, request validation approach, handler layout, or API-specific service patterns in FastAPI, Flask-style, or similar Python backends.

Use when a product needs third-party integrations such as payments, email, analytics, AI providers, storage, or internal services. Trigger on requests to plan integration boundaries, provider selection, failure handling, or sync strategies.

Use this when a feature or product needs a clear end-to-end user journey across entry, action, system response, and outcome. Trigger on requests to map the full experience before screens or components are finalized.

Use this when background workers or job processors need design or review. Trigger on requests about asynchronous processing, job payloads, retries, scheduling, worker ownership, or long-running tasks outside the request path.

Use this when planning or refining an Express or Express-style Node.js API with route groups, middleware boundaries, validation, auth, error handling, and service layering.

Use this when the team needs detailed interaction behavior for user inputs, transitions, feedback, validation, confirmations, or stateful UI behavior that should be implementation-ready rather than purely visual.

Use this when designing or refining a Node.js backend service, daemon, worker, integration service, or internal runtime that is not just an Express route layer.

Use this when the system needs logging, metrics, tracing, alerting, or operator-visible runtime signals for APIs, workers, integrations, serverless functions, or local-to-production supportability.

Use this when the team needs to improve latency, throughput, render performance, query speed, worker throughput, or resource usage across frontend, backend, database, or background systems.

Use when the team needs reusable UI component patterns, component responsibilities, states, props, and interaction behavior for React, Next.js, or Tailwind-based interfaces. Trigger on requests to design a component system or define a component before coding it.

Use this when the team needs to define permissions, roles, membership rules, resource ownership, or action-level authorization separate from authentication choice. Trigger on requests about access models, RBAC, ABAC, tenancy, or protected operations.

Use this when reviewing or designing UI for keyboard access, semantic structure, focus handling, labels, contrast, error communication, motion sensitivity, or screen-reader-friendly behavior.

Use this when frontend or service code needs help integrating with an API, provider, or internal backend contract. Trigger on requests about request flow, response handling, auth propagation, retries, or client-side integration patterns.

Design authentication and authorization strategy for a product or MVP. Use when the team needs sign-in methods, session model, user/workspace membership, roles, tenant boundaries, invitation flows, or permission enforcement plans.

Use this when a codebase or design effort needs consistency enforcement for tokens, spacing, typography, color usage, component variants, and reusable interaction patterns.

Use when the team needs authentication, identity providers, custom claims, session strategy, or permission design for a Firebase-backed app. Trigger on requests to design or review Firebase Auth architecture.

Use this when a Python worker, consumer, scheduled processor, or background execution service needs design or review. Trigger on requests about Python async jobs, consumers, schedulers, or long-running background processes.

Use when the team needs sign-in methods, profiles, sessions, invitations, memberships, or auth-related architecture for a Supabase app. Trigger on requests to design authentication and authorization using Supabase Auth.

Use when the team needs a strategy for validation errors, API failures, job retries, user-facing error UX, observability, or recovery behavior. Trigger on requests to design error handling across frontend, backend, and integrations.

Use this when building or planning a Python command-line tool, command surface, argument model, package entrypoint, or automation-oriented CLI workflow.

Use this when the system needs clear analysis of trusted versus untrusted execution contexts, external inputs, client/server boundaries, provider callbacks, or admin-level code paths. Trigger on requests about trust boundaries, attack surfaces, or where verification must happen.

Use this when the team needs to design or refine a backend service, API-facing domain module, internal service, or runtime-specific server component in Python, Node.js, or another backend environment.

Use this when the system needs scheduled tasks, cron-style jobs, periodic maintenance, sync loops, cleanup tasks, or non-interactive background automation that is not simply an API request or queue worker.

Design an application database schema from product flows and backend responsibilities. Use when the team needs core entities, relationships, lifecycle fields, indexes, audit needs, tenancy boundaries, and migration-minded schema planning for an MVP or production system.

Use this when the user gives a broad app, system, service, tool, or feature request and it must be converted into structured implementation requirements, runtime assumptions, security concerns, likely components, and handoff tasks for developer or designer skills.

Use this when the project needs Python-specific backend architecture for APIs, services, workers, scripts, or internal tools. Trigger on requests about Python runtime structure, framework fit, module boundaries, or service organization.

Use this when the system needs queue-backed processing design, message handling rules, delivery semantics, dead-letter strategy, or throughput planning. Trigger on requests about queues, brokers, message processing, and consumer coordination.

Use when designing PostgreSQL tables, enums, relationships, migrations, storage metadata, or tenant-aware schema structures for a Supabase-backed app. Trigger on requests about Supabase schema planning or SQL-first data design.

Use this when reviewing how a codebase organizes configuration files, env vars, runtime options, feature flags, and per-environment settings. Trigger on requests to clean up or validate config structure.

Use when building or planning Firebase Cloud Functions for webhooks, backend APIs, scheduled jobs, claim assignment, or privileged Firestore logic. Trigger on requests to create or review Firebase Functions.

Use when a Firebase app needs Firestore collection design, document shape, subcollection strategy, security rule implications, or query-aware data modeling. Trigger on requests to design Firestore data structures before implementation.

Use this when reviewing database, storage, config, queue, or integration migrations for rollout safety, rollback feasibility, data correctness, and environment-specific deployment risk.

Use when Codex needs to generate or scaffold a React or Next.js component with clear props, state handling, Tailwind styling direction, accessibility, and file structure. Trigger on requests to create a component, page section, dashboard widget, form, modal, or reusable UI block.

Use when a web product or component needs responsive layout planning across mobile, tablet, and desktop. Trigger on requests about breakpoints, layout adaptation, content priority, or mobile-first UI behavior.

Use this when the team needs to decide how responsibilities should be split across services, modules, workers, APIs, or runtimes. Trigger on requests about service boundaries, ownership, modularity, monolith versus separation, or where logic should live.

Use when the team needs to decide how frontend state should be organized across React or Next.js apps. Trigger on requests about local state, global state, server cache, forms, optimistic updates, or choosing between context, stores, and query-based patterns.

Use when the team needs a testing plan covering unit, integration, end-to-end, contract, and security-adjacent checks for a product or feature. Trigger on requests to design practical testing strategy before or during implementation.

Use this when designing scripts or small tools for automation, maintenance, CI tasks, file manipulation, config generation, or local workflow support across shell, Python, or mixed environments.

Use this when planning environment variables, config files, secrets, flags, and provider settings across local, CI, staging, production, serverless, or multi-runtime systems.

Use this when the team needs a component breakdown for a screen or feature that may or may not be React-specific. Trigger on requests to plan component responsibilities, composition, states, and boundaries before implementation.

Use this when the system needs explicit runtime validation for API inputs, config, queue messages, webhook payloads, file metadata, or external provider responses in TypeScript, JavaScript, Python, or mixed systems.

Use this when reviewing or designing how secrets, API keys, service credentials, signing keys, tokens, and environment-specific credentials are stored, loaded, rotated, and kept out of untrusted runtimes.

Use this when a project needs a better local development workflow for setup, running services, seeding data, testing integrations, or managing multi-service developer environments.

Use this when designing or scaffolding serverless functions for APIs, webhooks, background handlers, or small trusted services across cloud runtimes. Trigger on requests about serverless handlers, event functions, or function-level architecture.

Plan backend domains, services, jobs, integrations, and failure handling for a product or major feature. Use when UX and product scope are defined and the team needs a production-minded backend design without defaulting to premature microservices.

Use when a Supabase app needs Row Level Security policies for multi-tenant access, ownership checks, roles, service paths, or safe data exposure. Trigger on requests to design or review Supabase RLS and SQL authorization logic.