trino-gateway

Scores a Razorpay service repo against the Agentic SDLC Scorecard across three pillars — Context (C1–C4), Testing (T1–T4), CI/CD (D1–D4) — and outputs a band per pillar plus an aggregate score. Use when assessing how agent-ready a service is or tracking progress across teams.

Analyze alert coverage for Razorpay services by discovering multi-source monitoring (Prometheus, CloudWatch RDS, Performance Insights, Coralogix logs), scanning application metrics, and identifying missing business-critical metrics. Leverages repo skill Observability/Monitoring sections (when available) and verifies existing coverage with user before recommendations. Use when the user asks to analyze alert coverage, check for missing alerts, audit monitoring completeness, add metrics and alerts for a service, or improve observability. Only works with Razorpay repositories.

Analyzes API endpoints in Go codebases and generates comprehensive flow visualizations (both Mermaid charts and ASCII diagrams) showing the complete request execution path, including handlers, middleware, services, database queries, external HTTP APIs, cache operations, message queues, and all other components. Use when the user asks to visualize an API endpoint, see the flow of an API, understand how an API works, trace an API request, or map out API dependencies. Triggers on requests like "show me the flow for POST /users/create", "visualize the /orders endpoint", "trace the API call for account creation", or "map out what services are used by this endpoint".

Use when creating, updating, or reviewing baseline Prometheus alert rules for a Razorpay microservice. Triggered by requests like 'add baseline alerts for X service', 'set up monitoring alerts', 'create baseline alerting for my service'.

Index of baseline metric families for Razorpay services. Use it to determine which standard metrics must exist for HTTP, gRPC, workers, egress, outbox, Go runtime, and relevant infra components.

Apply security best practices when writing, reviewing, or discussing code. Covers authentication, injection prevention, API security, input validation, infrastructure, and AI/LLM security for Python, Go, JS/TS, React, PHP, Node.js.

Generates ready-to-run cURL commands from any codebase (Go, Laravel, Express, Fastify, or other frameworks). Scans route definitions to auto-generate commands, or builds them from user-described endpoints. Includes proper headers, authentication, request bodies with realistic sample data, and environment support (devstack/prod). Use when users ask to "generate curl", "create curl commands", "curl examples for this API", "test this endpoint", or "generate API commands".

Standards for SQL interactions within a Domain package.

Guide users in selecting the right data system (hot/warm/cold storage, OLAP, compute engines) and understanding overall data flow architecture. Use when someone is: (1) Building a new data feature and needs to choose where to query data, (2) Understanding how data flows from source to consumption, (3) Migrating workloads between systems, (4) Troubleshooting performance issues by validating system fit, (5) Understanding data architecture patterns, or (6) Making build vs buy decisions for data infrastructure. Triggers include 'which database should I use', 'how does data flow', 'data pipeline architecture', 'explain the data platform', 'data system selection', 'storage vs compute', 'OLAP vs lakehouse', 'CDC to lakehouse'.

Deploy and debug helmfile-based services with automated configuration validation, intelligent troubleshooting, and autonomous error recovery. Use when (1) Setting up devstack for new developers, (2) Onboarding new applications to devstack, (3) Creating helm charts and ephemeral resources (DB, cache, SQS, SNS), (4) Deploying helmfile services with devstack labels, (5) Debugging pod failures and crashes, (6) Validating helmfile/helm chart configurations, (7) Troubleshooting ImagePullBackOff, CrashLoopBackOff, OOMKilled errors, (8) Auto-fixing resource limits, probes, and configuration issues, (9) Post-deployment health monitoring and recovery, (10) Setting up devspace for live code sync and debugging.

Optimise Dockerfiles in repositories for better Docker layer caching. Reorders layers so static/rarely-changing layers are at the top and build-specific ARGs/ENVs are placed after the cache-busting source copy.

Debug oncall production issues for Data Platform CDC pipeline services (datasink, harvester, maxwell, kafka-connect, entity-operator staging-table-pipeline, entity-operator replication-table-pipeline). Use when an alert fires from Slack/Zenduty for any of these services. Parses alert text, queries Grafana metrics, uses Friday MCP for EMR cluster status and spot loss detection, traces cascading failures across the pipeline (TiDB path and datalake path), identifies root cause, and suggests fixes. Handles lag alerts, replication issues, job failures, spot loss, TiDB/Kafka health checks, and datalake freshness issues.

Identifies the right people to contact for a feature by searching across GitHub (code/PR/commit history), DevRev (tickets), and Slack (conversations). Use when you need to know who owns or has worked on a particular feature, module, or system — before raising a PR, asking for a review, or debugging an unfamiliar area.

