sawrus
106 verified skills1,272 total stars
prometheus-alertmanager
Write production-quality Prometheus alert rules, recording rules, and Alertmanager routing configs.
testing12
tls-termination
Configure TLS termination with cert-manager — Let's Encrypt, internal CA via Vault PKI, wildcard certs, mTLS between services.
tools12
templates
Project scaffolding templates for new applications. Use when creating new projects from scratch. Contains 12 templates for various tech stacks.
data-ai12
general-dev-tools
Core development tools used across any project — git, docker, make, CI/CD, linting, formatting, pre-commit hooks.
tools12
build-optimization
Optimize CI build speed — Docker layer caching, dependency caching, multi-stage builds, parallelism, and build matrix strategies.
development12
distributed-tracing
Implement distributed tracing with OpenTelemetry, Tempo/Jaeger — instrumentation, sampling, and trace-to-log correlation. Use when the user asks about distributed tracing, OpenTelemetry setup, span instrumentation, trace propagation, or connecting traces to logs and metrics.
testing12
observability
Implement structured logging, distributed tracing, and metrics for production-ready backend services.
development12
areas/software/data-engineering/skills/lineage-governance
# Skill: Data Lineage & Governance ## When to load When tracing data origins, assessing impact of schema changes, or managing data catalog. ## Lineage in dbt ``` dbt manifest.json contains full lineage graph. Use: dbt ls --select +model_name (upstream) dbt ls --select model_name+ (downstream) ``` ## Impact Assessment for Column Change ``` Before renaming/dropping a column: 1. dbt ls --select model_name+ → list all downstream models 2. Check dashboards/BI tools connected to those model
tools12
areas/software/mlops/skills/model-monitoring
# Skill: Model Monitoring ## When to load When setting up monitoring for a deployed model or responding to drift alerts. ## Monitoring Dimensions ``` 1. Operational health - Latency: p50, p95, p99 - Error rate: prediction failures, input validation failures 2. Data drift (vs training baseline) - PSI (Population Stability Index) per feature - PSI > 0.2 = significant shift → retrain likely needed 3. Model quality (when labels available) - Accuracy metrics after ground truth ar
testing12
areas/software/platform/skills/networking
# Skill: Cloud Networking ## When to load When designing VPC topology, configuring security groups, setting up NAT, or reviewing network architecture. ## VPC Design (3-tier) ``` VPC (10.0.0.0/16) ├── Public subnets (10.0.1.0/24, 10.0.2.0/24) ← ALB, NAT Gateway ├── Private subnets (10.0.10.0/24, 10.0.11.0/24) ← App servers, K8s nodes └── Isolated subnets (10.0.20.0/24, 10.0.21.0/24) ← RDS, ElastiCache ``` ## Security Group Rules (Default-Deny) ```hcl # App tier: only accepts traffic from
testing12
areas/software/frontend/skills/testing-patterns
# Skill: Frontend Testing Patterns ## When to load When writing tests for components, hooks, or integration flows. ## Philosophy Test **behavior**, not implementation. A user doesn't care that you called `setState`; they care that clicking "Submit" shows a success message. ## Component Test Template ```tsx import { render, screen } from '@testing-library/react'; import userEvent from '@testing-library/user-event'; import { UserCard } from './UserCard'; const defaultUser: User = { id: '1
tools12
areas/software/platform/skills/incident-response
# Skill: Incident Response Runbooks ## When to load When responding to a production alert, diagnosing an outage, or writing a postmortem. ## Severity Classification | Severity | Definition | Response Time | |:---|:---|:---| | P0 | Complete outage, data loss | Immediate | | P1 | Significant degradation, key feature broken | 15 min | | P2 | Minor degradation, workaround exists | 1 hour | | P3 | Non-user-facing | Next business day | ## P0 Response Playbook ``` T+0: ACKNOWLEDGE — "I'm on this
testing12
qa_expert
QA Expert for writing E2E tests, test scenarios, test plans, and ensuring test coverage quality.
testing12
areas/software/security/skills/security-headers
# Skill: HTTP Security Headers ## When to load When configuring web servers, API gateways, or reviewing HTTP responses. ## Required Headers ```nginx add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always; add_header X-Content-Type-Options "nosniff" always; add_header X-Frame-Options "DENY" always; add_header Referrer-Policy "strict-origin-when-cross-origin" always; add_header Permissions-Policy "camera=(), microphone=(), geolocation=()" always; add_header
development12
dns-management
DNS management for Kubernetes — CoreDNS tuning, external-dns automation, split-horizon DNS, and bare-metal DNS design.
tools12
areas/software/security/skills/sast-dast-interpretation
# Skill: SAST/DAST Results Interpretation ## When to load When reviewing security scan results, triaging vulnerabilities, or deciding which findings to fix vs. accept. ## SAST Triage Matrix | Severity | CVSS | Action | Timeline | |:---|:---|:---|:---| | Critical | 9.0–10.0 | Block merge, fix immediately | Same day | | High | 7.0–8.9 | Block deploy | 72 hours | | Medium | 4.0–6.9 | Track as tech debt | 2 weeks | | Low | 0.1–3.9 | Backlog | Next quarter | ## Common False Positives ``` False
testing12
areas/software/frontend/skills/a11y-audit
# Skill: Accessibility Audit & Remediation ## When to load When building interactive components, reviewing a PR for accessibility, or fixing a11y lint errors. ## Most Common Violations & Fixes ### 1. Icon-only button without label ```tsx // ❌ <button onClick={onClose}><CloseIcon /></button> // ✅ <button onClick={onClose} aria-label="Close dialog"> <CloseIcon aria-hidden="true" /> </button> ``` ### 2. Input without label ```tsx // ❌ <input type="email" placeholder="Email address" /> // ✅
tools12
api-design
Design and implement REST APIs with consistent conventions, versioning, error contracts, and security.
development12
api-design-principles
REST API design decisions — URL conventions, error contracts, versioning, pagination, idempotency, auth patterns.
development12
areas/software/frontend/skills/api-integration
# Skill: API Integration Patterns ## When to load When connecting a component to a REST API, handling loading/error states, or implementing optimistic updates. ## Standard Fetch Layer ```ts const apiClient = { get: async <T>(path: string, options?: RequestInit): Promise<T> => { const res = await fetch(`${import.meta.env.VITE_API_URL}${path}`, { ...options, headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${getToken()}`, ...option
tools12
areas/software/mobile/skills/app-store-prep
# Skill: App Store Submission Preparation ## When to load When preparing a release build or responding to rejection reasons. ## Pre-Submission Checklist ### Both Platforms - [ ] Version code/build number incremented - [ ] Release notes written (plain language, user-facing changes) - [ ] All new permissions declared with usage descriptions - [ ] Deep links tested end-to-end - [ ] Crash-free rate > 99.5% in pre-release testing - [ ] No debug flags in release build ### iOS Specific - [ ] `Info
development12
async-processing
Design and implement async task queues, message consumers, and background job patterns.
content-media12
areas/software/security/skills/auth-patterns
# Skill: Authentication & Authorization Patterns ## When to load When implementing login, token management, OAuth integration, RBAC, or reviewing auth code. ## JWT Best Practices ```python def create_access_token(user_id: str) -> str: return jwt.encode( payload={ "sub": user_id, "iat": datetime.utcnow(), "exp": datetime.utcnow() + timedelta(minutes=15), # Short expiry "jti": str(uuid.uuid4()), # Unique ID for revocation
development12
backend-developer
Specialized skill for Python backend development using FastAPI, SQLAlchemy, and Pydantic.
development12
blackbox-testing
Automates end-to-end and system validation tests. Runs services via Docker, feeds inputs, executes scenarios, and verifies outputs.
testing12
areas/software/platform/skills/ci-cd-pipelines
# Skill: CI/CD Pipeline Patterns ## When to load When designing GitHub Actions workflows, optimizing pipeline speed, implementing deployment gates. ## Pipeline Structure ``` .github/workflows/ ├── ci.yml # Every PR: lint, test, build, security scan ├── deploy-stg.yml # Merge to main: deploy to staging └── deploy-prd.yml # Release tag: deploy to production (with approval) ``` ## CI Template ```yaml jobs: validate: steps: - uses: actions/cache@v4 with:
development12
cluster-operations
Day-2 cluster operations — node management, etcd backup/restore, certificate rotation, namespace lifecycle.
tools12
container-hardening
Harden container images and Kubernetes workload security contexts — distroless, multi-stage, minimal attack surface.
testing12
areas/software/security/skills/crypto-standards
# Skill: Cryptography Standards ## When to load When implementing password storage, data encryption, token signing, or key management. ## Approved Algorithms | Use Case | Approved | Forbidden | |:---|:---|:---| | Password hashing | Argon2id, bcrypt (cost≥12) | MD5, SHA-1, unsalted SHA-256 | | Data encryption | AES-256-GCM, ChaCha20-Poly1305 | DES, 3DES, AES-ECB | | Token signing | RS256, ES256 | HS256 in distributed systems | | TLS | TLS 1.2+, prefer TLS 1.3 | SSLv3, TLS 1.0, TLS 1.1 | ## P
development12
css-architecture
Structure CSS/Tailwind for maintainability — tokens, BEM naming, specificity control, responsive patterns.
development12
areas/software/data-engineering/skills/data-modeling
# Skill: Data Modeling ## When to load When designing a warehouse schema, choosing between modeling approaches, or refactoring an existing model. ## Approach Decision Tree ``` Primary consumer? → BI tools + analysts: Kimball (dimensional) → Data science + ML: Wide denormalized tables → Multiple teams: Data Vault History tracking? → Never/rarely: Type 1 SCD (overwrite) → Track current + previous: Type 2 SCD (versioned rows) Scale? → < 100 GB: Simple star schema → 100 GB – 10 T
tools12
areas/software/security/skills/dependency-audit
# Skill: Dependency Audit ## When to load When adding/updating dependencies, handling security findings, preparing releases, or reviewing supply-chain risk in PRs. ## Objective Produce a dependency risk decision based on exploitability and business impact, not scanner output alone. ## Audit Workflow 1. **Inventory** - Identify direct and transitive dependencies changed in PR/release. - Record package source (registry), maintainer trust indicators, and version deltas. 2. **Scan**
development12
drift-detection
Detect, classify, and automate Terraform drift detection in CI — scheduled plans, drift metrics, cloud-native audit log correlation.
testing12
e2e-patterns
Write robust E2E tests with Playwright — page objects, resilient waiting, auth, and CI integration.
testing12
areas/software/mlops/skills/experiment-tracking
# Skill: Experiment Tracking (MLflow) ## When to load When running training experiments, comparing runs, or reproducing a historical experiment. ## MLflow Tracking Pattern ```python with mlflow.start_run(run_name="xgboost-lr-0.01-depth-6") as run: mlflow.log_params({ "model_type": "xgboost", "learning_rate": 0.01, "max_depth": 6, "data_version": dataset_version, "random_seed": 42, }) mlflow.set_tags({ "git_commit": subprocess.check_
development12
areas/software/mlops/skills/feature-engineering
# Skill: Feature Engineering ## When to load When building training datasets, designing feature pipelines, or debugging training-serving skew. ## Declarative Feature Pipeline ```python from sklearn.pipeline import Pipeline from sklearn.compose import ColumnTransformer preprocessor = ColumnTransformer(transformers=[ ('num', Pipeline([ ('imputer', SimpleImputer(strategy='median')), ('scaler', StandardScaler()), ]), numeric_features), ('cat', Pipeline([ ('im
development12
helm-charts
Design, structure, and test production-grade Helm charts with multi-environment overlays.
testing12
areas/software/mlops/skills/inference-serving
# Skill: Inference Serving ## When to load When deploying a model to an API endpoint or optimizing inference latency. ## FastAPI Inference Endpoint ```python @app.on_event("startup") def load_model(): app.state.model = mlflow.pyfunc.load_model("models:/churn-predictor/Production") app.state.preprocessor = load_preprocessor() @app.post("/predict", response_model=PredictionResponse) def predict(request: PredictionRequest): try: features = app.state.preprocessor.transform([
development12
ingress-patterns
NGINX Ingress Controller patterns — TLS, rate limiting, CORS, rewrites, path-based routing, and MetalLB for bare-metal.
documentation12
areas/software/platform/skills/k8s-manifests
# Skill: Kubernetes Manifests & Helm ## When to load When writing K8s YAML, designing Helm charts, setting resource limits, configuring probes, or reviewing pod security. ## Production Deployment Template ```yaml spec: replicas: {{ .Values.replicaCount }} # Min 2 for Tier 1 template: spec: securityContext: runAsNonRoot: true runAsUser: 1000 terminationGracePeriodSeconds: 60 containers: - name: api image: "{{ .Values.image.repositor
development12
migration-safety
Safe database migrations in production — expand-and-contract, lock-safe DDL, timing estimation, rollback SQL.
data-ai12
areas/software/mlops/skills/model-evaluation
# Skill: Model Evaluation ## When to load When evaluating a trained model, comparing versions, or performing fairness analysis. ## Threshold Selection ```python def select_optimal_threshold(y_true, y_prob, business_objective: str): """ business_objective: - 'max_f1': balanced precision/recall - 'high_precision': minimize false positives (fraud) - 'high_recall': minimize false negatives (screening) """ precisions, recalls, thresholds = precision_recall_curve(y_true
development12
network-policies
Design and implement Kubernetes NetworkPolicy and Cilium network policies for namespace isolation and service-to-service access control.
testing12
areas/software/platform/skills/observability-setup
# Skill: Observability Setup ## When to load When setting up monitoring for a new service, configuring alerts, debugging production issues. ## Golden Signals (Mandatory) Every service must expose: 1. **Latency**: p50, p95, p99 response times 2. **Traffic**: requests per second 3. **Errors**: 4xx/5xx rate 4. **Saturation**: CPU %, memory %, queue depth ## Prometheus Alert Rules ```yaml groups: - name: api-alerts rules: - alert: HighErrorRate expr: | sum(rate(ht
development12
opa-policies
Write OPA/Gatekeeper and Kyverno admission policies for Kubernetes security guardrails.
testing12
areas/software/data-engineering/skills/orchestration
# Skill: Pipeline Orchestration (Airflow) ## When to load When designing DAGs, debugging pipeline failures, or configuring retries. ## DAG Template ```python with DAG( dag_id="orders_pipeline", default_args={ "owner": "data-platform", "retries": 3, "retry_delay": timedelta(minutes=5), "retry_exponential_backoff": True, "email_on_failure": True, }, schedule="0 4 * * *", catchup=False, # ← Never True; causes backfill avalanch
development12
performance-testing
Design and execute load/stress tests with k6, establish SLO baselines, and identify bottlenecks.
testing12
areas/software/frontend/skills/performance-tuning
# Skill: Frontend Performance Tuning ## When to load When optimizing Core Web Vitals, reducing bundle size, diagnosing render performance, or reviewing images/fonts. ## Re-render Prevention ```tsx // Memoize expensive computations const sorted = useMemo( () => [...items].sort((a, b) => a.name.localeCompare(b.name)), [items] ); // Stable callback references const handleClick = useCallback(() => doSomething(id), [id]); // Memoize child components receiving object/function props const Exp
tools12
pod-troubleshooting
Systematic diagnosis of Kubernetes pod failures — CrashLoopBackOff, OOMKilled, Pending, ImagePullBackOff, and service connectivity issues. Use when the user encounters pods not starting, container restart loops, scheduling failures, or service unreachability in a K8s cluster.
devops12
postmortem-analysis
Write blameless postmortems with 5-whys RCA, actionable follow-ups, and systematic prevention measures.
documentation12
prompt-project-planner
Interactive project planning skill. Collects context, asks clarifying questions, selects rules/skills/workflows, and produces an execution-ready plan.
data-ai12
test-pyramid
Decide what type of test to write, structure the suite, measure health, and apply test doubles correctly.
testing12
service-mesh
Implement service mesh for mTLS, traffic management, and observability — Istio and Linkerd patterns for Kubernetes.
devops12
slo-sli-design
Define SLIs, SLOs, and error budgets; implement burn rate alerts; integrate with Prometheus.
content-media12
areas/software/data-engineering/skills/sql-optimization
# Skill: SQL Optimization ## When to load When writing complex queries, optimizing slow queries, designing indexes, or reviewing query performance. ## Core Patterns ```sql -- ✅ Column projection — never SELECT * SELECT user_id, created_at, total_amount FROM orders WHERE created_at >= '2026-01-01'; -- ✅ Partition pruning — filter on partition column first SELECT user_id, total_amount FROM orders WHERE order_date = '2026-01-15' -- partition filter first AND status = 'completed'; -- ❌ Func
data-ai12
areas/software/frontend/skills/state-management
# Skill: State Management ## When to load When deciding where to put state, choosing between local/global state, integrating server state, or debugging stale data. ## State Classification Matrix | State Type | Example | Solution | |:---|:---|:---| | **Local UI State** | Modal open/close, input focus | `useState` / `useReducer` | | **Shared UI State** | Theme, sidebar collapse | React Context + `useReducer` | | **Server/Remote State** | API data, pagination | React Query / SWR | | **URL State
development12
areas/software/platform/skills/terraform-patterns
# Skill: Terraform Patterns ## When to load When writing new Terraform, reviewing IaC PRs, designing module structure, or debugging plan/apply failures. ## Module Structure ``` terraform/ ├── modules/ │ ├── vpc/ │ ├── eks-cluster/ │ ├── rds-postgres/ │ └── static-site/ └── environments/ ├── staging/ │ ├── main.tf │ ├── variables.tf │ └── terraform.tfvars └── production/ ├── main.tf ├── variables.tf └── terraform.tfvars ``` **Rule**:
development12
troubleshooting
Systematic backend debugging — reproduce, isolate root cause, implement fix with regression test.
development12
vpc-design
Design cloud-agnostic private networks — subnet layout, CIDR allocation, zone redundancy, routing, and bare-metal equivalent.
testing12
artifact-management
Manage container images, Helm charts, and build artifacts — registry organization, retention, promotion between environments.
development12
postgres-operations
PostgreSQL operational runbooks — health checks, vacuum, bloat, locks, PITR, connection pool management.
testing12
db-performance
PostgreSQL query performance — EXPLAIN ANALYZE, index design, pg_stat_statements, slow query detection, connection pool tuning.
data-ai12
backup-restore
PostgreSQL backup and restore with pgBackRest — full/incremental/WAL, PITR, K8s CronJob scheduling, and restore verification.
databases12
terraform-modules
Design reusable, well-tested Terraform modules with cloud-agnostic interfaces and safe state management.
testing12
cost-optimization
Identify and reduce cloud infrastructure costs — right-sizing, reserved capacity, waste detection, tagging for cost attribution.
testing12
resource-tuning
Right-size pod resources, configure HPA/VPA/KEDA, and eliminate resource waste in Kubernetes.
devops12
rbac-design
Design minimal-privilege RBAC for workloads, operators, and human access in multi-tenant clusters.
content-media12
incident-command
Structured incident command for P0/P1 — roles, timeline, communication templates, and mitigation-first approach.
testing12
chaos-engineering
Design and run chaos experiments in Kubernetes — pod failures, network partitions, resource pressure with LitmusChaos and manual chaos.
devops12
areas/software/data-engineering/skills/dbt-patterns
# Skill: dbt Development Patterns ## When to load When building dbt models, writing macros, or configuring materializations. ## Materialization Strategy | Layer | Materialization | Why | |:---|:---|:---| | `staging/` | `view` | Always reflects source | | `intermediate/` | `ephemeral` | Reduce clutter | | `marts/` | `table` or `incremental` | Pre-computed for BI | ## Incremental Model ```sql {{ config( materialized='incremental', unique_key='order_id', incrementa
development12
areas/software/data-engineering/skills/quality-checks
# Skill: Data Quality Checks ## When to load When adding tests to dbt models, implementing data validation, or investigating quality incidents. ## dbt Test Taxonomy ```yaml models: - name: fct_orders columns: - name: order_key tests: [unique, not_null] - name: user_key tests: - not_null - relationships: to: ref('dim_users') field: user_key - name: total_amount tests: - not_null
testing12
bash-pro
Master of defensive Bash scripting for production automation, CI/CD pipelines, and system utilities. Expert in safe, portable, and testable shell scripts.
tools12
api-patterns
API design principles and decision-making. REST vs GraphQL vs tRPC selection, response formats, versioning, pagination.
development12
areas/software/mobile/skills/navigation-patterns
# Skill: Navigation Patterns (React Navigation) ## When to load When designing app navigation, implementing deep linking, or handling auth flows. ## Architecture ```typescript const RootNavigator = () => { const { isAuthenticated, isLoading } = useAuth(); if (isLoading) return <SplashScreen />; return ( <NavigationContainer linking={linking} ref={navigationRef}> {isAuthenticated ? <AppNavigator /> : <AuthNavigator />} </NavigationContainer> ); }; const AppNavigator =
development12
areas/software/mobile/skills/mobile-testing
# Skill: Mobile Testing (Detox) ## When to load When writing E2E tests for mobile or configuring Detox. ## Detox Test Pattern ```typescript describe('Login flow', () => { beforeAll(async () => { await device.launchApp({ newInstance: true }); }); beforeEach(async () => { await device.reloadReactNative(); }); it('should login with valid credentials', async () => { await element(by.id('email-input')).typeText('[email protected]'); await element(by.id('password-input')).typeText('p
development12
areas/software/platform/skills/secrets-management
# Skill: Secrets Management ## When to load When provisioning a new service, rotating credentials, or setting up CI/CD secrets. ## Secrets Hierarchy ``` Level 1: Static secrets (rotate quarterly) → AWS Secrets Manager / HashiCorp Vault → Database passwords, API keys for external services Level 2: Dynamic secrets (auto-expire, 1 hour) → Vault dynamic secrets / AWS IAM OIDC roles Level 3: Runtime injection (never on disk) → K8s ExternalSecrets Operator → mounts as env vars → Never
development12
test-data-management
Manage test data with factories, fixtures, isolation strategies, and cleanup to prevent test pollution.
testing12
design_expert
Expert UI/UX design intelligence for creating distinctive, high-craft, and mobile-first interfaces. Focuses on premium aesthetics, touch-first ergonomics, and Flutter performance.
development12
code_review_expert
Code Review Expert for static analysis, security auditing, architecture review, and ensuring code quality standards.
development12
threat-modeling
Apply STRIDE threat modeling to system designs, identify IDOR and authorization vulnerabilities, and build threat matrices for security reviews. Use when the user designs a new system, reviews an architecture, prepares for a security audit, or asks about common API vulnerabilities like IDOR or broken access control.
development12
ansible-playbooks
Write idempotent Ansible playbooks and roles for server configuration, K8s node provisioning, and application bootstrap.
documentation12
capacity-planning
Forecast infrastructure capacity needs — traffic projection, resource headroom calculations, node pool sizing, K8s cluster capacity.
testing12
babysit-pr
Babysit a GitHub pull request after creation by continuously polling review comments, CI checks/workflow runs, and mergeability state until the PR is merged/closed or user help is required. Diagnose failures, retry likely flaky failures up to 3 times, auto-fix/push branch-related issues when appropriate, and keep watching open PRs so fresh review feedback is surfaced promptly. Use when the user asks Codex to monitor a PR, watch CI, handle review comments, or keep an eye on failures and feedback on an open PR.
development12
api-testing
Write API integration tests and consumer-driven contract tests (Pact) for service boundaries.
development12
accessibility-testing
Run automated WCAG audits, manual keyboard/screen reader testing, and CI a11y gates.
testing12
areas/software/mobile/skills/state-sync
# Skill: Offline State Sync ## When to load When implementing offline-first features, handling optimistic updates, or building sync queues. ## Optimistic Update Pattern ```typescript const mutation = useMutation({ mutationFn: api.createOrder, onMutate: async (newOrder) => { await queryClient.cancelQueries({ queryKey: ['orders'] }); const previousOrders = queryClient.getQueryData<Order[]>(['orders']); queryClient.setQueryData<Order[]>(['orders'], (old = []) => [ { ...new
tools12
areas/software/mobile/skills/push-notifications
# Skill: Push Notifications ## When to load When implementing push notifications, handling notification permissions, or debugging delivery. ## Permission Request (Ask at Right Moment) ```typescript // ❌ Never ask at app launch // ✅ Ask when user understands the value async function requestNotificationPermission(context: string): Promise<boolean> { // Show custom pre-permission explanation first const userAgreed = await showNotificationExplanation(context); if (!userAgreed) return false
development12
areas/software/mobile/skills/native-modules
# Skill: Native Module Integration ## When to load When integrating device APIs, bridging to native SDKs, or debugging platform-specific behavior. ## When to Use Native Modules ``` Use Native Module: - Device hardware (camera, accelerometer, NFC, Bluetooth) - Cryptographic operations (device secure enclave) - Computation-intensive tasks (image processing, on-device ML) - Third-party SDKs without JS wrapper Stay in JS/React Native: - UI rendering and interactions - Network requests - State m
development12
python-pro
Master Python 3.12+ with modern features, async programming, performance optimization, and production-ready practices. Expert in the latest Python ecosystem including uv, ruff, pydantic, and FastAPI. Use PROACTIVELY for Python development, optimization, or advanced Python patterns.
development12
app-builder
Orchestrate full-stack application scaffolding — determine project type, select tech stack, coordinate agents, scaffold structure.
development12
component-design
Design reusable React components with compound patterns, controlled/uncontrolled hybrids, typed prop APIs, async state handling, and ARIA accessibility. Use when the user creates, refactors, or reviews React components, or mentions props, hooks, .tsx files, component APIs, or accessible UI patterns.
development12
areas/software/data-engineering/skills/streaming-patterns
# Skill: Streaming Data Patterns ## When to load When designing Kafka consumers/producers or implementing real-time pipelines. ## Producer Best Practices ```python producer = Producer({ "bootstrap.servers": settings.KAFKA_BROKERS, "acks": "all", # Wait for all replicas "retries": 5, "enable.idempotence": True, # Exactly-once delivery "compression.type": "snappy", }) ``` ## Consumer Pattern ```python consumer = Consumer({ "group.id": "order-processor-v
development12
database-modeling
Design relational schemas, write efficient queries, plan indexes, and implement safe migrations.
testing12
slo-implementation
Implement SLOs end-to-end in Prometheus — recording rules, burn rate alerts, error budget dashboards, and Sloth/pyrra integration.
tools12
log-aggregation
Set up Loki or ELK log aggregation for K8s workloads — structured logging, log routing, and log-based alerting.
tools12
grafana-dashboards
Design and maintain Grafana dashboards — service overview panels, SLO tracking, variable templates, dashboard-as-code with Grafonnet/Jsonnet.
development12
sbom-supply-chain
Generate, attach, and verify SBOMs (CycloneDX/SPDX) for container images; implement SLSA provenance; harden software supply chain.
testing12
redis-operations
Redis operational runbooks — memory management, eviction policy, persistence config, Sentinel/Cluster, K8s-hosted Redis ops.
databases12
pipeline-security
Secure CI/CD pipelines with keyless signing, OIDC federation, provenance attestations, policy enforcement, and hardened runners.
testing12
gitlab-ci-patterns
GitLab CI/CD pipelines — include templates, environments, OIDC auth, caching, protected runners, deployment gates.
testing12
github-actions-patterns
Production-grade GitHub Actions workflows — reusable workflows, OIDC cloud auth, caching, matrix builds, and environment protection rules. Use when the user creates, reviews, or debugs CI/CD pipelines in .github/workflows, or asks about GitHub Actions deployment, OIDC authentication, or workflow optimization.
development12
sigstore-signing
Sign container images and artifacts with cosign (keyless via OIDC and key-based); verify signatures in CD pipelines and admission policies.
testing12
state-management
Manage Terraform remote state — backend setup, state isolation, locking, import, mv, and state surgery.
development12
secret-detection
Detect secrets in code, git history, and running containers — pre-commit hooks, CI scanning, and incident response for exposed credentials.
development12
areas/software/frontend/skills/error-handling
# Skill: Frontend Error Handling ## When to load When adding error boundaries, handling async errors, or building error UI states. ## Error Boundary ```tsx class ErrorBoundary extends React.Component< { fallback: React.ComponentType<{ error: Error; reset: () => void }> }, { error: Error | null } > { state = { error: null }; static getDerivedStateFromError(error: Error) { return { error }; } componentDidCatch(error: Error, info: React.ErrorInfo) { logger.error('UI Error'
development12
skill-creator
Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.
tools12