All Cheatsheets

One-page Git command reference covering commit & stash, branch create/merge/rebase, revert & recovery, remote collaboration, and git log history queries — 50+ common operations for daily collaboration and recovering from mistakes.

A .gitignore pattern reference for developers who keep Git repos clean and avoid committing dependency directories or secrets, covering glob matching, directories vs files, negation, global ignore, and common language templates.

A one-stop Linux troubleshooting reference organized by process/load, port/network, disk/memory, and logs/services, helping you quickly spot performance bottlenecks, connection anomalies, and resource hogs during live incidents.

A Vim operation reference covering cursor motion, text editing, search and replace, visual mode, and save/exit, aimed at developers and operators editing files on a server, including real-world tricks such as batch replacement and saving with sudo.

A Systemd service-management reference covering start/stop and boot-enabling, journalctl log viewing, timer scheduling, targets and runlevels, and resource limits, with the differences between easily-confused pairs such as reload vs restart and mask vs disable.

A Cron scheduling reference spanning the 5-field expression format, special characters and time macros, common examples, environment variables, and troubleshooting, flagging frequent pitfalls such as the OR relationship between day-of-month and day-of-week and the minimal default PATH.

A debugging reference for GitHub Actions, GitLab CI, and Jenkins pipelines, covering job reruns and log extraction, runner online status, cache and disk usage, and local reproduction with act or gitlab-runner exec.

An MQ operations reference for Kafka, RabbitMQ, RocketMQ, and Redis Pub/Sub, focused on the four high-frequency scenarios of locating consumer backlog, hunting connection leaks, diagnosing cluster state, and benchmarking throughput.

For anyone doing long-lived remote work over SSH, tmux keeps sessions, windows, and panes alive across disconnects — closing a window does not kill the work. This table groups create/delete/switch flows for sessions, windows and panes, copy-mode keystrokes, and common .tmux.conf settings.

grep, sed, and awk are the "three text-processing swords": grep matches, sed rewrites in place, and awk extracts and aggregates by column. This reference collects each tool's highest-frequency forms and keeps the classic pipeline chain (grep to filter, sed to substitute, awk to summarize), for anyone who lives in logs, configs, and CSV.

A tar archiving reference covering creating and extracting .gz/.bz2/.xz/.zst archives, exclusion of files, listing archive contents, incremental backups, and common pipeline tricks.

Whether you are shipping an HTTPS endpoint or debugging a TLS failure, OpenSSL is the tool: inspecting a certificate's validity and SANs, generating a CSR and self-signed cert, and testing an actual TLS handshake. This reference is organized around the certificate lifecycle and connection debugging for developers and ops configuring certs or chasing handshake errors.

Bash is the default entry point for automating ops and deploys, and the details that make a script robust — default variables, parameter expansion and string slicing, conditionals, and loops — are where the skill lives. This reference covers variables, branches, loops, functions, and common string/file operations for both writing scripts from scratch and debugging existing ones.

A chmod reference covering numeric and symbolic modes, recursive changes, common permission combinations, and the purpose and risks of SUID/SGID/Sticky special permissions.

A find reference covering search by name, type, size, time, permission, and owner, plus running actions on matches, with tips to avoid scanning irrelevant directories.

When a port refuses to start or a deleted file still pins disk space, lsof answers "who opened what": by process, port, user, or file. This reference covers the multi-axis lookups (listener + process, file-to-user, connections) and practical flags like +L1 for freeing files marked deleted-but-still-held.

For checking connection states, confirming what is listening, and counting per-protocol connections, netstat is the veteran Linux command, complementary to ss. This reference covers listing connections, filtering by TCP/UDP, listening ports, the routing table, and interface stats, and flags -p to pin down the owning process.

screen is the terminal multiplexer that ships with almost every Linux distribution, a lighter alternative to tmux. This reference covers creating, detaching, and reattaching sessions (Ctrl-a d to detach, -r to return), multiple windows and splits, plus the -x flag to share one session across two terminals — so a dropped SSH connection stops interrupting long-running work.

An awk reference covering built-in variables such as NR and NF, conditionals and loops, per-column extraction and aggregation, string functions, and typical patterns for processing logs and CSV.

Batch-editing configs, redacting logs, and in-place replacement with a backup are sed's territory — the "rewrite" partner to awk's "aggregate". This reference covers substitution, deletion, insert/append, addressing by range, extended regex, and the -i in-place edit with -i.bak backup.

A grep search reference covering basic and recursive search, regex vs fixed strings, context lines, inverse filtering, multiple patterns, and counting, with common performance and escaping notes.

A ps process-management reference covering filtering by user, command, and state, custom output columns, process trees and threads, and the difference between aux and -ef styles.

top is the first window that shows why a machine feels slow, and htop wraps the same data in friendlier keys. This reference covers sorting and filtering by CPU/memory, the interactive keys (P/M to sort, k to kill), batch-mode output to file, and how to read the load average and memory bars to tell pressure from noise.

A wget download reference covering basic downloads, resume support, retries and timeouts, recursive site mirroring, background downloads, and handling auth and HTTPS.

An scp and rsync file-transfer reference covering single-file and directory copies, incremental sync, preserving permissions and timestamps, resume and checksum, and when each tool fits best.

