ArdurAI

@ardurai source repo

51 skills
0 followers
17 hours ago last updated

▌
God Iam AWS · ardurai bundle
God-level AWS IAM expertise. Covers IAM policies (identity-based, resource-based, permissions boundaries, SCPs, session policies), IAM roles (cross-account, service roles, IRSA, instance profiles), IAM users and groups (legacy patterns), AWS Organizations and SCPs, AWS SSO/Identity Center, ABAC with tags, IAM Access Analyzer, credential reports, CloudTrail IAM auditing, and least-privilege implementation patterns. Never fabricates IAM action names or condition keys — always verifies against AWS IAM documentation or the IAM policy simulator. Treats every permission as a potential security vulnerability.

0
installs
▌
God Iam GCP · ardurai bundle
God-level GCP IAM skill covering the GCP resource hierarchy (Org → Folder → Project → Resource), IAM roles (primitive, predefined, custom), IAM bindings and policies, Service Accounts (creation, impersonation, key management, Workload Identity Federation), Organization Policies, IAM Conditions, VPC Service Controls, Policy Intelligence (recommender, simulator, analyzer), IAM Deny policies, and Cloud Identity. Treats every service account key as a breach waiting to happen. Never fabricates GCP permission strings. Use for any GCP identity, access, organization policy, or service account task.

0
installs
▌
God LLM Sdk · ardurai bundle
God-level skill for working with LLM SDKs and AI frameworks: Anthropic Claude SDK (Python/TypeScript), OpenAI SDK (Python/TypeScript), AWS Bedrock SDK, Google Vertex AI SDK, LangChain (chains, agents, tools, memory, callbacks), LlamaIndex (document loaders, index types, query engines, retrievers), DSPy (signatures, modules, optimizers), Hugging Face transformers and datasets, Ollama for local models, LiteLLM for provider-agnostic calls, and the patterns for building production-grade AI applications. Covers API error handling, rate limiting, retry strategies, streaming, token counting, cost management, and async patterns. Never fabricates SDK method signatures — always provides verification path.

0
installs
▌
God Dev Core · ardurai bundle
Activates god-level developer mindset: researcher-first thinking, deep DSA mastery, OOP principles, SOLID/DRY/YAGNI/clean code principles, self-review loops, and zero-shortcut discipline. Load this before any coding, architecture, or engineering task. Covers end-to-end software development principles, data structures and algorithms, object-oriented design, design patterns, functional programming, concurrency, testing, debugging, and continuous self-improvement. Never assumes code is correct by default — always verifies, tears apart, and rebuilds.

0
installs
▌
God Iam Azure · ardurai bundle
God-level Azure IAM skill covering Microsoft Entra ID (formerly Azure AD), Azure RBAC, Managed Identities, Privileged Identity Management (PIM), Conditional Access, App Registrations, Service Principals, Enterprise Applications, Workload Identity Federation, Azure AD B2C, administrative units, and cross-tenant access. Covers the researcher-warrior approach to identity: every identity is a potential attack vector, every role assignment is a liability, every token is a secret. Never fabricates Azure permission names or role definitions. Use for any Azure identity, access, or authentication task.

0
installs
▌
God Mlops LLM · ardurai bundle
God-level LLM engineering skill. Covers LLM fine-tuning (full, LoRA, QLoRA, PEFT), RAG system design and evaluation, LLM evaluation frameworks, hallucination reduction techniques, prompt optimization, LLM serving (vLLM, TGI, Ollama, Triton), context window management, embedding models, vector databases, agent architectures, tool use, LLM security (prompt injection, jailbreak hardening), and LLMOps. Embeds researcher-warrior mentality: never accepts LLM output at face value, always probes failure modes, always evaluates systematically.

0
installs
▌
God API Design · ardurai bundle
God-level API design skill covering REST (Richardson Maturity Model, HTTP semantics, status codes, versioning, pagination, filtering, HATEOAS), GraphQL (schema design, resolvers, N+1 problem, DataLoader, subscriptions, federation), gRPC (Protocol Buffers, service definitions, streaming types, deadlines, interceptors), AsyncAPI and event-driven API design, API security (OAuth 2.0, OIDC, JWT, API keys, mTLS), API contracts (OpenAPI 3.1, Protobuf), API testing (contract testing with Pact, integration testing, fuzz testing), API gateway patterns, rate limiting, idempotency, and API versioning strategies. A bad API is a permanent scar on an organization — it cannot be unshipped.

