Browse

Comprehensive AWS CLI commands for configuration, profiles, global options, queries, and common cross-service recipes.

AWS CLI CloudFormation commands for templates, stacks, change sets, events, package, and deploy workflows.

AWS CLI EC2 commands for instances, AMIs, key pairs, VPC networking, security groups, EBS volumes, and snapshots.

AWS CLI ECR and ECS commands for repositories, image login and cleanup, clusters, services, task definitions, and tasks.

AWS CLI IAM and STS commands for users, groups, roles, policies, access keys, caller identity, and assume-role workflows.

High-level and low-level AWS CLI S3 commands for buckets, objects, sync, versioning, encryption, and presigned URLs.

Indexed and associative arrays, string handling, read/mapfile, and common Bash text-processing patterns.

Core Bash builtins, shell options, history, aliases, job control, traps, and interactive-shell behavior.

Comprehensive Bash commands, shell syntax, quoting, variables, redirection, pipelines, and day-to-day scripting patterns.

Bash if/elif/case logic, test expressions, loops, functions, return codes, and robust control-flow patterns.

Production-minded Bash script patterns for files, arguments, parsing, temp files, logging, retries, and common automation tasks.

Bash variables, parameter expansion, quoting rules, command substitution, arithmetic, and shell expansion patterns.

Container build/push flows, service dependencies, environment modeling, and deploy snippets.

Debug logs, common CI/CD failures, strict shell mode, retries, and faster pipeline diagnosis.

Core CI/CD concepts plus starter examples for GitHub Actions, GitLab CI, and Jenkins.

Selective execution, shared scripts, naming, and maintainable organization for growing automation estates.

Tag-based releases, canaries, rollbacks, smoke tests, migrations, and quality checks.

Reusable workflows, matrix builds, caching strategies, and artifacts across common CI/CD systems.

Least privilege, OIDC, protected variables, pinning, and release governance for safer pipelines.

Stage design, promotions, manual approvals, and deployment strategy examples for safer delivery.

Programmatic Copilot CLI usage patterns for scripts, CI jobs, GitHub Actions, and reusable automation flows.

JSON snippets and commands for extending GitHub Copilot CLI with hooks, MCP servers, skills, and repository initialization.

Commands for installing GitHub Copilot CLI, authenticating, updating, and starting interactive or wrapped sessions.

Commands and JSON snippets for Copilot CLI permissions, tool access, trusted directories, environment variables, and persistent configuration.

Commands and prompt patterns for interactive use, one-shot prompts, file-aware context, and common terminal Copilot workflows.

Slash commands and keyboard shortcuts for managing sessions, reviewing changes, sharing output, and using advanced agent features in Copilot CLI.

Commands for diagnosing Copilot CLI authentication failures, token issues, wrapper install problems, and access-policy errors.

Authentication, cookies, TLS verification, client certs, pinned keys, and proxy-secured curl workflows.

High-coverage curl commands for HTTP requests, APIs, downloads, uploads, cookies, redirects, and automation.

Tracing, DNS overrides, proxies, protocol selection, config files, timeouts, and script-friendly curl patterns.

Comprehensive curl patterns for downloads, retries, upload flows, range requests, SMTP, SFTP, and batch transfers.

HTTP methods, auth, JSON APIs, headers, caching, compression, and response inspection with curl.

Core indexing concepts, selectivity, left-prefix behavior, and practical heuristics for when to add an index.

Use EXPLAIN tools across PostgreSQL, MySQL, SQLite, and MongoDB to prove whether an index actually helps.

Avoid over-indexing, duplicate indexes, low-value indexes, stale statistics, and maintenance mistakes.

Single-field, compound, multikey, text, wildcard, partial, TTL, and unique index patterns for MongoDB.

Composite indexes, invisible indexes, descending indexes, generated-column indexing, and EXPLAIN workflows in MySQL.

High-leverage index patterns for subsets of data and computed predicates across PostgreSQL, MySQL, and SQLite.

Use PostgreSQL B-tree, GIN, GiST, BRIN, partial indexes, expression indexes, and concurrent builds effectively.

Practical SQL indexing patterns for equality, range filters, ordering, include columns, and covering scans.

SQLite CREATE INDEX patterns, expression and partial indexes, EXPLAIN QUERY PLAN, and lightweight performance tuning.

Modern BuildKit and Buildx reference for multi-platform builds, cache, secrets, and remote outputs.

Comprehensive Docker Engine CLI reference for images, containers, networks, volumes, registries, contexts, and cleanup.

High-value Dockerfile instructions, patterns, and build flags for reproducible and efficient image builds.