netcat (`nc`) is a Swiss-army knife for network checks: test whether a port responds, stand up a throwaway listener, relay between sockets, or move a file — without installing a server. This reference covers connect/scan, listen-and-echo, HTTP debugging, forwarding, and UDP mode, for quick connectivity checks under pressure.

A taskset CPU-affinity reference covering reading a process's current CPU mask, pinning a process to specific cores or a range, and tuning with the NUMA topology in mind.

ffmpeg is the de-facto standard for audio/video processing, covering transcoding, cutting, joining, extracting audio/subtitles, watermarking, and filtering in one tool. This reference covers format conversion, explicit encoders, cut/trim, audio and subtitle extraction, compression, and filters, plus the `-c copy` shortcut that skips re-encoding for speed.

The Makefile's real value is its dependency graph — declaring prerequisites means only stale targets rebuild, which is why it also powers many non-C automation tasks. This reference covers variable assignment (= vs := vs ?=), targets and rules, pattern rules and automatic variables, conditionals and functions, plus common pitfalls like .PHONY.

A Zsh terminal-configuration reference covering common .zshrc settings, oh-my-zsh plugins and themes, aliases, autocompletion, history search, and prompt customization.

An HTTPie reference: GET/POST requests, automatic JSON formatting, form and file uploads, authentication, and http/s sessions for everyday API testing.

For encrypting files, signing messages, and signing Git commits, GnuPG is the local standard, and good key management is what actually keeps it usable. This reference covers key generation, import/export and revocation, encryption/decryption, sign/verify, and gpg-agent's passphrase cache.

An Ansible reference covering ad-hoc commands, inventory management, common modules (copy, template, service, shell), Playbook structure, and syntax and check validation.

An AWS CLI reference covering authentication and configuration, the EC2 instance lifecycle, S3 object operations, IAM users and policies, and common query and management commands across resources.

Vagrant turns a machine image plus a Vagrantfile into a reproducible local VM that the whole team can share. This reference covers the init/up/ssh/destroy lifecycle, Vagrantfile settings, multi-machine definitions, and Provision automation, with notes on synced folders and port forwarding.

A Fish Shell reference covering its syntax differences from Bash, variables and functions, out-of-the-box autocompletion, aliases, and theme configuration.

An rclone reference for cloud storage, covering configuring a remote, copy and sync, checksum verification, filter rules, and encrypted backups.

For periodic scripts, scheduled backups, and log cleanup, cron is the most widespread Linux job scheduler — the five-field time syntax is the main hurdle. This reference covers the time format and special strings, common examples, crontab subcommands, environment variables, and troubleshooting hooks like log location and MAILTO.

An rsync incremental-sync reference covering -a archive, -z compression, --delete mirroring, --exclude, --dry-run preview, and remote sync, with an eye on backup correctness.

Terraform manages infrastructure as code through declarative HCL, with init → plan → apply → destroy as the core loop. This reference covers that lifecycle, state-file management, variables and outputs, module references and remote backends, plus hygiene commands like fmt and validate.

On Windows, system administration and automation hinge on PowerShell's object pipeline — cmdlets return objects, not text, so you filter and act on properties directly. This reference covers common cmdlets and their Linux counterparts, file/process/service operations, and Invoke-Command remoting, to turn daily Windows ops into scripts.

An SSH handbook for engineers who need passwordless login, bastion hopping across environments, and linking their local machine to remote networks — covering ssh -i/-p/-vvv login debugging, ssh-keygen & ssh-copy-id key management, ~/.ssh/config aliases & ProxyJump, -L/-R/-D port forwarding, and the known_hosts and key-permission gotchas.

An Elasticsearch reference for cluster operators and search engineers, covering health checks, shard allocation diagnosis, index & lifecycle (ILM) management, document CRUD, search & query DSL, aggregation, slow-query analysis, and disk/red-cluster troubleshooting.

For developers who use Python as their scripting and data-processing workhorse: covers venv/pip environments, built-in containers, list comprehensions, file and JSON I/O, exception handling, and common built-ins, ready to apply to real projects.

An ES6+ syntax reference for frontend and full-stack developers: let/const, arrow functions, destructuring, template literals, higher-order array methods, and Promise/async-await — the patterns used most in everyday React/Vue and Node code, ready to reuse.

For Go developers building backend services, cloud-native tooling, and CLIs: covers variables & types, control flow, functions and defer, structs & methods, interfaces, goroutine/channel concurrency, and error handling, organized by the coding scenarios you hit in practice.

For Python developers doing data analysis, numerical computing, and scientific simulation: covers array creation, indexing & slicing, shape manipulation, math & statistics, random numbers, and the often-misunderstood broadcasting rule, arranged from creating an array to saving it to disk.

For Java backend and ops developers: covers compiling, running and packaging with javac/java/jar, Maven/Gradle build flows, JVM heap and GC tuning flags, and online troubleshooting with jps/jstack/jmap/jstat, organized in a build → run → tune → debug sequence you can copy.

For PHP developers and the ops people deploying PHP apps: covers running scripts and the built-in dev server, Composer dependency management, extension and ini config checks, php -l linting and phpinfo diagnostics, grouped by the real dev workflow.

For Rust developers, from beginners in the borrow checker to maintainers of production crates: covers Cargo project scaffolding, build and run, testing, docs, Clippy lints, rustfmt, and cross-compilation, following the actual release workflow.