0
installs
▌
God Mlops Core · ardurai bundle
God-level MLOps skill. Covers end-to-end ML pipeline design, data versioning, feature engineering, experiment tracking, model training at scale, hyperparameter optimization, model validation, serving infrastructure, monitoring for drift and degradation, and ML system reliability. Embeds the researcher-warrior personality: never accepts a model as 'good enough', always hunts for failure modes, always challenges baselines, never stops at the first result. Use for any task involving ML pipelines, model deployment, MLflow, Kubeflow, SageMaker, Vertex AI, DVC, Feast, BentoML, Triton, or any ML infrastructure.

0
installs
▌
God Networking · ardurai bundle
God-level networking: OSI model deep dive (L2-L7 in production), TCP/IP internals (handshake, congestion control CUBIC/BBR, flow control, retransmission, TIME_WAIT), UDP, QUIC/HTTP3, DNS (resolution chain, record types A/AAAA/CNAME/MX/TXT/NS/SOA/SRV/PTR, TTL, DNSSEC, split-horizon, DoH/DoT), TLS 1.3 (handshake, cipher suites, session resumption, OCSP stapling, certificate pinning), load balancing (L4 vs L7, ECMP, anycast), firewalls (iptables/nftables, AWS Security Groups, NACLs), VPN (WireGuard, IPsec/IKEv2, OpenVPN), BGP (AS, path attributes, route propagation), SD-WAN, network namespaces (Linux), VPC design, subnetting (CIDR, VLSM), network troubleshooting (tcpdump, Wireshark, ss, netstat, traceroute/tracepath, mtr, nmap, curl -v, openssl s_client). Never back down — diagnose any packet drop, trace any latency spike, and design any network from first principles.

0
installs
▌
God Dev Builder · ardurai bundle
God-level product and system builder skill. Use when designing and building software products, systems, or services end-to-end. Covers: product thinking, requirements engineering, system design, API design, database design, scalability, reliability engineering, observability, DevOps/CI-CD, documentation, and launch readiness. Ensures no shortcut is taken from idea to production. Prevents the most common catastrophic engineering mistakes. Treats every architectural decision as a research question first.

0
installs
▌
God Devops Core · ardurai bundle
God-level DevOps skill covering CI/CD pipeline design, container orchestration, infrastructure as code, GitOps, secrets management, artifact management, build systems, deployment strategies, and infrastructure automation. Use for any task involving pipelines, Docker, Terraform, Ansible, GitHub Actions, GitLab CI, Jenkins, ArgoCD, Flux, or any infrastructure automation. Never fabricates tool flags or config keys — always verifies against official docs. Treats every pipeline as a security boundary.

0
installs
▌
God AI Architect · ardurai bundle
God-level AI systems architecture skill. Covers multi-model AI system design, agent architectures (ReAct, Plan-and-Execute, multi-agent frameworks), agent-to-agent (A2A) communication protocols and their security, tool use and function calling patterns, AI safety and alignment in system design, LLM routing and orchestration (LangChain, LlamaIndex, DSPy, CrewAI), memory systems (short-term, long-term, episodic, semantic), retrieval augmented generation at scale, AI observability (prompt/response logging, LLM tracing, cost tracking), AI security (prompt injection, jailbreak resistance, data exfiltration prevention), and the infrastructure to run AI systems reliably in production.

0
installs
▌
God AI Prompting · ardurai bundle
God-level prompt engineering and LLM interaction skill. Covers systematic prompt design, chain-of-thought (CoT) and its variants (zero-shot CoT, few-shot CoT, self-consistency, tree of thought, graph of thought), structured output extraction, few-shot example design, instruction following optimization, prompt robustness testing, DSPy for programmatic prompt optimization, meta-prompting, system prompt design for production, prompt injection defense at the prompt level, evaluation of prompt quality, and the mindset that prompt engineering is applied ML research — not trial and error.

0
installs
▌
God Dev Codebase · ardurai bundle
God-level codebase review, indexing, and audit skill. Use when reviewing, auditing, or analyzing any codebase — existing or newly written. Covers deep code indexing, multi-pass review (bugs, vulnerabilities, architecture, quality, performance, maintainability), zero-shortcut audit methodology, tool-driven analysis, and continuous self-checking. Never skips files, never assumes correctness, never takes shortcuts. Reviews for security vulnerabilities (OWASP Top 10, CWE, CVE patterns), code quality, design principle adherence, test coverage adequacy, dependency risk, and technical debt.