Swarm cluster, node, service, and stack commands for container orchestration on Docker Engine.

Commands for starting, stopping, inspecting, and operating Docker Compose projects.

Developer workflows, troubleshooting commands, CI flows, and small-host production Compose patterns.

compose.yaml examples for services, variables, profiles, overrides, and dependency-aware startup.

Compose patterns for ports, networks, volumes, secrets, configs, and runtime controls.

Core fzf usage patterns for filtering lists, selecting items, and integrating the result into shell workflows.

Install fzf, enable shell integration, and configure global defaults for day-to-day use.

Tune layout, borders, headers, sorting, and visual style for cleaner fuzzy-finder interfaces.

Use previews, key bindings, execute actions, and dynamic UI changes to build powerful interactive pickers.

Practical pipeline recipes that combine fzf with fd, ripgrep, bat, Git, and shell utilities.

Build live search interfaces with reload, change events, refresh-preview, and mode-switching key bindings.

Set up fuzzy shell completion and customize built-in key bindings like CTRL-T, CTRL-R, and ALT-C.

Use fzf with tmux and editors, and fix common issues involving shell integration, source commands, and large repositories.

Common branching commands (create, switch, merge, rebase).

Comprehensive Git commands for day-to-day work, collaboration, history, releases, recovery, and advanced repository workflows.

Ready-to-use Git configuration recipes for identity, pull/push policy, aliases, tools, safety, and performance.

Git hook locations, setup patterns, and reusable client-side hook snippets for linting, testing, policy, and automation.

Low-level Git objects, refs, trees, index, commit creation, and packfile plumbing for advanced users and debugging.

Patch-oriented Git workflows using format-patch, apply, am, and range-diff for mailing-list and review-based collaboration.

Git recovery patterns using reflog, ORIG_HEAD, fsck, dangling objects, and targeted reset or cherry-pick flows.

Git revision selectors, ranges, parents, symbolic refs, and object/path addressing.

Advanced Git commands and workflows for rewriting history, recovering commits, debugging regressions, working with multiple trees, and maintaining repositories.

Advanced workflows for regression hunting, selective commit transfer, and repository dependency management.

Advanced rebase commands, interactive workflows, conflict handling, and branch-transplant patterns.

Recover commits, branches, and work after resets, rebases, deletes, and mistaken force updates.

Understand the differences between reset, revert, and restore and use the right recovery command safely.

Temporary work preservation, multi-worktree workflows, cleanup commands, and conflict-resolution reuse.

Cache dependencies, upload and download artifacts, and drive workflows with GitHub CLI commands in GitHub Actions.

Debug failing GitHub Actions workflows with log grouping, debug logging, step summaries, shell flags, and common troubleshooting patterns.

Expressions, contexts, env vars, configuration variables, step outputs, job outputs, and dynamic workflow logic in GitHub Actions.

Jobs, steps, matrix builds, conditional execution, reusable workflows, composite actions, and service containers in GitHub Actions.

GitHub-hosted runners, self-hosted runners, job containers, service containers, labels, and operational patterns for GitHub Actions execution.

Secure GitHub Actions workflows with permissions, environments, secrets, masking, fork safety, and OpenID Connect for cloud auth.

Practical CI/CD recipes for testing, build matrices, release creation, package publishing, and environment-based deployments in GitHub Actions.

Workflow YAML structure, common triggers, path filters, schedule, workflow_dispatch, concurrency, and job basics for GitHub Actions.

Authentication, enterprise usage, aliases, extensions, completion, org secrets, and administrative helpers.

Core GitHub CLI commands for auth, repository context, search, JSON output, and daily workflows.

Issue triage plus GitHub Actions workflows, runs, secrets, variables, and caches.

Release management, gist workflows, and direct REST or GraphQL automation with gh api.

Repository creation, forking, syncing, pull request creation, review, and merge workflows in GitHub CLI.

Core go command workflows for build, run, test, env, fmt, vet, doc, install, list, clean, toolchains, and everyday module-aware development.

Cross-compilation, build flags, ldflags, reproducible releases, CGO controls, and packaging patterns with the go command.

Go modules and go work workflows for init, tidy, vendor, replace, workspaces, private modules, and dependency management.

go test patterns for package tests, focused runs, benchmarks, fuzzing, coverage, JSON output, and CI-friendly test workflows.

go tool, go generate, code generation, formatting helpers, analysis tools, and practical developer automation with the Go CLI.

Practical command-line companions and non-interactive alternatives to htop for logs, scripts, and copyable output.