For Kotlin developers, especially Android and JVM-backend engineers: covers kotlinc compilation and scripting, Gradle builds, null-safety idioms, the standard collection operators, and coroutines, arranged around the code you write every day.

For Swift developers shipping iOS/macOS apps or server code: covers swift/swiftc compilation and running, Xcode command-line builds and simctl, Swift Package Manager workflows, and common syntax idioms, arranged by the real build-and-debug cycle.

For Laravel developers making CRUD apps and the ops people behind them: covers project scaffolding, artisan generators, migrations, routing and cache optimization, queued jobs, and testing — the Artisan commands used around every feature and deploy.

For Node developers building REST APIs and web apps on Express: covers app and router setup, route definition (params/query/Router chains), request and response objects, the middleware ecosystem (json, static, cors, helmet, morgan, compression), EJS rendering, JWT auth, and async error handling.

A focused ES2015+ reference for JavaScript developers modernizing their code: let/const and block scoping, arrow functions, destructuring, template literals, Promise/async, modules, classes, Map/Set and iterators — the language features that changed how everyday JS is written.

For developers maintaining legacy sites or jQuery-heavy frontends: covers selectors, DOM manipulation, event binding and delegation, Ajax requests, animations, and the plugin pattern — the API you reach for when modernizing or maintaining jQuery code.

For developers designing or consuming GraphQL APIs: covers query and mutation syntax, subscriptions, the schema type system, fragments, directives, and pagination — the vocabulary shared by GraphQL clients and servers.

For developers writing C for embedded, systems, or performance-critical code: covers data types, control flow, pointers and arrays, functions, manual memory management, file/syscalls, and the preprocessor — with the bytes and lifetimes that demand care in C.

For C++ developers working on applications, games, or libraries: covers classes and objects, the STL containers, smart pointers, lambdas, templates, and exceptions — emphasizing the modern idioms that avoid manual lifetime bugs.

For .NET developers building apps, services, or games: covers classes and interfaces, LINQ querying over collections, async/await, generics and delegates, properties and events, with the C# idioms that differ from other mainstream languages.

For Dart developers building Flutter apps and backend services: covers variables and null-safety types, functions and closures, classes and mixins, and Future/async programming — the syntax that shapes everyday Dart.

For Node and Express developers rendering server-side HTML: covers the EJS tag syntax, escaped and raw output, conditionals and loops over locals, includes, layout inheritance, and wiring EJS into an Express app.

Learn to process data the MATLAB way: build matrices, run linear-algebra solves, visualize trends, read/write files, and do signal processing. 80+ commands grouped by scenario, copy and run.

For JS devs adding static types to a codebase: from basic types, interfaces and union types, to generic constraints and utility types like Partial/Pick/Omit — explained with copyable examples.

A Lodash quick reference for writing safer, shorter JS without hand-rolling helpers: array transforms, safe nested property access, deep clone & merge, debounce/throttle, and handy math utilities. Copy and run.

A Vue 3 reference for building reactive UIs with the Composition API: ref/reactive/computed/watch, lifecycle hooks, props-emits-provide-inject communication, router, Pinia state, and template/render optimization. Copy and run.

A React 18 reference for building component UIs with Hooks: state and effects, advanced Hooks like useReducer/Context, component patterns, controlled forms, and performance tweaks (memo, lazy, Suspense). Copy and run.

A Promise async reference for JavaScript: creating and consuming promises, static combinators like all/race/allSettled, chaining, the async/await syntax, plus concurrency control, timeouts, retries, and abort via AbortController. Copy and run.

A Redux Toolkit reference for predictable app state: configureStore, createSlice with auto-generated actions, async thunks, middleware, useSelector/useDispatch, and normalized entities — the idiomatic way to wire Redux into React. Copy and run.

A React Router v6 (and v6.4+ data APIs) reference: declarative routes and nested layouts, Link/NavLink/useNavigate navigation, URL and search params, guarded routes, and lazy loading. Copy and run.

A Chai.js assertion reference covering all three styles — expect and should (BDD) and assert (TDD): equality, deep comparison, types, inclusion, thrown errors, numeric bounds, plus async and HTTP helpers via plugins. Copy and run.

A Sinon.js test-double reference: spies that observe calls, stubs that replace behavior with returns/throws/resolves, strict mocks, fake timers, sandboxes, and assertion helpers — the tools for isolating units under test. Copy and run.

A Moment.js date-time reference: creating and formatting dates, add/subtract and startOf/endOf operations, comparisons, relative time like fromNow, timezones via moment-timezone, and Duration math. Copy and run.

A Ruby syntax reference for newcomers and Rails devs: variables, symbols, arrays/hashes, control flow, methods and blocks, classes & modules (include/extend/attr_accessor), and exception handling — with the idiomatic Ruby way of writing each. Copy directly.

PM2 process-management commands across start/stop/restart and zero-downtime reload, log management and rotation, cluster mode, monitoring, boot-start and deployment — with key flags explained. For running and keeping Node.js services alive in production.

npm commands across project init/scaffolding, install/update/remove, version management and lockfiles, script running and npx, dependency inspection and auditing, publishing, and config/cache. For running a Node.js project's full lifecycle without leaving the terminal.

Webpack configuration covering entry/output, Loaders for assets, Plugins, the dev server and HMR, code splitting and bundle optimization, and mode/environment. For assembling a frontend build pipeline and fixing slow or bloated builds.