0
installs
▌
God Dev Research · ardurai bundle
Activates god-level research capabilities for developers: finding academic papers (including paywalled ones), checking novelty and prior art, searching GitHub repos, Reddit, HN, arXiv, ACM, IEEE, Semantic Scholar, and all available online sources. Covers how to tear down a technical domain to its foundations before building anything. Use for research papers, literature review, novelty checking, accessing restricted papers, competitive analysis of open-source implementations, and building deep domain understanding from first principles.

0
installs
▌
God Git Workflow · ardurai bundle
God-level Git mastery: internals (objects, DAG, packfiles, loose objects, refs, ORIG_HEAD), branching strategies (GitFlow, GitHub Flow, trunk-based, release trains), rebasing (interactive, autosquash, rebase -onto), cherry-pick, bisect, reflog recovery, submodules vs subtree, monorepo strategies (Turborepo, Nx, Bazel), Git hooks (pre-commit, pre-push, commit-msg, husky, lefthook), worktrees, sparse checkout, partial clone, bundle, signing commits (GPG/SSH), large file storage (Git LFS), PR workflow best practices, CODEOWNERS, branch protection rules, GitHub/GitLab CI integration, conventional commits, semantic versioning, and changesets. Never back down — recover any lost commit, untangle any history, and architect any branching strategy from first principles.

0
installs
▌
God Tech Support · ardurai bundle
God-level technical support and debugging skill for any engineer who has to diagnose, troubleshoot, or resolve complex technical issues. Covers systematic root cause analysis (RCA), reading and interpreting stack traces (Java, Python, Go, Node.js, Rust), log analysis (structured and unstructured), Linux system debugging, Java heap dumps and thread dumps, Python profiling and memory analysis, Kubernetes pod debugging, network issue diagnosis, database query diagnosis, distributed system debugging, incident triage, and the researcher-warrior approach to never giving up on a problem. This skill turns any engineer into the person who solves the problem nobody else can solve.

0
installs
▌
God UI UX Design · ardurai bundle
Master of interface design and user experience. Expertise in typography systems, color theory (HSL/LCH/Oklch), spacing scales, grid mechanisms, WCAG 2.2 accessibility standards, micro-interactions, design tokens, and Figma-to-code bridging. You bridge the gap between engineering precision and human psychology, ensuring every pixel feels intentional, every animation feels organic, and every layout guides the user effortlessly.

0
installs
▌
God Data Cleaning · ardurai bundle
God-level data cleaning, preprocessing, and feature engineering skill. Covers the full data preparation pipeline: missing value strategies, outlier detection and treatment, data type coercion, duplicate detection, text normalization, categorical encoding, numerical scaling, imbalanced dataset handling, time series preprocessing, data validation with Great Expectations and Pandera, feature engineering from domain knowledge, automated feature engineering (Featuretools), data versioning (DVC), and the researcher-warrior truth: garbage in = garbage out, and most ML failures are data failures not model failures. Covers Pandas, Polars, NumPy, scikit-learn preprocessing, and PySpark for scale.

0
installs
▌
God Devex Tooling · ardurai bundle
God-level developer experience and tooling: IDE mastery (VS Code extensions/settings/keybindings/devcontainers, JetBrains IDE features, Vim/Neovim with LSP/Treesitter/telescope), terminal productivity (zsh/bash/fish, oh-my-zsh/starship, tmux, fzf, ripgrep, bat, eza, zoxide, delta), debuggers (gdb, lldb, pdb/ipdb, Delve for Go, IntelliJ debugger, VS Code launch.json), linters and formatters (ESLint, Prettier, Ruff, Black, gofmt/golangci-lint, ktlint, Checkstyle, clang-format, yamllint, hadolint), pre-commit hooks (husky, lefthook, pre-commit framework), static analysis (SonarQube, CodeClimate, semgrep, codeql), AI coding assistants (GitHub Copilot, Cursor AI, Cody, Tabnine, Aider), shell scripting (bash strict mode, arrays, parameter expansion, here-docs, process substitution), Makefile patterns, task runners (just, Taskfile.yml), and productivity systems. Never back down — master every tool in the developer's arsenal.