Customize meters, visible columns, threads, kernel tasks, and display density for different monitoring scenarios.

Persist htop settings, edit configuration files, and manage practical theming and display preferences across sessions.

Core htop installation and launch commands, including startup options for delay, sorting, tree view, and PID filtering.

Interactive keys and workflows for moving around htop, searching processes, filtering by command, changing sort columns, and working in tree view.

Use htop to renice, kill, tag, and inspect processes, including shortcuts for signals, strace, lsof, and affinity-related workflows.

Common htop workflows for SSH sessions, containers, services, and production troubleshooting on Linux hosts.

Troubleshooting recipes for missing visibility, permission issues, terminal quirks, and common htop interpretation mistakes.

Informational responses like 100 Continue and 103 Early Hints.

Successful responses like 200 OK, 201 Created, and 204 No Content.

Redirection responses like 301, 302, 307, and 308.

Client error responses like 400, 401, 403, 404, 409, 422, and 429.

Server error responses like 500, 502, 503, and 504.

Common HTTP status code comparisons, cURL debugging recipes, and troubleshooting patterns.

Comprehensive HTTP status code reference with meanings, examples, and debugging guidance.

Quick reference for for/while/do-while/enhanced for loops in Java.

Comprehensive array, object, collection, and string manipulation patterns in JavaScript.

Promises, async/await, fetch, timers, generators, async iterables, and event loop patterns.

Core JavaScript syntax, functions, classes, modules, and everyday language patterns.

DOM selection, manipulation, browser events, storage, URL APIs, clipboard, observers, and forms.

Node.js filesystem, HTTP, process, streams, events, child processes, and worker threads.

Regular expressions, JSON parsing and serialization, dates, Intl formatting, math, and crypto helpers.

Deep reference for jq arrays, objects, grouping, entries, path updates, reshaping, and structural manipulation.

Core jq syntax, filters, selectors, arrays, objects, variables, sorting, grouping, formatting, and shell-friendly usage.

Real-world jq commands for APIs, cloud tooling, DevOps output, reporting, logs, and shell scripting.

Advanced jq patterns for regex, booleans, dates, math, recursive descent, filtering, and output shaping.

Reusable JSON payload shapes for APIs: envelopes, pagination, errors, metadata, partial updates, and event-style messages.

Core JSON syntax, valid values, root structures, and foundational examples for working with JSON documents.

Escape sequences, Unicode, URLs, embedded JSON strings, and encoding pitfalls when storing or transporting JSON.

Commands and patterns for compact JSON, human-readable formatting, stable sorting, and terminal-friendly inspection.

Newline-delimited JSON patterns for logs, streams, ETL, and large-file processing workflows.

Patterns for nested objects, arrays, list items, nullability, and common data-shape decisions in JSON.

Practical JSON Schema examples for required fields, types, enums, arrays, nested objects, and validation workflows.

Examples and edge cases for strings, numbers, booleans, null, arrays, and objects in JSON.

How to validate JSON, spot parse failures, repair common mistakes, and debug malformed payloads quickly.

Bootstrap, join, cert, kubeconfig, reset, phase, image, and upgrade commands for kubeadm-managed clusters.

JSONPath recipes, custom output patterns, jq/yq workflows, and Kustomize commands supported by kubectl.

Comprehensive kubectl commands for contexts, resources, apply flows, creation, deletion, logs, and cluster introspection.

Services, ingress, EndpointSlices, network policies, PVCs, PVs, storage classes, ConfigMaps, Secrets, and nodes.

Debugging, inspection, RBAC checks, rollout failures, node health, and maintenance-oriented kubectl workflows.

Deployments, StatefulSets, DaemonSets, Jobs, CronJobs, autoscaling, rollouts, and workload maintenance.

Core kubectl troubleshooting commands for pods, deployments, services, events, logs, exec sessions, and ephemeral debugging.

Find pod logs, previous container logs, event timelines, kube-system logs, and cluster incident evidence quickly.

Debug Services, DNS, Ingress, network policies, connectivity, endpoints, and port-forwarding issues.

Diagnose node readiness, kubelet issues, pressure conditions, cordon/drain, and node-level debugging with kubectl debug.

Troubleshoot Pending, CrashLoopBackOff, image pull, readiness, liveness, and init container problems.

High-value Kubernetes YAML patterns for Pods, Deployments, Services, probes, resources, scheduling, and day-to-day manifest authoring.

ConfigMap, Secret, projected volume, envFrom, and secure configuration patterns.

Kustomize overlays, patches, generators, and CRD/CR authoring patterns.