Jest testing APIs covering test cases and grouping (describe/it), matchers and assertions, async testing, mock functions and module mocking, snapshot tests, and coverage reports. For writing JavaScript unit tests that fail for the right reason.

An Nginx configuration handbook for backend, DevOps, and frontend-integration engineers, covering nginx -t/-s reload syntax validation and hot reload, location matching priority, proxy_pass reverse proxies, access/error log troubleshooting, and the common causes of 502/504.

A curl request and troubleshooting handbook for backend developers, testers, and ops, covering GET/POST request bodies, -v/-I/-w request details and timing analysis, -k/-x TLS and proxies, -u/-F/-o auth and upload, plus practical combinations of cookies, redirects, and timeout retries.

An HTML reference for building accessible, semantic web pages — document structure, text, lists, links & images, tables, forms, and the semantic tags that convey meaning to both browsers and screen readers.

A CSS reference for styling pages without a framework, covering selectors, the box model, Flex/Grid layout, positioning, transitions & animation, and responsive patterns for both desktop and mobile.

An Emmet abbreviation reference for anyone writing HTML/CSS by hand in VSCode, covering structure expansion, nesting & grouping, attribute and counter shortcuts, and CSS shorthand that turns long markup into a single keystroke.

A Sass/SCSS reference for structuring CSS that scales, covering variables, nesting, Mixins, @extend, math and color functions, and @each/@if control flow, plus how they compile down to plain CSS.

A Flexbox layout reference for building one-dimensional responsive layouts, covering container vs item properties, main-axis and cross-axis alignment, grow/shrink/basis sizing, and the classic toolbar, card, and centered layouts that Flexbox handles naturally.

A CSS Grid reference for building two-dimensional page layouts, covering grid-template definitions, track sizing with fr/minmax, named areas and line placement, alignment, and responsive patterns that adapt without media queries.

An HTML meta tags reference for controlling how a page appears in search and on social — SEO meta, Open Graph & Twitter Cards for sharing, viewport & responsive/theme settings, PWA manifest & theme-color, and security headers such as CSP.

A Tailwind CSS reference for developers who build interfaces directly with utility classes — layout Flex/Grid, spacing, typography, colors, responsive breakpoints, dark mode, and animation — and the trade-offs of on-demand generation and class composition.

A Next.js reference for React developers weighing SSR vs SSG, covering App Router routing and layouts, the client/server component boundary, data fetching, API routes, middleware, the static-generation vs ISR trade-off, and how the cache hierarchy affects update freshness.

A Svelte reference for developers who prefer minimal runtime and compile-time reactivity, covering reactive declarations (let and $:), template syntax, events and dispatch, component communication, lifecycle, Store, and built-in transitions — and how Svelte removes a virtual-DOM runtime from the box.

For engineers working without a browser who need to call APIs and download with resumable transfers — covering GET/POST requests, headers & cookies, resumable download, proxy auth, and debugging with both curl and wget, plus a side-by-side comparison so you pick the right tool per task.

A MySQL command handbook for DBAs, backends, and data analysts, covering database & table management, CRUD, index optimization and slow-query localization with EXPLAIN, user privileges, logical backup & recovery, and replication — highlighting operations that can lock tables or stall replication.

A PostgreSQL command handbook for backend engineers, DBAs, and data analysts, covering connection & role management, database & table operations, EXPLAIN analysis, lock & transaction troubleshooting, pg_dump/pg_restore backup & recovery, and streaming replication, with paths for locating lock waits and table bloat.

A Redis command handbook for the cache/backend and its operators, covering string and per-data-structure operations, key space and TTL management, RDB/AOF persistence trade-offs, memory and big-key inspection, slow query monitoring, cluster & replication, and practical debugging of hot keys, big keys, and cache puncturing/cascading.

A MongoDB reference for backend engineers, covering database & collection management, document CRUD, query operators, index strategies that keep queries off full collection scans, the aggregation pipeline, and replica-set vs sharded-cluster responsibilities.

A Neo4j Cypher reference for working with graph data where relationships matter more than rows, covering node & relationship creation, pattern matching, updates & deletes, aggregation and ordering, constraints & indexes, and traversal-style graph queries.

A SQL JOIN reference for writing multi-table queries correctly, covering INNER, LEFT/RIGHT/FULL OUTER, CROSS, self-joins, USING/natural joins, and when a correlated subquery with EXISTS beats a JOIN — plus the row-duplication pitfall of joins on one-to-many tables.

A Knex.js query-builder reference for Node.js developers who want type-safe, database-agnostic SQL, covering CRUD, joins, aggregation & grouping, transactions with rollback, schema building, raw queries, and debug() to inspect the generated SQL.

A reference for developers who need a zero-config embedded database in a single portable file, covering creation & connection, table operations, CRUD, indexes & constraints, transactions, CSV import/export, and the sqlite3 CLI — plus the WAL-mode and concurrent-write-lock gotchas.

For developers who write SQL that must be both correct and fast, covering the specifics of SELECT, JOIN, aggregation and GROUP BY traps, subqueries, window functions (ROW_NUMBER/RANK/LAG), NULL semantics, transactions, and DDL — each with a locally runnable example showing the expected behavior.

A Docker command handbook for developers and operators, walking through image build, container lifecycle, networks & volumes, and Compose orchestration, with key flags and real-world troubleshooting for both local development and production deployment.