0
installs
▌
God Infra As Code · ardurai bundle
God-level Infrastructure as Code: Terraform (providers, modules, state backends, workspaces, import, moved blocks, testing with terratest/terraform test, HCL advanced patterns, drift detection), Pulumi (TypeScript/Python SDKs, ComponentResource, Stack references, automation API), AWS CDK (constructs L1/L2/L3, aspects, custom resources, CDK Pipelines), Crossplane (XRDs, Compositions, managed resources, provider config), Ansible (roles, collections, playbooks, handlers, vaults, molecule testing), GitOps (ArgoCD, Flux), and IaC security scanning (tfsec, Checkov, Snyk IaC, Terrascan). Never back down — provision any cloud resource, detect any drift, and enforce any security policy.

0
installs
▌
God Linux Mastery · ardurai bundle
God-level Linux mastery for engineers of all roles. Covers Linux internals (kernel, processes, memory, file systems, device drivers), shell scripting (bash/zsh best practices, error handling, argument parsing), process management, performance analysis (perf, eBPF, bpftrace, flamegraphs), file system operations, networking tools (ip, ss, tcpdump, nftables), systemd service management, cgroups and namespaces (the foundation of containers), user and permission management, package management, and the conviction that any engineer who can master Linux can understand anything built on top of it — because everything runs on Linux.

0
installs
▌
God Observability · ardurai bundle
God-level observability skill covering the three pillars (metrics, logs, traces), OpenTelemetry (OTel) instrumentation, Prometheus (PromQL, scrape config, alerting rules, recording rules), Grafana (dashboard design, alerting, data sources), ELK Stack (Elasticsearch, Logstash, Kibana), OpenSearch, Splunk, Jaeger, Zipkin, Tempo, Loki, structured logging, distributed tracing context propagation, alerting design (SLO-based, symptom-based), cardinality management, and the shift from monitoring to observability. A DevOps engineer who cannot read logs, query metrics, and trace requests is flying blind. A platform engineer who builds observability wrong creates more noise than signal.

0
installs
▌
God Security Core · ardurai bundle
God-level application and infrastructure security skill. Covers threat modeling (STRIDE, PASTA, Attack Trees), OWASP Top 10 (2021), CWE Top 25, secure design principles, zero trust architecture (NIST SP 800-207), SAST/DAST/SCA tooling, secrets management, cryptography fundamentals (correct algorithms, key sizes, modes), supply chain security (SLSA, SBOM, sigstore), container security, network security, and incident response fundamentals. The researcher-warrior never trusts any input, any system, or any assumption. Every feature is an attack surface. Use for security reviews, threat modeling, secure design, vulnerability assessment, or any security-related engineering task.

0
installs
▌
God Auth Protocols · ardurai bundle
God-level authentication and authorization protocols: OAuth 2.0 (all grant types, PKCE, token introspection, token revocation), OIDC (ID token, UserInfo, discovery, hybrid flow), SAML 2.0 (SP-initiated, IdP-initiated, assertions, metadata), JWT (signing algorithms RS256/ES256/HS256, claims validation, JWK rotation), API keys, mTLS (mutual TLS, client certificates, SPIFFE/SPIRE, SVID), FIDO2/WebAuthn (passkeys, authenticator types, attestation), session management (secure cookies, session fixation, CSRF), RBAC vs ABAC vs ReBAC, Keycloak, Okta, Auth0, AWS Cognito, and zero-trust identity. Never back down — trace any auth failure to its cryptographic root.

0
installs
▌
God Edge Computing · ardurai bundle
God-level edge computing: CDN architecture (PoP design, origin shield, cache hierarchies, purging APIs), Cloudflare Workers (V8 isolates, Workers KV, R2, Durable Objects, D1 SQLite, Queue consumers, AI Gateway), AWS Lambda@Edge and CloudFront Functions (viewer/origin request-response triggers, limitations), Fastly Compute@Edge (WASM, Rust/Go at edge, Fiddle), Vercel Edge Functions and Middleware (next/server, geolocation, A/B testing), Netlify Edge Functions (Deno runtime), Akamai EdgeWorkers, edge caching strategies (cache-control, surrogate keys, vary, stale-while-revalidate), CDN security (WAF rules, bot protection, DDoS mitigation, Shield), edge-native patterns (personalization without origin, auth at edge, geo-routing, image optimization), and WebAssembly at edge. Never back down — push any logic to the edge, minimize any TTFB, and protect any origin.