Services, Ingress, NetworkPolicy, ports, and service exposure manifests.

YAML patterns for Deployments, StatefulSets, DaemonSets, Jobs, CronJobs, HPAs, and PodDisruptionBudgets.

Comprehensive Linux command reference covering navigation, files, text processing, permissions, processes, system information, networking, archives, services, storage, and troubleshooting.

Comprehensive Linux networking administration reference covering iproute2, DNS, HTTP debugging, TLS, SSH tunnels, packet capture, and firewall inspection.

Comprehensive Linux package management reference for apt, dnf, yum, pacman, zypper, rpm, and dpkg workflows across common distributions.

High-value Linux permissions and security reference covering users, sudo, ACLs, special mode bits, SSH access, SELinux, and AppArmor basics.

High-value Linux shell scripting reference covering variables, expansion, conditionals, loops, functions, redirection, pipelines, traps, getopts, and script debugging.

Backup, copy, imaging, clone, and storage troubleshooting workflows on Linux.

Disk inventory, partitions, formatting, and capacity analysis for Linux systems.

Mount, unmount, fstab, filesystem check, and repair workflows on Linux.

LVM volume management, mdadm RAID, and LUKS encryption workflows.

High-value Linux filesystem commands for navigating, listing, inspecting, copying, moving, linking, and organizing files and directories.

Powerful Linux search commands using find, locate, xargs, and metadata filters.

Comprehensive Linux networking commands for interfaces, sockets, packet capture, and throughput testing.

DNS troubleshooting, resolver inspection, HTTP probing, and TLS certificate testing from Linux.

nftables, iptables, ufw, firewalld, conntrack, and packet flow debugging commands.

Linux routing tables, policy routing, bridges, VLANs, bonds, and tunnel configuration commands.

Reachability, latency, DNS, proxy, logs, and real-time diagnostics for Linux network incidents.

Navigate Linux paths efficiently with cd, pushd/popd, globbing, basename, dirname, and canonical path tools.

Change permissions, ownership, umask, and symbolic or hard links on Linux.

Low-level Linux process inspection with /proc, syscall tracing, profilers, debuggers, and core dumps.

Comprehensive Linux process inspection, control, scheduling, and backgrounding workflows.

Interactive and sampled monitoring for Linux processes, threads, memory, sockets, and scheduler behavior.

Linux signals, process groups, shell job control, and safe batch-termination patterns.

systemd-oriented process inspection, signaling, cgroup views, transient units, and service troubleshooting.

Use systemd-analyze, unit verification, logs, and dependency tools to diagnose systemd problems.

Read, filter, follow, export, and troubleshoot systemd journal logs.

Author, edit, override, and harden systemd .service files with practical examples.

Core systemctl commands, unit inspection, service lifecycle management, dependencies, and operational workflows.

Work with timer units, socket activation, path units, transient services, and user services.

Core Linux commands for viewing files, comparing content, touching, truncating, splitting, and combining files.

Column extraction, sorting, deduplication, character translation, file combining, and list comparison.

Search text with grep, egrep, fgrep, and ripgrep including regex, file globs, recursion, and context.

Build practical shell pipelines, batch commands with xargs, compare files, and split or reshape data.

Edit text streams with sed and parse structured text with awk.

Core Linux text processing commands and shell patterns for searching, filtering, editing, formatting, and analyzing text files and streams.

Comprehensive GNU make and Makefile reference covering targets, prerequisites, recipes, variables, includes, conditionals, pattern rules, and command-line usage.

Debug make behavior, inspect variables, run parallel builds safely, and build reliable CI targets.

GNU make text, path, conditional, shell, and metaprogramming functions with practical examples.

Pattern rules, wildcarding, implicit rules, static pattern rules, and generated dependency files in GNU make.

Portable makefile patterns that work across POSIX make environments, avoiding GNU-only features when needed.

Production-oriented Makefile targets for apps, Docker, Terraform, Python, Node, Go, and deployment workflows.

Group, project, sort, unwind, lookup, facet, and aggregate analytics data with MongoDB pipelines.

Use mongodump, mongorestore, replica set commands, and diagnostic tools for operational MongoDB workflows.

Insert, find, update, replace, and delete documents with the core mongosh collection methods.

Use mongoimport, mongoexport, bsondump, and GridFS tools for practical MongoDB data movement workflows.

Create indexes, inspect query plans, and troubleshoot common MongoDB query performance issues.

Use filters, logical operators, projections, sorting, skip, and limit to shape query results efficiently.

Connect with mongosh, switch databases, inspect collections, and run the most common shell workflows.