A kubectl command handbook for app developers and cluster operators, covering Pod query & log diagnosis, deployment scaling & rolling updates, context & namespace switching, and event troubleshooting, with full debugging paths for CrashLoopBackOff and ImagePullBackOff.

A Docker Compose command handbook for frontend, backend, and DevOps engineers who manage several services as one unit, covering multi-service orchestration, log tracking & status inspection, config validation & build, network & named volume management, and horizontal scaling, with mitigation and troubleshooting for frequent incidents like down -v data loss and --scale port conflicts.

A Dockerfile writing reference for developers who package applications into images, covering base image selection, RUN execution, COPY/ADD file handling, ENV variables, port declaration, multi-stage builds, and layer size optimization — with the build cache and .dockerignore pitfalls that silently blow up image size.

Regex syntax and high-frequency patterns: character classes, anchors, quantifiers, groups & backreferences, lookahead/lookbehind, greedy vs lazy matching, plus editable templates for email, URL, phone and ID. Each metacharacter is explained so you understand why a pattern works, not just copy it.

Every HTTP response status code from 1xx to 5xx with its meaning, common cause and a debugging hint. Built for backend/frontend developers and Nginx/gateway ops to pinpoint why an API misbehaves — distinguishing 4xx from 5xx and checking whether redirects behave as expected.

A Markdown syntax reference covering headings, text formatting, links & images, lists, code blocks, tables, blockquotes and GFM extensions, with cross-platform caveats. For writing technical docs, READMEs and blog posts that stay clean and portable.

LaTeX commands for academic typesetting, grouped into document structure, text formatting, math formulas, list environments, tables/figures and references. For writing papers, reports and theses in LaTeX rather than fighting the tool.

ASCII codes for control and printable characters, each shown in decimal, hex, octal and HTML-entity forms, plus notes on Latin-1 extension and how to convert codes in common programming languages. For encoding and protocol debugging.

Common MIME types / Content-Type values mapped to file extensions, covering text, image, audio, video, application data, documents, archives and fonts, including charset hints. For correctly returning and validating Content-Type in HTTP responses and uploads.

HTML character entities in both named and numeric forms, for symbols, quotes, arrows, math and Greek letters. For escaping user input against XSS/breakage and for rendering special characters reliably.

Unicode codepoints for common emojis by category — smileys, gestures, hearts, animals, food and activity — plus encoding pitfalls such as surrogate pairs and ZWJ sequences. For storing and rendering emoji correctly both frontend and backend.

Common screen resolutions and aspect ratios grouped by phones, tablets, laptops, monitors and TVs. For planning responsive breakpoints, aligning video aspect ratios and choosing device targets.

ISO 639-1 two-letter language codes for Asian, European, Middle Eastern and African languages, each with English and native names, plus Accept-Language and HTML lang attribute usage. For wiring locale negotiation in i18n apps.

HTTP methods and REST semantics: GET/POST/PUT/PATCH/DELETE verbs, idempotency, safe methods, status-code pairing and common misuses. For choosing the right verb when designing APIs so retries and concurrency behave predictably. Pairs with the HTTP Status Codes sheet.

Semantic Versioning rules: the MAJOR.MINOR.PATCH structure, prerelease tags, comparison operators, npm range syntax (^ ~ >= < *) and release rules. For managing dependency versions without surprises.

RESTful API design conventions covering URL naming, HTTP method selection, status-code choice, request headers and response formats, auth options and best practices. For designing consistent, debuggable web APIs.

CIDR notation reference covering subnet-mask tables, common subnet sizes, private IP ranges, special-purpose addresses and the math to split or merge subnets. For network planning, ACLs and diagnosing addressing mistakes.

Date & time formatting reference covering strftime tokens, ISO 8601, timezone offsets and per-language formatting methods, plus timestamp conversion and date math. For producing and parsing timestamps that don't drift across timezones.

High-frequency VSCode shortcuts covering the Command Palette, multi-cursor editing, file & code navigation, refactoring, debugging and Git integration. For developers who want to stop reaching for the mouse while refactoring and switching files — both macOS and Win/Linux keybindings are listed.

Emacs keystrokes covering file & buffer operations, cursor movement and editing, search/replace, window management, keyboard macros and Org-mode, with the C/M prefix conventions explained. For terminal or no-GUI editing where Vim-style modal editing is not an option.

Prompt-design patterns and templates for ChatGPT: role assignment, task framing and step breakdown, output-format constraints, few-shot examples and chain-of-thought steering — with common office, coding and writing scenarios. For turning vague asks into consistent, controllable model output.

Pandoc conversion commands across Markdown/HTML/PDF/DOCX/EPUB interchange, Chinese PDF typesetting and fonts, custom templates and styles, slides and e-books, citations and math. For converting documents without re-keying content or breaking layout.

Homebrew commands for installing/updating/removing formulas, managing Cask GUI apps, starting and stopping services, switching to domestic mirrors, and inspecting dependencies and debugging broken installs. For keeping a macOS dev environment reproducible.

XPath selector syntax: node paths, predicate filtering, axis navigation, string/functions and wildcard/logic, plus XML/HTML parsing and scraping patterns. For locating elements precisely in XML, HTML or config files without brittle regex.