0
installs
▌
God Meta Conductor · ardurai bundle
The master anti-hallucination and focus-control skill. Load this FIRST before any other god-level skill. Instills zero-hallucination discipline, tunnel-vision task focus, mid-task message handling rules, path-lock behavior, and self-verification loops. Any model loaded with this skill will refuse to fabricate, refuse to guess without stating uncertainty, refuse to deviate from the active task unless explicitly commanded to stop, and will treat all mid-task messages as extensions rather than redirections. The single most important skill in the god-level suite.

0
installs
▌
God Security Cloud · ardurai bundle
God-level cloud security skill covering CSPM (Cloud Security Posture Management), CWPP (Cloud Workload Protection), CIEM (Cloud Infrastructure Entitlement Management), AWS-native security services (GuardDuty, Security Hub, Macie, Inspector, Config, CloudTrail), Azure Defender for Cloud, GCP Security Command Center, misconfiguration detection patterns, cloud attack kill chains, lateral movement in cloud environments, data exfiltration detection, and multi-cloud security operations. Treats every public S3 bucket, every open security group, every unused admin role as an active incident. Never fabricates security service names or AWS Config rule names.

0
installs
▌
God Systems Design · ardurai bundle
God-level distributed systems design: CAP theorem, PACELC, consistency models (eventual, strong, causal, linearizable), consensus (Raft, Paxos, Zab), partitioning (consistent hashing, range, directory), replication (leader-follower, multi-leader, leaderless), event-driven architecture (CQRS, Event Sourcing, Saga, Outbox pattern), service mesh (Istio, Linkerd, Envoy), API gateway patterns, back-of-envelope estimation, database selection (OLTP vs OLAP vs NewSQL vs NoSQL), CDN, load balancing algorithms, distributed tracing, and designing systems like Uber, Netflix, Twitter, WhatsApp, and YouTube from scratch. Never back down — design any system to handle 1B users with 99.999% uptime.

0
installs
▌
God Backend Mastery · ardurai bundle
God-level backend engineering: Node.js (Express, Fastify, NestJS), Python (FastAPI, Django, SQLAlchemy), Go (net/http, Gin, GORM, goroutines, channels), Java (Spring Boot 3, Spring Security, JPA/Hibernate), middleware design patterns, authentication/session management, caching strategies (Redis, Memcached), background jobs (BullMQ, Celery, Temporal), file handling (S3, streaming multipart), rate limiting, circuit breakers, graceful shutdown, connection pooling, SQL query optimization, and production-grade error handling. Never back down — trace any 500 error to its root, optimize any slow endpoint, and design for 10M req/day from day one.

0
installs
▌
God Research Review · ardurai bundle
God-level academic and technical research review skill. Covers systematic paper review methodology, peer review standards (what NeurIPS/ICML/ICLR/OSDI/SOSP reviewers look for), identifying paper flaws (statistical errors, unfair baselines, cherry-picked results, missing ablations, reproducibility gaps), novelty assessment, literature search strategy (arXiv, Semantic Scholar, Google Scholar, ACM DL, IEEE Xplore, DBLP), accessing paywalled papers legally, citation graph analysis, replication study design, writing a research critique, and the researcher-warrior mindset that has produced hundreds of papers — meticulous, adversarial toward one's own work, and relentless.

0
installs
▌
God Sre Reliability · ardurai bundle
God-level SRE and reliability engineering skill. Covers SLI/SLO/SLA design, error budgets, toil elimination, incident management (detection, response, retrospective), on-call excellence, capacity planning, chaos engineering (Chaos Monkey, Litmus, fault injection), load testing (k6, Locust, JMeter, Gatling), runbook authoring, reliability patterns (circuit breaker, bulkhead, retry, timeout, fallback), postmortem culture, and reliability as a feature. Draws from Google SRE Book, 'Seeking SRE', and 'Building Secure and Reliable Systems'. The researcher-warrior SRE treats every incident as a research paper to be written and every on-call shift as a field expedition.

0
installs
▌
God Testing Mastery · ardurai bundle
God-level testing engineering: unit testing (Jest/Vitest/pytest/JUnit 5/Go testing), integration testing (Testcontainers, Docker Compose in CI), E2E testing (Playwright, Cypress, Selenium), contract testing (Pact, Spring Contract), performance/load testing (k6, Locust, JMeter, Gatling), chaos engineering (Chaos Monkey, LitmusChaos, Gremlin), fuzz testing (go-fuzz, libFuzzer, AFL++, Python Hypothesis), mutation testing (Stryker, pitest), test pyramid strategy, TDD/BDD (Cucumber, behave), mocking strategies (MSW, WireMock, testify/mock), snapshot testing, property-based testing, and CI test optimization (parallelization, sharding, flaky test detection). Never back down — no bug escapes your test suite.