Use sessions, multi-document transactions, and change streams for modern event-driven and consistency-sensitive MongoDB applications.

Use $set, $unset, $inc, $push, $addToSet, positional updates, and arrayFilters for real-world MongoDB mutations.

Create users, grant roles, inspect server status, and run the most common administrative commands in MongoDB.

group by, having, count, sum, avg, row_number, lag, running totals, and analytical query patterns in MySQL.

mysqldump, mysql restore, load data infile, select into outfile, mysqlimport, and MySQL Shell dump/load workflows.

mysql client commands for connecting, switching databases, inspecting metadata, and working efficiently in interactive or scripted sessions.

create, alter, rename, and drop databases and tables in MySQL, with practical patterns for primary keys, unique keys, and foreign keys.

now, date_add, date_sub, date_format, timestampdiff, json_extract, json_set, json_object, concat, coalesce, and case in MySQL.

index design, show index, explain, explain analyze, analyze table, and practical performance tuning workflows in MySQL.

inner joins, left joins, self joins, subqueries, derived tables, and common table expressions in MySQL.

stored procedures, stored functions, delimiters, call, triggers, and scheduled events in MySQL.

practical MySQL CRUD queries including filtering, sorting, pagination basics, inserts, updates, deletes, truncation, and upsert patterns.

start transaction, commit, rollback, savepoints, select for update, isolation levels, and InnoDB lock troubleshooting.

create users, alter passwords, grant privileges, show grants, revoke access, and manage MySQL accounts safely.

Node.js CLI cheat sheets for runtime flags, debugging, watch mode, test runner, environment variables, and production execution patterns.

Node.js CLI environment and config cheat sheets for NODE_OPTIONS, runtime environment variables, proxy settings, CA certificates, and launch patterns.

Node.js CLI performance cheat sheets for memory tuning, CPU profiling, heap analysis, coverage, and source-map-aware debugging.

Node.js CLI recipes for watch mode, built-in tests, REPL usage, shebang scripts, and practical automation patterns.

Node.js CLI security cheat sheets for the permission model, network and filesystem restrictions, eval hardening, and TLS/crypto settings.

Security auditing, package maintenance, and npm org/team workflows.

Core npm CLI, package inspection, package.json editing, and daily workflow commands.

Configuration, npmrc, cache management, profile, and token workflows.

Install, update, remove, lockfile, and local-development npm dependency workflows.

Publishing, versioning, dist-tags, auth, and registry metadata commands.

Scripts, lifecycle hooks, npm exec, and workspace workflows.

Core pip commands for installing, upgrading, uninstalling, inspecting, and managing Python packages.

pip configuration, cache management, network troubleshooting, verbose logs, and environment diagnostics.

Dependency installation patterns with pip, including constraints, editable installs, extras, local paths, VCS installs, and resolver control.

Patterns for requirements files, constraints, repeatable installs, hashes, wheelhouses, and reproducible environments.

Use pip correctly across Python versions, venvs, pyenv-style setups, CI, and system interpreters.

Comprehensive pnpm CLI reference for installs, dependency management, scripts, filtering, and inspection.

CI installs, fetch, production pruning, Node runtime management, patching, and troubleshooting.

Configuration, .npmrc, store/cache operations, and installation model settings.

Dependency types, package sources, versions, lockfiles, and reproducible installs.

Pack, publish, dist-tags, registries, auth, and package metadata queries.

Workspace setup, filtering, recursive execution, deploy flows, and catalogs.

Server lifecycle, utility commands, grants, monitoring, and cluster maintenance tasks.

Replication, transactions, FDWs, extensions, and specialized PostgreSQL workflows.

pg_dump, pg_restore, pg_dumpall, pg_basebackup, COPY, and migration workflows.

Core PostgreSQL commands, SQL patterns, and object management for daily engineering work.

EXPLAIN, vacuum, planner settings, indexing, and practical tuning recipes.

Deep psql reference for connection flags, slash commands, formatting, and automation.

Core Python syntax, control flow, operators, collections, and everyday language patterns.

Lists, tuples, dictionaries, sets, deque, Counter, defaultdict, heapq, and collection idioms.

Functions, parameters, lambda, decorators, comprehensions, generators, and functional helpers.

Classes, dataclasses, inheritance, properties, abstract base classes, modules, and package patterns.

itertools, functools, json, datetime, uuid, regex, subprocess, typing, and enum recipes.

String handling, file I/O, pathlib, JSON, and exception-handling patterns.

Advanced loop management, low-level scheduling, and platform-aware asyncio usage.