Optimize Flink job code and configuration based on runtime metrics and execution flow graph. Use when user asks to "optimize Flink job", "analyze Flink job performance", "check for backpressure", "review Flink DAG", "find Flink configuration issues", or provides a Flink cluster URL with job ID. Analyzes running jobs from Flink UI (via REST API), reviews YAML jobspec configuration, examines Java DAG construction code, and identifies optimization opportunities including backpressure, data skew, dead code/wiring, incorrect stream connections, checkpoint issues, memory configuration, and inefficient aggregations.

Five-layer Go code review framework (Intent → Correctness → Scope → Quality → Post) with CRITICAL transaction context detection and mandatory inline comments. Use when reviewing Go code changes, PRs, or commits. Triggers on: 'review this PR', 'check my Go code', 'review my changes', '/go-code-reviewer', '/review-go', or when user asks for Go code quality assessment. Enforces research-backed quality gates from Google, Uber, and Razorpay standards with strict output guardrails (concise reviews under 300 lines, professional tone, 3-5 mandatory inline comments per review). Includes automated pattern detection for auth, database, API, and concurrency changes. NEW in v4.2: Executive summary with quality ratings, SOLID principles assessment, security risk levels, positive observations section, acceptance criteria, and structured next steps. v4.1: Mandatory inline comments and guardrails. v4.0: Transaction context bug detection (CRITICAL), comprehensive Razorpay reference guides.

Analyzes Go codebases to identify unprotected goroutines and systematically adds panic recovery handlers to prevent service crashes. Use when users request panic handling improvements, service resilience enhancements, or goroutine safety analysis. Triggers include "add panic recovery", "find unhandled panics", "protect goroutines", "make service resilient to panics", "scan for unsafe goroutines", or any request to prevent panics from crashing Go services.

Generates unit tests for Go code changes on a feature branch. Analyzes git diff, creates table-driven tests with GoMock/testify, updates affected existing tests, runs locally until >95% coverage passes (max 5 iterations), commits, pushes, and monitors CI. Use when user wants to generate unit tests for branch changes.

Generate production-ready Grafana dashboards from Prometheus metrics. Outputs JSON that can be directly pasted into Grafana's import menu. Use when users ask to "create grafana dashboard", "generate dashboard for metrics", "visualize prometheus metrics", "build grafana panels", or need to convert Prometheus metrics into Grafana visualizations.

Query Prometheus metrics via Grafana MCP across Razorpay cells (IN, SG, US) with seamless SAML SSO. Use when users ask to "query prometheus", "check grafana metrics", "run promql", "list metrics", "compare metrics across cells", "investigate service health", "check latency/error rate/throughput", "pull dashboard metrics", or need live Prometheus data from any Grafana cell.

Generate Helm charts and Kubernetes manifests for Razorpay services, then open PRs on razorpay/kube-manifests via MCP tools (no local git commands). Supports onboarding new services, adding components (workers, cronjobs, HPA, PDB, KEDA, ConfigMap) to existing services, onboarding UPI gateways, and previewing chart files. All chart generation and PR creation happens server-side through MCP tool calls. Use this skill whenever the user asks to onboard a service to Kubernetes, scaffold Helm charts, add workers/cronjobs/ HPA/PDB/KEDA to an existing service, onboard a UPI gateway, or create kube-manifests PRs. Triggers on: '/helm-chart-generator', 'generate helm chart', 'create helm chart', 'onboard service to k8s', 'add worker to service', 'add cronjob', 'deploy my service', 'I need k8s manifests', 'kube-manifests PR', 'onboard UPI gateway', 'helm chart', 'IngressRoute', 'deploy a new microservice'.

Execute end-to-end business integration tests on payment servers using AI. Orchestrates multi-step payment workflows, validates business logic, and ensures payment systems work correctly before going to production.

Comprehensive Kubernetes pod debugging and log analysis using Friday MCP server. Use when troubleshooting K8s pod issues including (1) Pod startup failures or crashes, (2) High restart counts or instability, (3) Performance problems or resource issues, (4) Application errors and log analysis, (5) Namespace-wide health checks, (6) Root cause analysis of K8s incidents.

Analyze Kubernetes pod resource allocation vs actual usage and generate cost-saving recommendations. Use when optimizing pod requests/limits, finding cost-saving opportunities, or planning HPA adoption. Compares P95 usage metrics against allocated resources across prod-green and prod-white clusters.

Analyzes and optimizes log volume in Go services by scanning repositories for log statements, estimating daily volume, and generating optimization recommendations. Supports batch processing across multiple repositories with automated PR creation. Use when reducing Coralogix units consumption, optimizing logging costs across services, or auditing log hygiene for Go repositories.