mitmproxy commands covering startup modes and ports, flow filters, request/response interception and editing, Python script injection, and HTTPS certificate installation. For inspecting and mutating API traffic when curl or browser DevTools can't capture it.

Postman operations covering request building, environment/global variables, test scripts and assertions, pre-request scripts and dynamic data, and collection runs with Mock servers. For debugging APIs beyond a single curl call.

Chrome DevTools operations covering the Elements panel and DOM breakpoints, Console tips, Network analysis and request replay, Performance/Profiler flame graphs, and Application storage. For diagnosing layout, network and runtime issues in the browser.

Figma shortcuts covering tool switching and frames, layer management and grouping, alignment and layout, component/style creation, view navigation and exports. For speeding up UI mockup work for designers and design-engineers.

IntelliJ IDEA shortcuts covering code navigation, editing and refactoring, code generation and completion, run/debug and stepping, VCS/Git integration, and window layout. For Java/Kotlin developers who want to drive the IDE instead of the IDE driving them.

Sublime Text shortcuts covering basic editing and code folding, multi-cursor and bulk editing, quick navigation, search/replace, split windows and layout, plus snippets and autocompletion. For developers on a featherweight editor who still want serious editing power.

WebStorm shortcuts (JetBrains keymap) covering editing and formatting, completion and generation, navigation/search, refactoring, running/debugging, Git integration and layout. For JS/TS frontend developers who want JetBrains-level tooling on the keyboard.

PhpStorm shortcuts covering PHP-specific code generation, Laravel/Symfony framework navigation, database tooling, debugging/run and static-quality checks. For PHP/Magento/Laravel developers who want framework-aware jumps from the keyboard.

Android Studio shortcuts covering Kotlin/Java generation and navigation, the layout editor, Gradle build and sync, emulator keys, run/debug, and Logcat/Profiler panels. For Android developers whose loop is edit → build → run inside one IDE.

GitHub shortcuts covering global navigation, repo browsing and file search, code search, Issue/PR operations, code review and commenting, and Markdown editing. For moving around GitHub without lifting hands off the keyboard during review-heavy workflows.

GitLab shortcuts covering global navigation, repo browsing and file search, code search, Issue/MR operations, review (MR approvals/threads) and Markdown editing. For teams on self-hosted GitLab who live in the review flow.

Vite build commands and config covering project initialization, the dev server, production build, environment variables, plugins, proxy and SSR builds, plus how its workflow differs from Webpack-era tooling. For scaffolding or maintaining a Vite-based frontend project.

A YAML syntax reference for developers who write Docker Compose, Kubernetes and GitHub Actions configs, covering basic syntax, data types, lists, dicts, multiline strings, anchors and explicit type tags. Consult section by section while validating indentation and common write errors.

A JSON reference for frontend/backend developers who handle API payloads and JSON config, covering data types, objects, arrays, nesting, common API response patterns, and validation/formatting commands. Consult section by section when a key quotation, comma or nested brace causes an error.

A TOML reference for developers writing Rust/Cargo, Hugo and Python pyproject.toml config, covering basic types, date-time, strings, arrays and tables, arrays of tables, and a Cargo.toml example. Section-by-section lookup helps avoid type and structure ambiguity.

An INI reference for developers working with Windows config, PHP php.ini, Git config and Python configparser files, covering basic syntax, data types, common real-world sections and cross-parser pitfalls.

An environment-variable reference for Node/Python/frontend developers writing .env and integrating dotenv, covering variable definition, shell and per-language reading, dotenv usage, multi-environment file organization, and security pitfalls such as secret leakage.

For developers shipping with Docker and slimming images: explains .dockerignore glob matching, ignoring files and directories, differences from .gitignore, build-context slimming tips and common pitfalls. A correct ignore file sharply shrinks the context sent to the daemon.

Full command reference for Claude Code, Anthropic terminal AI coding agent: install & auth, -p print mode and session resume, --permission-mode/--worktree, dev slash commands, MCP server management, and @ file references, all flags matching official docs.

Command reference for OpenAI Codex CLI, the Rust-built terminal coding agent: install & auth, interactive and non-interactive codex exec, session management, model & config, sandbox and approval modes, MCP, and Codex Cloud.

Command reference for Gemini CLI, Google open-source (Apache 2.0) terminal AI agent: install & auth, run modes and global flags, session slash commands, MCP/extension management, and GEMINI.md project memory, with a 2M context.

Command-line and Cursor Agent reference for Cursor, the VS Code-based AI editor: opening files/folders, window management, diff compare, extension management, rendering & performance, remote dev, debugging, cursor-agent non-interactive calls, and git core.editor integration.

Command reference for Aider, the open-source Apache 2.0 terminal AI pair programmer (100+ models, auto git commits): install, model & reasoning, files & context, chat modes, Git & run, session tools, and advanced usage.

Command reference for OpenCode, the open-source Claude Code-style TUI terminal AI coding agent: launch & resume, CLI flags, session and subcommands (agent/auth/github/mcp/run/serve/web), and interactive slash commands.

Command reference for Goose, the open-source general-purpose terminal AI agent (Rust, Apache-2.0, 15+ providers, 70+ MCP extensions; orig. Block, now Linux Foundation AAIF): sessions, runtime, configure, extensions, and diagnostics, including goose session/run/configure/cook/doctor and --resume.