Core asyncio patterns for writing concurrent I/O-bound Python programs with async and await.

Real-world asyncio recipes for HTTP concurrency, retries, and pipelines.

Network streams, subprocesses, and non-blocking integration patterns.

Core Python debugging commands, traceback inspection, runtime introspection, and practical troubleshooting workflows.

Reference for Python logging, stack traces, warning visibility, trace hooks, and instrumentation patterns.

Focused reference for pdb commands, breakpoints, stepping, stack frames, and conditional debugging.

Profile Python programs, inspect memory and imports, and diagnose slow or stuck processes.

pytest and unittest debugging patterns for isolating failures, flaky tests, fixtures, and CI-only issues.

Comprehensive Python venv reference covering creation, activation, pip usage, requirements, inspection, and recovery workflows.

Package installation, requirements, editable installs, wheel workflows, and dependency troubleshooting inside Python virtual environments.

Project-level setup patterns for Python virtual environments, pyproject.toml, editable installs, dev tools, and team onboarding.

Diagnose activation problems, broken pip, wrong interpreter selection, PATH confusion, and environment drift in Python virtual environments.

Built-in React Hooks reference covering state, effects, refs, context, memoization, transitions, and store subscriptions.

Reusable custom hook patterns for UI state, data fetching, forms, persistence, and interaction handling.

Common React Hooks mistakes, stale closure issues, dependency pitfalls, and practical best practices.

Practical React Hooks recipes for UI interactions, timers, measurement, polling, and optimistic updates.

Type-safe React Hooks patterns for state, refs, reducers, and custom hooks.

redis-cli operational workflows, latency inspection, slowlog, config, ACL, clients, and safe administrative controls.

Comprehensive Redis commands for redis-cli, key lifecycle, strings, expiration, and core operational workflows.

High-value Redis commands for lists, sets, hashes, and sorted sets used in queues, objects, tags, and leaderboards.

RDB, AOF, replication, failover, Lua scripts, functions, and cluster command references for operational Redis use.

Atomic transactions, optimistic locking, pub/sub messaging, streams, consumer groups, geo commands, bitmaps, and HyperLogLog.

Core regular expression syntax, classes, quantifiers, groups, lookarounds, flags, and performance techniques.

Large cookbook of validation, extraction, cleanup, and code-search regex recipes for everyday engineering work.

Regex patterns and command-line workflows for grep, ripgrep, sed, awk, and advanced PCRE-style features.

Regex patterns and search/replace recipes for VS Code, JetBrains IDEs, and common editor refactors.

JavaScript RegExp syntax, APIs, flags, named captures, and high-value browser/Node recipes.

Bearer auth, API keys, permission errors, versioning strategies, and compatibility patterns for HTTP APIs.

Core REST API patterns for resource-oriented URLs, nested resources, and standard CRUD request examples.

High-signal design rules, consistency patterns, and common mistakes to avoid in production APIs.

HTTP methods, safe vs unsafe semantics, and idempotency examples for API consumers and designers.

Common collection query patterns including offset pagination, cursor pagination, filtering, sorting, and search.

JSON request bodies, envelope choices, sparse fieldsets, includes, concurrency control, and common response contracts.

Naming conventions for resources, relationships, nested endpoints, and clean URL design.

Practical HTTP status codes, error response bodies, validation failures, and troubleshooting-friendly API error contracts.

Persist preferred flags, create custom types, and combine ripgrep with fd, fzf, git, and editors.

Control what ripgrep searches with globs, type filters, hidden files, and ignore behavior.

Control headings, context lines, counts, paths, columns, and machine-readable output.

Understand ripgrep defaults, debug missing results, and use PCRE2 or multiline search when required.

High-value ripgrep recipes for refactors, security scans, framework audits, logs, and docs.

Use basic regex, PCRE2, word boundaries, alternation, and literal searches with ripgrep.

Preview replacements, search transformed files, and handle compressed or non-UTF8 data.

Core `rg` searches for files, code, and text with line numbers, smart defaults, and recursive search behavior.

Everyday Cargo workflows for checking, building, running, testing, formatting, linting, and cleaning Rust CLI projects.

Cargo configuration, environment variables, docs generation, and troubleshooting commands for Rust CLI development.

Core rustup and Cargo commands for creating, building, running, and inspecting Rust CLI projects.

Dependency declarations, feature flags, workspace commands, and reusable patterns for larger Rust CLI projects.

Package local crates, install binaries, publish to crates.io, and prepare Rust CLI releases.

Manage Rust toolchains with rustup, switch channels, install components, and add cross-compilation targets.