0
installs
▌
God Web3 Blockchain · ardurai bundle
God-level blockchain and Web3 engineer: Solidity, EVM internals, Rust (Solana), smart contract security, DeFi mechanics (AMM, Liquidity Pools, Flash Loans), Oracles, zero-knowledge proofs, and MEV. You treat code as law, understanding that a single bug in a smart contract is a permanent, irrecoverable financial disaster. You audit before you ship. You assume every caller is adversarial.

0
installs
▌
God Cost Engineering · ardurai bundle
God-level FinOps and cloud cost engineering skill covering cost allocation and tagging strategies, AWS cost optimization (Reserved Instances, Savings Plans, Spot Instances, rightsizing, S3 storage tiering, data transfer costs), Azure cost management (Azure Reservations, Spot VMs, Advisor recommendations), GCP cost optimization (Committed Use Discounts, Preemptible VMs, sustained use discounts), Kubernetes cost management (Kubecost, cluster rightsizing, namespace cost allocation), unit economics (cost per request, cost per user, cost per ML inference), FinOps Foundation principles, cloud cost anomaly detection, and building a culture of cost ownership. Every engineer should know what their code costs to run.

0
installs
▌
God Data Engineering · ardurai bundle
God-level data engineering skill covering the modern data stack, batch and streaming pipeline design, Apache Spark (architecture, transformations, optimization), Apache Flink (stateful stream processing, exactly-once), Apache Airflow (DAG design, operators, sensors, XCom, task dependencies), dbt (data modeling, tests, documentation, incremental models), Kafka as a data backbone, data quality frameworks (Great Expectations, dbt tests, Soda), data lake architectures (Delta Lake, Apache Iceberg, Apache Hudi), data warehousing (Snowflake, BigQuery, Redshift), ELT vs ETL, and DataOps. A backend engineer who understands data pipelines builds better APIs. A DevOps engineer who understands data pipelines builds better infrastructure for them.

0
installs
▌
God Database Mastery · ardurai bundle
God-level database mastery covering SQL (PostgreSQL deep dive, MySQL differences), NoSQL (MongoDB, Cassandra, DynamoDB), NewSQL (CockroachDB, Spanner), caching (Redis deep dive — data structures, persistence, clustering, pub/sub), message streaming (Apache Kafka — architecture, partitioning, consumer groups, exactly-once semantics), Elasticsearch/OpenSearch (indexing, mapping, search relevance, aggregations), time-series (InfluxDB, TimescaleDB), graph databases (Neo4j), schema design, query optimization, indexing strategies, ACID vs BASE, CAP theorem, replication, sharding, and connection pooling. A developer who does not understand their database is a developer who will eventually bring it to its knees.

0
installs
▌
God Frontend Mastery · ardurai bundle
God-level frontend engineering: React 18+, Next.js 14+ App Router, TypeScript deep types, state management (Zustand/Jotai/Redux Toolkit), performance (Core Web Vitals, bundle splitting, rendering strategies), CSS architecture (Tailwind, CSS Modules, CSS-in-JS), testing (Vitest, Playwright, React Testing Library), accessibility (WCAG 2.2, ARIA), WebSockets, WebWorkers, PWA, micro-frontends, monorepo tooling (Turborepo, Nx), build systems (Vite, esbuild, Webpack 5), design systems, animation (Framer Motion, GSAP), and server components. Never back down from any frontend challenge — debug render loops, hydration mismatches, memory leaks, and bundle bloat with surgical precision.

0
installs
▌
God Ml Data Training · ardurai bundle
God-level ML data preparation and model training skill. Covers data labeling (Label Studio, Scale AI, Prodigy), dataset curation (quality > quantity, curriculum learning), training loop design (PyTorch training loop, gradient accumulation, mixed precision, gradient clipping), loss functions (cross-entropy, focal loss, contrastive loss, triplet loss — when each applies), optimizers (SGD, Adam, AdamW, Lion, LAMB — differences and when to use), learning rate scheduling (warmup, cosine decay, one-cycle), regularization (L1/L2, dropout, weight decay, early stopping), distributed training (DDP, FSDP, DeepSpeed ZeRO stages), and the truth that training a model without understanding your data and loss landscape is driving with your eyes closed.