Command reference for OpenHands, the open-source autonomous coding agent that can write a whole repo: launch, task execution, approval modes, resume/headless, Web/ACP/Cloud, MCP management, and config, including openhands -t/--yolo/--resume/--headless and openhands mcp.

Command reference for Cline, one of the most popular VS Code AI coding extensions (formerly Claude Dev, Apache-2.0, multi-provider, Plan & Act modes): command palette entries, @ context references, Plan/Act workflows, and config.

Command reference for Ollama, the de-facto open-source local LLM runtime: run, pull/push, model management, Modelfile customization, serve, and config, including ollama run/pull/list/ps/create and Modelfile FROM/PARAMETER/TEMPLATE/SYSTEM.

Command reference for Qwen Code, Alibaba Qwen open-source AI coding CLI (Claude Code-like, built on Qwen3-Max / Qwen3-Coder): install, launch, print mode, slash commands, and MCP, including qwen -p, /init, qwen mcp, and DASHSCOPE_API_KEY.

Command reference for GitHub Copilot CLI (gh CLI extension): explain commands, generate shell suggestions, aliases, and config, covering gh copilot explain/suggest/alias/config and @copilot.

Command reference for Amazon Q Developer CLI, AWS official terminal AI coding agent: install, login, chat, one-line queries, and Agent mode, covering brew install amazon-q, q chat, q one-line queries, and /q slash commands.

Command reference for Sourcegraph Amp, the terminal AI coding agent: install, login, one-shot prompts, background execution, and thread management, covering @sourcegraph/amp, amp prompts, amp -x background tasks, and amp threads.

Command reference for LiteLLM, unified OpenAI-compatible gateway for 100+ LLMs: proxy launch, provider-prefix routing, config-file mode, and self-test, covering litellm --model, litellm --config, and litellm --test.

Command reference for vLLM, the high-performance LLM inference & serving engine: install, OpenAI-compatible server launch, host/port/API-key configuration, and quantization, covering pip install vllm, vllm serve, and --host/--port/--api-key.

Command reference for llamafile, Mozilla single-file local LLM runner: download & run, OpenAI-compatible server, GGUF loading, GPU layers, and temperature, covering ./xxx.llamafile --server, --nobrowser, -m, --ngl, --temp.

Command reference for Continue CLI (cn, open-source terminal coding agent sharing the engine with the VS Code/JetBrains extensions): install, interactive session, headless mode, login, and thread resume, covering cn, cn -p, cn login, and cn --resume.

Command reference for Hermes Agent, Nous Research open-source, model-agnostic terminal AI agent: install, model & tool configuration, message gateway, and setup wizard, covering hermes model, hermes tools, hermes config set, and hermes gateway.

Command reference for Kilo Code CLI, the terminal AI coding agent sharing an engine with the IDE extensions: install, interactive & one-off tasks, and model integrations, covering kilo run, kilo --mode, kilo --auto, kilo auth, and kilo mcp.

Command reference for Pi, the earendil-works multi-model terminal coding agent: install, interactive sessions, headless mode & scripting, and session/model management, covering pi -c, pi -p, pi @file, /login, and /model.

Command reference for Kimi Code CLI, Moonshot AI terminal AI coding agent wired to Kimi models: install, interactive & single instructions, and sessions & models, covering kimi -p, kimi -C, /login, /init, and /model.

Command reference for Grok CLI, the xAI Grok Build terminal AI coding agent: install, interactive sessions, session management, headless mode, and scripting, covering grok -p, grok inspect, XAI_API_KEY, and /model.

Command reference for Warp Agent CLI, the AI coding agent built into the Warp terminal: install, core agent commands, MCP integration, and cloud agents, covering /agent, /model, /plan, /orchestrate, /mcp, and oz agent run.

Command reference for Crush, the Charmbracelet Rust single-binary terminal AI coding agent: install, sessions & modes, and configuration, covering crush --yolo, /model, and crush logs.

Command reference for Antigravity CLI (Google terminal AI coding agent, command `agy`): install, sessions & planning, and tools & integrations, covering agy, /model, /planning, /mcp, and /permissions.

Command reference for Plandex, the terminal planning open-source AI coding agent (alias pdx): install, plan & load, and execute & iterate, covering plandex new, plandex load, plandex tell, and OPENROUTER_API_KEY.

Full command reference for Open Interpreter, a terminal AI coding agent: install and launch, --local local models, -y auto-accept, --os OS control, --api_base custom endpoint, resume --last session restore and /model interactive commands, all matched to official docs.

Full flag reference for llama.cpp llama-cli inference tool: model load -m, interactive -i, GPU offload -ngl, context -c, threads -t, temperature --temp and conversation -cnv, all matched to official docs.

Full command reference for MLC-LLM mlc_llm CLI: chat interactive, serve local server, convert model, plus --device, --quantization, --model-lib flags, all matched to official docs.

Full command reference for LocalAI local-ai CLI: run and serve to start, models list/install/pull for management, api and finetune commands, all matched to official docs.

Full command reference for LM Studio lms CLI: status, ls and ps to list models, get to download, load and unload, server start, and terminal chat, all matched to official docs.

Full command reference for GPT Engineer gpte and gpt-engineer CLI: create projects, improve code with -i, --model selection, --steps workflows, and --temperature, all matched to official docs.