Monitor Kubernetes deployments post-release by analyzing code changes and checking metrics. Use when users ask to "monitor deployment", "check deployment health", "verify deployment", "analyze deployment impact", or provide a deployment name with namespace and cluster. Automates deployment image comparison, code diff analysis, repository skill loading, flow impact analysis, and Grafana metrics validation. Generates comprehensive health reports with risk assessment.

Analyze GitHub Actions CI check failures (Unit Tests, SLIT, or E2E/ETE) for a Pull Request. Use when a PR has a failing CI check and you need to investigate why — accepts a PR URL and action type (UT / SLIT / E2E), checks the check status, and for E2E failures: locates the Argo workflow URL from PR comments, downloads Argo log artifacts as text files, lists every failing E2E test, and identifies common failure patterns with root causes. Use when asked "why is UT/SLIT/E2E failing on PR X", "analyze E2E failures", "check CI status for this PR", "debug the failing action on this PR", or "what ETEs are failing in this PR".

AI-powered PR co-pilot that autonomously handles CI failures, flaky tests, coverage issues, and AI review comments. Detects failing tests, runs them locally to identify flaky vs genuine failures, auto-generates unit tests following repo patterns, and intelligently processes AI PR review comments. Use when CI checks fail, tests are failing, coverage is low, AI review comments need addressing, or when preparing a PR for merge.

Autonomous end-to-end testing orchestrator for validating Pull Requests on devstack. Given a PR URL, analyzes the diff, infers impacted services and flows, deploys to devstack, generates test plans, executes tests, debugs failures, and generates reports. Use when (1) testing a PR end-to-end on devstack, (2) validating a code change against downstream services, (3) user says "test this PR", "validate this PR", "e2e test", "run E2E", or provides a PR URL for testing, (4) deploying and testing a feature branch, (5) generating an E2E test report for a PR.

Automated pre-mortem checks for GitHub PRs before merge. Validates infrastructure patterns (PostgreSQL, Aurora, DynamoDB, Kafka config, Kafka consumers/producers, Redis, SQS, dependency upgrades), query & index patterns (foreign keys, N+1 queries, composite indexes), service integrations (API contracts, events, Splitz experiments, Stork notifications, Passport auth, ASV account service, Router SDK), cross-border payment patterns (CFB fee handling, currency validation, exchange rates, DCC/MCC lifecycle, wallet DCC flows, skip3DS authorization, recurring payment forex, network tokenization, scrooge refund calculations), payment platform services (PG-Router service development), performance optimization (duplicate queries, missing indexes, N+1 patterns - delegated to db-network-optimizer), domain business logic, quality standards (tests, coverage), and observability (monitoring, logging). Includes comprehensive goroutine panic recovery checks and dependency upgrade validation (flags version bumps of packages use

Triages and investigates Airflow DAG, Spark/EMR, and Presto/Trino failures — classifies them into failure buckets, explains likely causes, and when runtime context is available, reads DAG config, queries AWS systems, fetches logs, and debugs a specific run. Use when given any DAG/task error, log snippet, failure description, or request to debug a DAG run.

Classifies Pull Requests to the agent-skills repository as LOW, MEDIUM, or HIGH risk based on what changed — new skills, reference edits, existing skill modifications, or structural changes. Use when reviewing PRs on agent-skills to decide review action (comment, approve, request changes). Includes auto-approval policy for safe additive changes.

Comprehensive technical specification reviewer that analyzes tech specs for alternative approaches, edge cases, optimizations, testing strategy, observability, NFRs (performance, security, availability), data consistency, and error handling. Use when asked to review tech specs, design docs, architecture proposals, or when user says "review this tech spec" or "check if I'm missing anything in this design".

Analyze Trino query costs by examining query plans, estimating CPU/memory/S3 requirements, and using historical data from delta.dbt_prod_de_metrics.trino_showback for cost prediction. Use when Claude needs to: (1) Predict query cost before execution, (2) Analyze expensive queries and suggest optimizations, (3) Understand query execution plans, (4) Identify cost-saving opportunities, or (5) Compare historical vs predicted costs. Triggers include "estimate query cost", "optimize expensive query", "analyze trino cost", "predict cost", "why is this query expensive".

Translate standard SQL queries into WDA Query Builder Go code using the goutils/wda/query-builder SDK, and validate the translation against the WDA stage API. Use when users want to: (1) Convert SQL to WDA SDK Go code, (2) Generate WDA Query JSON from SQL, (3) Validate WDA query translations against the stage API. Trigger phrases include 'translate SQL to WDA', 'WDA query builder', 'convert SQL to WDA SDK', 'SQL to WDA'.