Commands for investigating compiler errors, Cargo diagnostics, verbose output, and fix suggestions in Rust CLI projects.

Commands for debugging CI failures, environment mismatches, build script output, installation problems, and publish checks in Rust CLI projects.

Commands for analyzing dependency trees, feature activation, duplicate crates, and lockfile behavior in Rust CLI projects.

Commands and examples for debugging Cargo.toml issues, package selection mistakes, and workspace confusion in Rust CLI repos.

Commands for fixing toolchain mismatches, missing components, and cross-compilation target issues in Rust CLI projects.

Commands for debugging failing tests, capturing output, isolating flaky cases, and fixing documentation-generation issues in Rust CLI projects.

Core SQL syntax and patterns for querying, filtering, sorting, joining, grouping, and modifying data.

Create and change schema objects, then insert, update, delete, merge, and manage transactional data changes.

Reference for string, date, numeric, conditional, null-handling, and aggregate SQL functions.

Query tuning patterns with EXPLAIN, indexing, keyset pagination, deduplication, and optimization-oriented SQL recipes.

Advanced relational query patterns for joins, subqueries, EXISTS, IN, set operations, and correlated queries.

Use CTEs, recursive queries, ranking, running totals, partitions, and lag/lead patterns for analytical SQL.

sqlite3 shell commands for opening databases, inspecting schema, formatting output, importing CSV, and scripting common interactive workflows.

High-value SELECT, INSERT, UPDATE, DELETE, UPSERT, ORDER BY, LIMIT, and filtering patterns for day-to-day SQLite development.

CREATE TABLE, constraints, generated columns, foreign keys, defaults, and schema design patterns for production SQLite databases.

FTS5 virtual tables, MATCH queries, prefix search, phrase search, bm25 ranking, snippets, and highlighting patterns for SQLite search features.

CSV import/export, SQL dumps, VACUUM INTO, backup copies, and repeatable data movement patterns for SQLite databases.

CREATE INDEX patterns, covering and partial indexes, EXPLAIN QUERY PLAN, ANALYZE, and practical tuning tips for SQLite queries.

JOIN patterns, recursive CTEs, ranking functions, running totals, and analytical SQL patterns for SQLite.

json_extract, json_set, json_each, JSON operators, generated columns, and practical JSON query/update patterns in SQLite.

High-signal PRAGMA commands for foreign keys, cache, synchronous settings, page size, temp storage, health checks, and general SQLite administration.

BEGIN modes, COMMIT and ROLLBACK, savepoints, WAL mode, busy timeouts, and concurrency patterns for SQLite applications.

CREATE VIEW, CREATE TRIGGER, audit logging, derived values, generated columns, and automation patterns in SQLite.

Counting, summing, pre-aggregating, and handling NULLs correctly after one-to-many and outer joins.

Practical SQL patterns for inner, outer, and reconciliation-style joins, including full outer join emulation.

SQL join tuning with indexes, plan inspection, row reduction, and troubleshooting guidance.

Many-to-many SQL join patterns with bridge tables, aggregation, filtering, and index guidance.

SQL self join examples for managers, duplicates, comparisons, and basic hierarchy modeling.

High-value EXISTS, IN, NOT EXISTS, and LEFT JOIN IS NULL patterns for membership and missing-row queries.

Core SQL join types with practical examples, NULL behavior, and quick rules for correct join selection.

Common SQL join mistakes, reusable templates, and correctness rules for production queries.

Use ROW_NUMBER, LAG, and running groups to deduplicate rows, detect gaps, and form islands or sessions.

Positional window functions for first, last, and nth values inside ordered partitions.

Compare rows to prior or next rows with LAG and LEAD for change detection, retention, and trend analysis.

Core window function syntax, partitions, ordering, and frame clauses for analytic SQL queries.

Percent rank, cumulative distribution, percentile-style bucketing, and segmentation patterns.

How to tune window queries, reduce sorts, structure indexes, and account for cross-dialect differences.

Ranking functions such as ROW_NUMBER, RANK, DENSE_RANK, NTILE, PERCENT_RANK, and CUME_DIST.

Rolling metrics, cumulative sums, moving averages, and period-over-period analytics with frame clauses.

sshd administration, config validation, systemd control, logging, hardening, authorized keys, and certificates.

SSH-based file transfer with scp and sftp, including recursive copies, jump hosts, interactive commands, and batch mode.

Comprehensive SSH client commands for login, remote execution, auth, multiplexing, jump hosts, and practical options.

Client-side SSH configuration examples for aliases, defaults, patterns, includes, ProxyJump, multiplexing, and effective config inspection.