Full command reference for Mentat CLI: pass files or dirs as context, --exclude to drop paths, --auto-context retrieval, --model switch, --mcp-server for tools, and /include interactive commands, all matched to official docs.

Full command reference for CrewAI crewai CLI: create crew, run, train, flow workflows, tool management, and install, all matched to official docs.

Full command reference for Phidata phi CLI: init, auth, config, ws create/up/down workspace management, start/stop resource deploy, all matched to official docs.

Full command reference for Tabby tabby CLI: serve to start, --model/--device/--port flags, download models, scheduler to trigger indexing, and OpenAI-compatible API calls, all matched to official docs.

Full command reference for Open WebUI open-webui CLI: serve to start, --port and --host flags, DATA_DIR, pip install and update, Docker and K8s deploy, all matched to official docs.

Full command reference for gptme CLI: start a chat, -m model, -t tools, -y auto-confirm, -n non-interactive, --output-format json, resume, and tools/chats/models subcommands, all matched to official docs.

Full flag reference for SGLang launch_server: --model-path, --host and --port, --tp and --dp parallelism, --mem-fraction-static VRAM, --quantization, and --trust-remote-code, all matched to official docs.

Full command reference for Tabnine CLI: tabnine to start, /help /model /clear /settings slash commands, -p non-interactive mode, TABNINE_TOKEN auth, and tabnine-opencode integration, all matched to official docs.

Prompt-writing reference for ChatGPT covering role setting, structured output (JSON/table/Markdown), code generation & review, text processing, Few-shot prompting, and Chain of Thought, with adaptable template skeletons.

Prompt-writing reference for Claude, highlighting 200K long context, Constitutional AI, and jailbreak refusal, covering long-doc processing, code generation & analysis, role-play, structured output, multi-turn dialogue, and safety boundaries, with adaptable template skeletons.

Midjourney AI art prompt and parameter reference covering basics (--ar/--v/--q/--niji), style keywords, composition & camera, lighting & mood, negative prompts & weights (--no/::), and advanced tips (seed/chaos/stylize), with combinable prompt skeletons.

Prompt-writing reference for DeepSeek that distinguishes the reasoning model R1 (deepseek-reasoner) from the chat model V3 (deepseek-chat), covering R1 hard rules (no system prompt, instructions in user, no few-shot, temperature 0.6) and V3 system-lock, few-shot, and JSON/function calling.

Gemini prompt engineering reference covering structured delimiters (XML/Markdown tags), long-context anchoring, internal-thinking and date/grounding clauses, native multimodal (text/image/audio/video) input, and model selection (3.5 Flash / 3.1 Pro / 2.5 Pro 1M / 2.5 Flash).

Stable Diffusion (SDXL) image-generation prompt reference covering the six-segment structure, token-weight syntax, negative prompts, LoRA & ControlNet, sampling params (CFG/Steps/sampler), native resolution, and VRAM planning.

Kling AI video-generation prompt reference covering camera moves (push-in/pull-out/pan/tilt/dolly/orbit/crane/tracking), the one-move-per-shot rule, the six-segment prompt structure, and API params (camera_control/aspect_ratio/duration/model).

Perplexity prompt techniques covering "write questions not keywords", Focus modes (Web/Academic/Pro Search/Research/Reddit/YouTube/Writing/Math/Finance), date & source constraints, format constraints, chained follow-ups, and citations.

NotebookLM prompt techniques covering source management (PDF/URL/transcript/spreadsheet), answer-only-from-uploaded-sources with inline citations, verification prompts (find contradictions/gaps/counterpoints), and Learning Guide & Studio (study guide/infographic/audio) generation.

Model-agnostic prompt engineering techniques covering role anchoring, structured output, explicit constraints, Few-shot, Chain of Thought, self-verification, and common pitfalls, not tied to any specific tool.

Retrieval-Augmented Generation (RAG) prompt patterns covering answer-only-from-context, cite sources, handle no-answer, fuse multi-passage evidence, and flag conflicts — emphasizing traceability and hallucination control.

Autonomous-agent system-prompt patterns covering goal/role definition, tool declarations, step-by-step decision loops, guardrails & permissions, error handling, and reflection — emphasizing control and safety.

Model-agnostic text-to-image (Midjourney/Stable Diffusion/SDXL) prompt structure covering subject, style & artists, composition & lens, light & material, negative prompts, and common params.

Code-generation prompt patterns covering requirement & context handoff, language/framework/version constraints, I/O contracts, edge cases & tests, and acceptance criteria — emphasizing compilable, runnable output.

High-frequency macOS shortcuts across General, Finder, Screenshots, Window Management, System and Text Editing — 30+ bindings with what each does. Built for the everyday Mac inefficiency of hunting for the screenshot key or scattering files.

A keyboard-shortcut reference for Windows desktop and multi-monitor users, covering General, File Explorer, Screenshots, Window Management, System, and Command Line — 30+ high-frequency bindings from snapping windows to opening Task Manager in one step.

A Chrome keyboard-shortcut reference for daily browsing and front-end debugging, covering Tabs, Windows, Browsing, Address Bar, DevTools and Mouse — 6 groups with 25+ high-frequency bindings on both macOS and Windows.

A Slack keyboard-shortcut reference for team members who rely on Slack across many channels and threads, covering Messages, Channels, Navigation, Search and Formatting — 20+ high-frequency bindings on macOS and Windows.