0
installs
▌
God Mobile Awareness · ardurai bundle
God-level mobile platform awareness: iOS (UIKit vs SwiftUI, UIViewController lifecycle, memory management ARC, Grand Central Dispatch, URLSession, Keychain, push notifications APNS, App Store review guidelines, TestFlight, Xcode instruments), Android (Activity/Fragment lifecycle, Jetpack Compose, Coroutines/Flow, Room, WorkManager, FCM push, Play Store deployment, ProGuard/R8, ADB debugging), React Native (Metro bundler, bridge vs JSI, Hermes engine, Expo vs bare workflow, native modules), Flutter (widget tree, BuildContext, StatefulWidget, BLoC/Riverpod, platform channels, Dart isolates), PWA (service workers, Web App Manifest, install prompt, background sync, push via Web Push API), API design for mobile (pagination, offline-first patterns, delta sync, binary protocols), and mobile-specific security (certificate pinning, root/jailbreak detection, biometric auth, secure storage). Never back down — ship to any platform, debug any crash, and optimize any mobile experience.

0
installs
▌
God Vector Databases · ardurai bundle
God-level vector database and embedding skill covering embedding models (sentence-transformers, OpenAI embeddings, Cohere, BGE, E5), vector database selection and operation (Pinecone, Qdrant, Weaviate, Milvus, pgvector, Chroma, FAISS), approximate nearest neighbor algorithms (HNSW, IVF, PQ — tradeoffs), hybrid search (dense + sparse), metadata filtering, index configuration, production scaling, and embedding evaluation (MTEB benchmark). The researcher-warrior understands that 'vector search' is not magic — it is applied linear algebra and information retrieval, and the quality of retrieval depends entirely on the quality of embeddings and the correctness of the index configuration.

0
installs
▌
God Devops Kubernetes · ardurai bundle
God-level Kubernetes and Helm expertise. Covers cluster architecture, workload design, networking (CNI, ingress, service mesh, eBPF), storage, RBAC, pod security, autoscaling, operators, CRDs, Helm chart authoring and debugging, multi-cluster management, GitOps with ArgoCD/Flux, K8s API deep dives, kubectl power usage, and troubleshooting methodology. Never fabricates API fields — always cites kubectl explain or official API reference. Covers Kubernetes versions 1.24 through current.

0
installs
▌
God Message Streaming · ardurai bundle
God-level messaging and event streaming skill covering Apache Kafka (producer/consumer internals, partitioning, replication, exactly-once semantics, Kafka Streams, ksqlDB, schema registry with Avro/Protobuf), RabbitMQ (exchanges, queues, bindings, dead letter exchanges, quorum queues), AWS SQS/SNS (standard vs FIFO, visibility timeout, DLQ, fan-out pattern), NATS (JetStream, pub/sub, request/reply, key-value), Apache Pulsar (multi-tenancy, geo-replication, tiered storage), and the engineering truth that choosing the wrong messaging system is a decision you will regret at 2am under production load.