SSH key generation, authorized_keys management, ssh-keyscan, host keys, ssh-agent, ssh-add, and certificate basics.

Local, remote, and dynamic SSH forwarding with practical database, web, and bastion tunnel recipes.

Core Stripe CLI commands for login, auth, help, webhooks, testing, logs, and common resource operations.

Connect, subscriptions, invoices, test clocks, and billing-oriented Stripe CLI workflows.

Profiles, config, request logs, diagnostics, and troubleshooting patterns for the Stripe CLI.

Resource CRUD patterns for customers, products, prices, payment intents, checkout sessions, refunds, and subscriptions.

Stripe CLI webhook forwarding, listen, trigger, fixtures, and local integration testing patterns.

Core Terraform CLI commands for init, plan, apply, state, output, variables, workspaces, and automation.

Commands and snippets for HCP Terraform remote runs, CLI auth, automation, and CI-friendly usage.

High-value HCL patterns for variables, locals, outputs, loops, conditionals, dynamic blocks, and data shaping.

Commands and snippets for modules, providers, version constraints, registry access, and dependency management.

Commands and patterns for debugging, upgrades, migration, and state repair in Terraform.

Manage Terraform CLI workspaces, local and remote state, imports, and state surgery commands.

tmux .tmux.conf settings for prefix changes, mouse support, indexing, reloading, and status bar customization.

tmux copy-mode commands, scrollback capture, search, buffers, and clipboard configuration patterns.

tmux plugin manager patterns, TPM setup, and common plugin snippets for restoring sessions, sensible defaults, and clipboard workflows.

tmux patterns for remote servers, resilient SSH sessions, multi-client visibility, and collaboration workflows.

tmux commands for listing state, using format strings, conditional logic, send-keys automation, and repeatable workspace bootstrapping.

Core tmux commands and interactive shortcuts for managing sessions, windows, panes, splits, and layouts.

tmux commands and config snippets for diagnosing key bindings, options, environment issues, TERM problems, and server resets.

Core TypeScript syntax, typing patterns, and compiler commands.

Classes, access modifiers, inheritance, modules, and validation boundaries.

Function typing, overloads, control-flow narrowing, and async typing.

tsconfig.json patterns, diagnostics, and project references.

Advanced type operators, mapped types, conditional types, and utility types.

Built-in utility types and practical application patterns.

Language-aware development workflows in Neovim with built-in LSP, Treesitter, and plugin managers.

Modern Neovim configuration patterns using Lua, keymaps, options, and autocommands.

Core modal editing concepts, motions, and movement commands for everyday editing.

Manage multiple files and layouts with buffers, splits, and tab pages.

Launch editors with flags, compare files, recover swap data, and use terminal-friendly startup patterns.

Use the command line efficiently, navigate help, and save working context with sessions.

Delete, change, yank, repeat, and target text precisely with motions and text objects.

Search efficiently, run substitutions, and automate repetitive edits with macros.

Select text precisely, edit columns, control registers, and jump back to saved positions.

Comprehensive VS Code reference for navigation, editing, multi-cursor, search, terminal, debugging, settings, and Git workflows.

Launch configurations, breakpoints, tasks.json, and common debugging workflows in VS Code.

Daily Git workflows, compare views, merge conflicts, and general productivity patterns inside VS Code.

High-value VS Code shortcuts for navigation, editing, multi-cursor, search, panels, and windows.

Search, replace, regex, and multi-file refactoring patterns in VS Code.

Useful user and workspace settings.json snippets for formatting, files, search, editor behavior, and terminal preferences.

Integrated terminal workflows plus `code` CLI commands for opening files, folders, diffs, and extensions.

Reusable YAML patterns using anchors and aliases, with merge examples and commands for expanding and validating resolved config.

Core YAML syntax, indentation rules, maps, lists, and practical validation commands for day-one and day-100 YAML workflows.

Application config, OpenAPI, environment settings, and interoperability patterns for YAML across modern tooling.

Kubernetes manifests, GitHub Actions, Helm, Compose, and YAML-powered automation workflows with practical validation commands.

Indentation patterns, nested lists and maps, and practical commands for catching whitespace and structure mistakes.

Document separators, multi-resource YAML files, and commands for splitting, filtering, and validating streamed YAML.

Plain scalars, quoted strings, literal and folded blocks, and the quoting rules that prevent common YAML mistakes.

Common syntax errors, duplicate keys, parser checks, and validation workflows for debugging YAML faster.

High-value yq commands for reading, updating, filtering, converting, and merging YAML in local scripts and CI pipelines.