Results for “sar”

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 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 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 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 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 when building or planning a Supabase Edge Function for authenticated server logic, webhooks, background triggers, third-party integrations, or privileged operations. Trigger on requests to create or review edge functions in a Supabase system.

Use this when a Python service, package, or repository needs a maintainable internal structure for modules, domain logic, adapters, config, entrypoints, and tests. Trigger on requests about project layout and internal organization for Python systems.

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.

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.

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.

Plan screens, views, and page responsibilities for a product flow. Use when user journeys already exist and the team needs a screen inventory, screen purpose, key states, and component-level responsibilities without jumping into visual styling too early.

Scans a codebase for security vulnerabilities using CodeQL's interprocedural data flow and taint tracking analysis, with support for multiple languages, scan modes, and data extension models.

Takes raw whole-genome sequencing FASTQ files or a pre-existing VCF through variant calling, quality control, and polygenic risk score computation using the PGS Catalog.

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 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.

Evaluate a raw app, startup, SaaS, internal tool, marketplace, or AI product idea before planning features. Use when the user shares a vague concept and needs pain analysis, market realism, feasibility, differentiation, risks, or a build/no-build recommendation.

Use when the team needs route structure, feature modules, design-system boundaries, and frontend responsibilities for a React, Next.js, or Tailwind application. Trigger on requests about frontend architecture, app structure, pages, modules, or client-side delivery planning.

Use when the team needs a clear product point of view, product principles, or a concise philosophy statement before planning UX, features, or architecture. Trigger on requests about product vision, differentiation, or what the product should optimize for.

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 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 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.

Design product-led growth loops, activation paths, and expansion mechanics for a software product. Use when the team needs onboarding-to-value planning, sharing or collaboration loops, retention hooks, or realistic post-launch growth motions tied to product usage.

Review whether a product, MVP, or feature is actually ready to launch. Use when the team needs a production-minded check across product quality, UX edge cases, auth and security, observability, support readiness, pricing readiness, and post-launch measurement.

Design pricing, packaging, and monetization strategy for a software or AI product. Use when the team needs plan structure, free-tier logic, usage vs seat pricing tradeoffs, paywall timing, or monetization guardrails tied to product value and costs.

Detect and prevent hardcoded secrets in git repositories using Gitleaks, including pre-commit hooks, CI/CD integration, custom rules, baseline management, and remediation workflows.

Use when the user wants to create a new Antigravity skill pack or add a focused skill folder with SKILL.md, references, examples, or scripts. Trigger on requests to generate a skill, scaffold a skill, or expand the local skill library.

Prioritize features for an MVP or first release. Use when the team has too many ideas and needs must-have vs later vs never-for-v1 decisions tied to the core value loop, user pain, operational shortcuts, and launch feasibility.

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.

Extract the core product philosophy, strategic posture, and design principles from a raw concept or founder brief. Use when the team needs a crisp product promise, guiding principles, product point of view, or a philosophy statement before scope and UX planning.

Guide federal systems through the NIST Risk Management Framework (SP 800-37 Rev 2) to achieve an Authorization to Operate (ATO), covering categorization, control selection, assessment, and continuous monitoring.

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.

Comprehensive guide for setting up and configuring CodeQL code scanning via GitHub Actions workflows and the CodeQL CLI. This skill should be used when users need help with code scanning configuration, CodeQL workflow files, CodeQL CLI commands, SARIF output, security analysis setup, or troubleshooting CodeQL analysis.

Guides AI agents through the complete GDPR Data Subject Access Request (DSAR) workflow under Article 15, including identity verification, 30-day deadline calculation with extensions, response formatting, exemptions, and fee provisions. Activate when handling DSAR, access request, subject access, Art. 15, or SAR queries.

Use when the request is broad and spans idea evaluation, MVP planning, UX, frontend, backend, database, auth, integrations, and launch strategy. Trigger on asks like "build this app", "turn this idea into a product", "design the whole system", or "plan everything end to end".

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".