0
installs
▌
God Project Management · ardurai bundle
God-level technical project management: Agile/Scrum (ceremonies, story points, velocity, sprint planning, retrospectives, impediment removal), Kanban (WIP limits, flow metrics, cycle time, throughput, Little's Law), roadmapping (OKRs, RICE/ICE scoring, opportunity solution trees, now-next-later), stakeholder management (RACI, communication plans, executive reporting, managing up), technical debt management (debt quadrants, debt register, ADRs), risk management (ROAM, risk register, pre-mortems), estimation techniques (three-point, planning poker, PERT, #NoEstimates movement), incident management (ICS roles, incident commander, severity levels, blameless postmortems), DORA metrics (deployment frequency, lead time, MTTR, change failure rate), and engineering metrics (cycle time, PR throughput, code review SLA). Never back down — deliver any project, align any stakeholder, and measure what matters.

0
installs
▌
God Search Engineering · ardurai bundle
God-level search engineering skill covering Elasticsearch and OpenSearch (inverted index, mappings, analyzers, query DSL, aggregations, performance tuning, cluster management), Typesense (fast typo-tolerant search, faceting, synonyms), Apache Solr (SolrCloud, schema design, relevance tuning), search relevance engineering (BM25, TF-IDF, learning to rank), vector search (KNN, HNSW algorithm, dense vector fields, hybrid search), and the art of making users find what they need — even when they don't know exactly what they're looking for.

0
installs
▌
God Containers Advanced · ardurai bundle
God-level container engineering skill going far beyond basic Docker. Covers OCI specification (image spec, runtime spec, distribution spec), Docker internals (layers, union filesystems, copy-on-write), BuildKit (cache mounts, secret mounts, SSH mounts, multi-platform builds), rootless containers, container runtime alternatives (containerd, CRI-O, gVisor, Kata Containers), image optimization (multi-stage, distroless, scratch base), container security (seccomp, AppArmor, capabilities, rootless, image signing with cosign), Docker Compose for local development, and the truth that a container is just a process with namespaces and cgroups — understanding Linux is understanding containers.

0
installs
▌
God Platform Engineering · ardurai bundle
God-level platform engineering skill covering Internal Developer Platforms (IDPs), golden paths, Backstage (software catalog, TechDocs, scaffolder templates, plugins), developer experience (DX) measurement, self-service infrastructure, paved roads vs off-road, platform as a product mindset, GitOps at scale, multi-tenancy patterns, namespace-as-a-service, environment management, developer cognitive load reduction, platform team topologies (Team Topologies book), and building platforms that accelerate every other engineering team. A platform engineer who understands ML, backend, DevOps, and security builds platforms that serve all of them. Never fabricates Backstage plugin names or Kubernetes CRD fields.

0
installs
▌
God Architecture Patterns · ardurai bundle
God-level software architecture patterns: microservices decomposition (DDD bounded contexts, strangler fig, anti-corruption layer), monolith-to-microservices migration, hexagonal/ports-and-adapters, clean architecture, onion architecture, event-driven patterns (pub/sub, event mesh, choreography vs orchestration), CQRS+Event Sourcing in production, Saga pattern, Outbox+CDC, API versioning strategies, backward compatibility, schema evolution (Avro, Protobuf), service discovery, sidecar/ambassador/adapter patterns, and architecture decision records (ADRs). Never back down — evaluate any architectural tradeoff with the precision of a decade-long post-mortem.

0
installs
▌
God Compliance Governance · ardurai bundle
God-level compliance and governance engineering: SOC 2 Type II (Trust Service Criteria, evidence collection, vendor management, CC controls), HIPAA (PHI/ePHI identification, BAA requirements, technical safeguards, audit logging, minimum necessary rule), PCI-DSS v4.0 (cardholder data environment, network segmentation, tokenization, PA-DSS), GDPR (data subject rights, lawful basis, DPA agreements, DPIA, breach notification 72h), ISO 27001:2022 (ISMS, risk assessment, Annex A controls, SoA), CCPA/CPRA, FedRAMP, NIST 800-53, encryption standards (FIPS 140-2/3), audit logging design, compliance automation (Vanta, Drata, Lacework, AWS Security Hub, GCP Security Command Center), and policy-as-code (OPA, Sentinel, Conftest). Never back down — pass any audit, remediate any finding, and build compliance into the SDLC.

0
installs
▌
God Performance Engineering · ardurai bundle
God-level performance engineering: CPU profiling (perf, py-spy, async-profiler, pprof, Instruments), memory profiling (Valgrind, heaptrack, memory_profiler, jmap/jhat, Go pprof heap), distributed tracing (OpenTelemetry, Jaeger, Zipkin, AWS X-Ray), load testing (k6, Gatling, Locust, JMeter, wrk2), database query optimization (EXPLAIN ANALYZE, index strategy, query planning, vacuum), JVM tuning (GC algorithms G1/ZGC/Shenandoah, heap sizing, JIT compilation), Go runtime tuning (GOGC, GOMEMLIMIT, goroutine leaks), Node.js performance (event loop lag, V8 profiling, worker threads), network performance (TCP tuning, HTTP/2 multiplexing, gRPC vs REST), caching optimization, CDN tuning, and SLO/SLI/error budget management. Never back down — find any bottleneck, eliminate any latency spike, and optimize any system to its theoretical limit.

0
installs
▌
God Serverless Architecture · ardurai bundle
God-level serverless engineering: AWS Lambda, DynamoDB, API Gateway, EventBridge, Step Functions. Master of cold start optimization, idempotency, ephemeral state, distributed retry logic, dead-letter queues, and API Gateway integration limits. You understand that servers aren't gone, they're just someone else's problem—and you design systems resilient to sudden scale, transient network faults, and strict timeout boundaries.

0
installs

51 published skills