Results for “sar”

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 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 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 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 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 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 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 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 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 whether an app, service, worker, CLI, or serverless system is ready for its target environment with respect to config, secrets, migrations, dependencies, observability, rollback, and runtime constraints.

Use when context window is filling up, sessions are getting slow, or you need to preserve state across sessions. For context compression, state snapshots, search-first discipline, and cross-session memory management.

Integrate antennas into RF systems using MATLAB Antenna Toolbox and RF Toolbox. Covers impedance matching network design (L/Pi/Tee topologies, evaluation parameters, Richards transformation), measured antenna creation (E-field, directivity-only, EmbeddedE, ffsReader import), RF propagation and site planning (txsite/rxsite, coverage, SINR, ray tracing, link budget), and SAR estimation (birdcage+Phantom, conformalArray+Custom3D, direct EHfields). Use when the user wants to match an antenna, create a measuredAntenna, compute coverage or signal strength, perform ray tracing, or estimate SAR.

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

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

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

Design API contracts from product flows and backend responsibilities. Use when the team needs resource models, action endpoints, request and response shapes, error handling, pagination rules, and contract clarity before implementation begins.

Runs Semgrep static analysis to find bugs and security vulnerabilities, with guidance on installation, rule selection, custom rule writing, and CI/CD integration.

Write an implementation plan from an approved architecture and MVP scope. Use when the team needs milestones, workstreams, dependency ordering, acceptance criteria, and execution sequencing that connect product intent to shippable engineering work.

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

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 when the team needs a top-level system architecture spanning frontend, backend, auth, data stores, jobs, integrations, and deployment boundaries. Trigger on requests to design the overall system or validate a proposed architecture.

Use this when the project needs a clear strategy for local, test, staging, production, cloud, serverless, or hybrid environments. Trigger on requests about environment layout, runtime differences, environment-specific behavior, or deployment-context planning.

Use this when reviewing or designing Firebase security rules for Firestore or related client-accessed Firebase data. Trigger on requests about Firebase rules safety, access constraints, auth-claim checks, or client data exposure.

Use when the team needs pricing, packaging, free-tier, trial, usage metering, or business-model guidance for a software product. Trigger on requests to design how the product should make money or control value access.

Plan the frontend application structure for a product or feature. Use when the team needs route structure, feature modules, state boundaries, design-system needs, and frontend delivery sequencing based on defined screens and flows.

Configure GitHub Advanced Security with CodeQL to perform automated static analysis and vulnerability detection across repositories at enterprise scale.