Tech

The Unix shell and its scripting language — the glue between every other tool, and the language of the commands agents run.

Microsoft's general-purpose language for .NET — statically typed, garbage-collected, with LINQ, records, and pattern matching that make data-shaping code read declaratively.

Cascading Style Sheets — the presentation layer of the web. Modern CSS: custom properties, cascade layers, container queries, OKLCH color, nesting.

Database Markup Language — a plain-text notation for a relational schema (tables, columns, types, references, enums, notes) that renders as an entity-relationship diagram and converts to and from SQL DDL. The language behind dbdiagram.io.

HTML Template Language (formerly Sightly) — AEM's server-side templating language, expressions in HTML attributes with contextual XSS escaping by default.

HyperText Markup Language — the document structure of the web, and the one layer every other front-end technology eventually produces.

The enterprise language — statically typed, garbage-collected, compiled to a virtual machine that runs the same everywhere, with two decades of frameworks for building the systems large organizations trust.

The programming language of the web — in the browser, on the server through Node.js, and increasingly at the edge.

The server-side language most of the web's content management runs on — WordPress, Drupal, and Laravel are all PHP — with a request-per-script model that keeps deployment simple.

A general-purpose language with a readable syntax and a large standard library, dominant in scripting, data work, and machine learning.

A dynamic, object-oriented language built for programmer happiness — everything is an object, blocks make iteration read like prose, and Rails made it the web framework of a generation.

A CSS preprocessor scripting language that extends CSS with variables, nesting, and mixins.

JavaScript with a static type system layered on top — types are erased at build time, so the language is the same but the editor and the compiler know what a value can be.

Microsoft's cross-platform web framework on .NET — MVC and Razor for server-rendered pages, minimal APIs and controllers for REST, Entity Framework for data.

A rugged, minimal framework for composing behavior directly in markup — fifteen attributes, six properties, two methods, dropped into a page with one script tag, for the interactivity a server-rendered site needs without a build step.

Google's batteries-included front-end framework — TypeScript-first, dependency injection, RxJS, and a CLI that makes every decision so a large team does not have to.

A content-first web framework that ships zero JavaScript by default — pages render to static HTML, and interactive pieces from any UI framework are opted in as islands with their own hydration rule.

Fast, unopinionated, minimalist web framework for Node.js.

The fast Node.js web framework — schema-first routes with JSON Schema validation and serialization, a plugin system with encapsulation, and a benchmark-driven core that made speed a feature.

The glue between a server-side framework and a client-side one — Laravel or Rails routes and controllers, Vue or React or Svelte pages, no API in between: the controller returns a page component and its props.

The PHP framework that made the language pleasant — Eloquent ORM, Blade templates, a queue and scheduler built in, and a convention for almost everything an application needs.

A TypeScript back-end framework with an Angular-shaped architecture — modules, controllers, providers, decorators, dependency injection — over Express or Fastify, with first-class OpenAPI generation from the decorators.

Vercel's React meta-framework — file-based routing, server components and server actions, and a rendering model that decides per route between static, streamed, and dynamic.

Nuxt is my preferred framework for content-driven apps and prototypes. Used for UXLab and several internal tools.

The component model most of the industry standardized on — a UI as a function of state, JSX for markup in code, hooks for the lifecycle, and an ecosystem so large that the framework choice now happens one level up.

A compiler rather than a runtime — components are compiled to plain DOM updates at build time, so there is no virtual DOM and very little framework shipped to the browser.

Svelte's application framework — file-based routing, server `load` functions, form actions that work without client JavaScript, and adapters that deploy the same app to Node, the edge, or static files.

A full-stack React framework from the TanStack family — type-safe file routing from TanStack Router, server functions, and streaming SSR on Vite, without a vendor's deployment target baked in.

The progressive JavaScript framework — a reactive component model with single-file components, the Composition API, and a template syntax that stays close to HTML.

Adobe Experience Manager delivered as a managed cloud service — Adobe runs the Author and Publish tiers and the dispatcher, code arrives through Cloud Manager’s pipelines from a Git repository, and the platform updates itself continuously; the migration target for AEM 6.5 estates, and the one this work’s adapters are written for.

Adobe's enterprise content management system — a Java content repository (JCR/Oak) with Sling on top, authored through a component-and-template model and delivered through a publish tier and a dispatcher cache.

The open-source PHP content management framework — content types, fields, views, and a module ecosystem, with theming through Twig.

Adobe's document-based delivery platform — pages authored in Word or Google Docs (or the Universal Editor), transformed to HTML at the edge, and decorated by plain JavaScript "blocks" with no build step.

The most widely deployed content management system — PHP and MySQL, a theme and plugin model, and since 5.0 the block editor (Gutenberg).

The front-end toolkit that taught a generation of developers what a grid, a component, and a utility class were — Sass source, a responsive grid, and JavaScript components with jQuery long since removed.

A CSS-only framework built on Flexbox — readable class names, no JavaScript, and a modular Sass source you can take a piece of.

IBM's open-source design system — a token architecture, a component library in four frameworks, and the most thoroughly documented governance model of any public system.

The official component library for Nuxt and Vue — accessible primitives from Reka UI, styled with Tailwind Variants, themed through CSS variables, and shipped as auto-imported components.

Salesforce's design system for the Lightning platform — a CSS framework of BEM-named blueprints, design tokens, and the accessibility guidance that comes with building for a regulated enterprise.

A utility-first CSS framework for rapidly building custom user interfaces.

Not a dependency but a set of components you copy into your codebase — Radix primitives styled with Tailwind, owned and edited like your own code rather than configured from outside.

Daniel Eden’s “just-add-water” CSS animation library — a stylesheet of named keyframe animations (bounce, fadeInUp, shakeX, and ninety-odd more) applied with two classes, `animate__animated` and `animate__<name>`, tuned with `--animate-duration` and `--animate-delay`, and switched off for anyone who has asked their OS for reduced motion.

A Redis-backed job queue for Node.js — jobs with retries, delays, priorities, and rate limits, workers that pull from the queue, and flows for jobs that depend on other jobs.

Components in Markdown as a standalone pipeline — parse CommonMark plus a directive-style component syntax into a serializable document, then render it to HTML, a terminal, Vue, React, Svelte, or Angular, with auto-close for Markdown that arrives one token at a time.

A TypeScript ORM that reads like SQL — a schema in code, type-safe queries, and a migration generator that diffs the schema against the last migration.

The icon library the web standardized on — thousands of icons in matched styles (solid, regular, light, thin, duotone, brands), as web fonts, SVGs, or framework components, with the free tier on every CDN and the Pro tier behind a license.

A JavaScript calendar component — month, week, day, and list views, drag-to-move events, and framework bindings for Vue, React, and Angular over one core.

One icon framework over 200,000 icons from 150-plus open-source sets, addressed as `collection:name`, rendered as inline SVG or CSS, and installable one collection at a time.

Diagrams from text — flowcharts, sequences, class and state diagrams written in a small syntax inside a fenced code block and rendered in the browser.

A Nuxt module that turns your repository into a CMS-like content source with Markdown-based authoring and a runtime query API.

The agent runtime underneath OpenClaw — the loop, the tool dispatch and the session-based trust tiers that decide what a given channel is allowed to do.

The official state-management library for Vue 3 — stores defined with the Composition API, typed without ceremony, devtools-inspected, and shared between server and client in Nuxt; the successor to Vuex, with mutations gone and modules replaced by one store per concern.

The routing library React grew up with — nested routes, loaders and actions borrowed back from Remix, and since v7 a framework mode that makes it a full-stack option rather than a client-side add-on.

Charts as React components — a line, an axis, a tooltip each declared in JSX and composed like any other UI, over D3 for the math and SVG for the drawing.

Video made with React — a composition is a component, a frame is a render at a point in time, and the result is an MP4 from code, with data, animation, and layout treated like any other UI concern.

A collection of essential Vue composables — hundreds of small, tree-shakable functions for the browser, state, sensors, animation, and time, each wrapping a reactive idea once so no app has to.

TypeScript-first schema validation — declare the shape once, get the static type and the runtime parser from the same declaration.

A dependency-free confetti burst on a canvas — the one motion effect the garden uses to mark a real completion, and only that.

The DOM library that defined front-end JavaScript for a decade — selectors, events, effects, and Ajax behind one `$`.

JFrog’s universal artifact repository — one server that speaks npm, Maven, Docker, PyPI, NuGet and thirty other package protocols, holding local repositories for what a team builds, remote ones that proxy and cache public registries, and virtual ones that present several as one URL.

Andrew Hedges' four-box calculator: fill in any three of W₁ : H₁ = W₂ : H₂ and it solves the fourth — the fastest way to size an image, a video embed, or a component to a known ratio.

Anthropic's agentic coding tool — a CLI, desktop app and IDE extension that reads a repository, runs its tools, and lands changes through the same git workflow a person would.

An Anthropic Labs product, in research preview since April 2026, for making prototypes, slides and one-pagers with Claude: it reads a codebase and design files, builds a design system from them, and applies it to each new piece.

The Claude app for macOS and Windows: the assistant outside the browser, with system-level shortcuts, local MCP servers as tools, and Claude Code sessions alongside chat.

A macOS screen-capture app — area, window and scrolling captures, annotations, a quick-access overlay, and a media library, so a screenshot is a finished artifact rather than a file on the desktop.

OpenAI's coding agent. An open-source CLI (April 2025) that reads a repository, proposes multi-file changes and runs commands in a sandbox behind an approval step, plus a desktop app, IDE integrations and a cloud agent in ChatGPT.

Atlassian's wiki — where an organization's decisions, runbooks, meeting notes and half-finished specifications live, linked to the Jira tickets they explain.

An AI-first code editor built as a fork of VS Code, with AI in the editing loop: completions across the file, chat over the codebase, and an agent that makes multi-file changes.

A browser-based end-to-end testing framework that runs inside the browser with a time-travelling test runner.

Container build and runtime — a Dockerfile describes an image, the image runs the same anywhere.

The pluggable linter for JavaScript and TypeScript — a rule engine over the AST, a flat config, and an autofixer, with ecosystems of rules for Vue, Node, imports, and formatting.

The collaborative design tool — components, variants, variables, and Dev Mode, with an API and a plugin model that make it a source of truth rather than a picture.

The Given / When / Then language for writing a behavior as an example a person can read and a tool such as Cucumber can run.

A GPU-rendered terminal emulator by Mitchell Hashimoto — native on macOS and Linux, configured in one plain-text file, fast enough that the terminal stops being the bottleneck.

Two things under one name: xAI's computer-use agent, in public beta since August 2026, and the older `@grok` account on X that answers when a post replies to it.

A terminal multiplexer for coding agents — one Rust binary that runs Claude Code, Codex and the rest side by side, reads each one's state (idle, working, blocked, done) off its output, and keeps the sessions alive through a disconnect or reboot.

Nous Research's self-improving agent runtime — procedural memory that accumulates across sessions, and the ability to author its own skills from what it learned doing the work.

Git hooks from a project's own repository: scripts in .husky/ that run on commit, push and the other hook points, installed for everyone by a prepare script.

JetBrains' Java IDE and the base every other JetBrains IDE is built on — the refactoring engine, the debugger, and the plugin model that PhpStorm and Rider inherit.

TypeSafe AI's System One model — it answers typed questions with structured values and never with prose: a boolean with a probability, a choice from a set you named, a score against a scale you defined.

Atlassian's issue tracker — epics, stories, and sprints on a configurable workflow, with Confluence beside it for the documentation the tickets point at.

A design system platform — tokens, components, patterns, and documentation in one workspace, connected to Figma on one side and the code repository on the other, so a change lands once and the docs update themselves.

Browser-based diagramming — flowcharts, architecture and sequence diagrams, ERDs, org charts — with shape libraries, shared editing, and embeds that stay live in Confluence and Jira.

A framework for HTML email — templates authored with Tailwind utilities, then compiled, inlined, and stripped down to what the mail clients of 2010 will still render.

A macOS Markdown previewer that watches a file and re-renders as it is saved — any editor on the left, the rendered document on the right, with custom styles and export to PDF and HTML.

An all-in-one workspace of blocks — pages, wikis and databases that can be viewed as tables, boards, calendars or galleries — for notes, docs and light project tracking, alone or as a team.

A local-first knowledge base over a folder of plain Markdown files — wikilinks, backlinks and a graph view on top, and a plugin ecosystem that bends it into almost any note-taking method.

An open-source, always-on personal AI agent that lives in the messaging apps you already use — Telegram, Slack, Discord, WhatsApp — self-hosted, MIT licensed, and stewarded by a non-profit foundation.

A clipboard manager for macOS and iOS — an unlimited, searchable history of everything copied, pinboards for the snippets worth keeping, and sync across devices.

JetBrains' PHP IDE — IntelliJ's engine with first-class PHP, Blade and Twig support, Xdebug integration, and framework awareness for Laravel, Drupal and WordPress.

An on-screen measuring tool for macOS — snap to any edge, read a distance in pixels, drag a guide across anything that is rendered, from Figma to a running site.

Microsoft's browser automation and end-to-end testing framework — one API across Chromium, Firefox, and WebKit, with auto-waiting locators and a trace viewer.

A tool for transforming CSS with JavaScript plugins — it parses a stylesheet into an AST, hands it to plugins (Autoprefixer, nesting, custom properties), and prints it back out. The layer most CSS tooling is quietly built on.

An API client and workspace — requests organized into collections with environments and variables, tests scripted against responses, mock servers, and collection runs that double as integration suites.

An opinionated code formatter — parse to an AST, print it back out to a fixed width, and argue about style never again.

A launcher for macOS with an extension store — search, window management, snippets, scripts and AI in one command bar, and a React-based extension API that makes writing your own routine.

JetBrains' .NET IDE — ReSharper's analysis inside the IntelliJ shell, cross-platform, with a debugger and test runner that make C# work on a Mac feel native.

A Node.js-based tool for optimizing SVG vector graphics files.

Presentation slides for developers — a Markdown deck with Vue components, code blocks with highlighting, presenter mode, and an export to PDF or a static site, all themed like any other Vite app.

A spreadsheet that thinks it is a project plan — rows with owners, dates and dependencies, Gantt and card views over the same grid, forms and automations feeding it, and reports that roll several sheets into one.

Static analysis as a gate — bugs, code smells, security hotspots, duplication and coverage measured on every pull request, with a quality gate that fails the build when new code slips below the bar.

A workshop for UI components — each story renders one component in one state, in isolation, with controls, docs, and visual and interaction tests attached.

Amazon's build system for design tokens — one JSON source of truth, transformed and formatted into CSS variables, Sass, JavaScript, iOS, Android, or anything a custom format can emit.

AI dictation for macOS, Windows, iOS and Android, built on whisper.cpp. Its models can run offline on-device, and it formats text for the app it is typing into.

The tooling family around OpenAPI — Swagger UI renders a spec as a browsable, try-it-out reference; Swagger Editor edits one; Codegen turns one into clients and servers. The name the spec had before it became OpenAPI, and the one people still say.

A native database GUI for macOS — one window for SQLite, Postgres, MySQL, Redis and the rest, with inline editing, saved queries, and a local MCP server that lets an agent run the same queries.

A family of DOM testing utilities whose queries find elements the way a user would — by role, label, and text — so a test breaks when the experience does and not when the markup does.

A type-scale calculator — enter a base size and a ratio (minor third, major third, perfect fourth…) and read the ladder of sizes, previewed in a font of your choice, with the CSS to copy.

Microsoft's open-source editor — the extension marketplace, the integrated terminal, and now an MCP client, which makes it a host for agents as well as a place to type.

The Vite-native test runner — Jest-compatible API, ESM and TypeScript out of the box, and projects for running the same suite under different environments.

AI voice dictation for Mac, Windows, iOS and Android: hold a hotkey, speak, and it types cleaned-up, formatted text into whatever app has focus, filler words removed.

An infinitely nested outliner: one list of bullets, where any bullet can be zoomed into as its own page, tagged, moved or mirrored elsewhere in the tree.

Node plugin that creates AEM ClientLib configuration files, folders, and synchronizes assets.

Pushes content to AEM instance(s) upon file changes with no vault dependency.

Lints commit messages against a convention, usually Conventional Commits via @commitlint/config-conventional, from a commit-msg hook or in CI.

A style checker for Markdown — a numbered rule set (MD001 through MD059) over headings, lists, spacing, and links, with a CLI that fixes what it can.

Design system documentation as a product — pages that pull live components, styles, and tokens from Figma and Storybook, so the guidance sits next to the thing it describes rather than in a wiki that drifts from it.

Amazon Web Services — the largest cloud, and the one whose service names became the industry's vocabulary: S3 for object storage, Lambda for functions, CloudFront for the edge.

Adobe's enterprise work-management platform — projects, tasks, requests, approvals, proofing and resource planning — where a marketing organization's intake, review cycles and campaign schedules live, and where an AEM or brand-site request usually begins before any repository sees it.

Salesforce's platform for building and deploying AI agents that act on their own across business functions, such as resolving service cases, qualifying leads and running campaigns, on the Salesforce Platform's data.

Microsoft's cloud — compute, storage, managed databases, identity and the rest, and the default answer wherever the organization already runs on Microsoft 365 and Active Directory.

Microsoft's bundle of the whole delivery chain — Boards for work items, Repos for git, Pipelines for CI/CD, Artifacts for packages and Test Plans for manual testing — sold as one product where Atlassian sells Jira and Bitbucket separately.

Atlassian's git hosting — repositories, pull requests and Pipelines CI, with Jira issue keys threaded through branch names and commits so a ticket and its code find each other.

OpenAI's AI assistant, on the web, desktop and mobile. It is also the account that Codex, OpenAI's coding agent, runs under.

Anthropic's family of AI models and the assistant built on them, reached through claude.ai, the desktop and mobile apps, the API, and the products layered on top: Claude Code, Claude Design.

The network in front of the origin — authoritative DNS, a CDN and WAF at the edge, Email Routing for a domain that sends nothing, and Workers and Pages for code that runs at the edge instead of behind it.

Serverless code on Cloudflare's network: JavaScript and WebAssembly running in V8 isolates rather than containers, so thousands share one process and a request starts almost instantly, close to the user.

Media as a service — upload once, then request any crop, format, quality or transformation by changing the URL, with the derived asset generated on first request and cached at the edge.

Privacy-first web analytics — page views and referrers counted without cookies, without fingerprinting, and without following anyone to another site; one ~7 KB script and a dashboard.

Code hosting, pull requests, issues, and Actions — the collaboration layer over git.

Google's cloud — compute, storage and managed data services, strongest where Google's own problems were: BigQuery for analytics, Cloud Run for containers, and the Gemini models alongside them.

The simplest way to sell a file — a product page, a checkout and a download link, with no store to build, aimed at writers, designers and course authors rather than at merchants.

The DevOps platform around Artifactory — the artifact repository at its center, with Xray for scanning what is in it, Pipelines for building, and Distribution for shipping; in an enterprise, usually the one place every package, container image and build output is allowed to come from.

A cross-platform JavaScript runtime built on Chrome's V8 engine for building server-side and networking applications.

The Java module system AEM runs on — a framework (Apache Felix, in AEM’s case) in which code ships as versioned bundles that can be installed, started, stopped and updated at runtime, with services registered and looked up by interface and configuration applied per bundle.

A merchant of record for software — it sells your product as the legal seller, which moves sales tax, VAT and compliance off your books and onto theirs, in exchange for a larger cut than a payment processor takes.

The open-source relational database with the most complete SQL, extensible types, and a reputation for doing the right thing under load.

A deployment platform — services from a Dockerfile or a buildpack, environments per branch, variables, volumes, and a pre-deploy hook.

An in-memory data structure store used as a cache, a queue, and a session store.

A transactional email API for developers — one SDK call to send, domains verified by DNS, webhooks for delivery events, and React or HTML templates rather than a drag-and-drop editor.

The embedded relational database — one file, no server, and through libSQL / Turso a replicated, hosted edition of the same engine.

The CRM company and the cloud platform under it. For a developer, that means the Lightning Platform: Apex, a strongly typed language with Java-like syntax for business logic, the Lightning UI, and Trailhead for learning it.

Error and performance monitoring — exceptions captured with stack traces, breadcrumbs and releases, grouped into issues, with tracing and session replay alongside.

Hosted commerce — catalog, cart, checkout, payments and fulfillment as one platform, themed with Liquid or built headlessly against the Storefront API.

The workplace chat platform — channels, threads, huddles, an app platform with slash commands, webhooks and the Block Kit UI — and, through Claude Tag, a place an agent can be asked from.

Dependency and container vulnerability scanning — a lockfile or an image in, a list of known CVEs with fix versions out, run on every pull request and again on a schedule as new advisories land.

Log aggregation and search at enterprise scale — every machine's events indexed into one store, a query language (SPL) to slice them, and dashboards and alerts built on saved searches.

Payments as an API — charges, subscriptions, invoices, tax and a hosted checkout, with documentation good enough that it became the industry's reference for what developer documentation should be.

A hosted PostgreSQL with auth, storage, and realtime bolted on — the open-source answer to Firebase.

A WireGuard mesh network with the key exchange handled — every device gets a stable address and a name, and anything on one is reachable from another without opening a port.

Hosted libSQL — SQLite as a networked database with replicas, branches, and an HTTP driver, so the same schema runs against a local file in development and a remote database in production.

The hosting platform built around Next.js — git-push deploys, preview URLs per branch, edge and serverless functions.

Anthropic's flagship model, for demanding reasoning and long-horizon agentic work, and the slowest and most expensive in the current lineup.

OpenAI's most capable GPT-6 model, built for the hardest end-to-end work: complex reasoning, coding, computer use, research and document creation.

OpenAI's cost-efficient high end of the GPT-6 series, built to power complex coding and agentic workflows, with reasoning effort configurable from none to max.

Google's Pro-tier Gemini model, a refinement of Gemini 3 Pro for complex problem-solving, software engineering and agentic workflows that need precise tool use.

Google's speech-to-text model: low-latency transcription in 85+ languages with code-switching, speaker diarization for up to 8 speakers, word-level timestamps and custom vocabulary.

Google's most intelligent Flash model, engineered for long-horizon software engineering, autonomous agents and complex enterprise workflows, with tunable thinking levels.

Google's flagship creative text-to-speech model: studio-grade voice fidelity, expressive delivery, regional accents, and voice design or replication, in 130+ languages.

Google's fast video model from the any-to-any Gemini Omni family: it generates 3–10 second clips up to 4K, with native audio, and edits them conversationally.

Anthropic's fastest, lowest-latency current model, with near-frontier intelligence; it uses manual extended thinking rather than adaptive thinking.

Anthropic's Opus model from July 2026, now legacy: succeeded by Opus 5.5 in September 2026. It remains available, with retirement no sooner than July 2027.

Anthropic's recommended default model and the first of the Claude 5.5 family, for long-running agentic coding and knowledge work. Anthropic says it performs at the level of Fable 5.1 on most work at lower cost.

Anthropic's balance of speed and intelligence: the next Sonnet generation, a drop-in upgrade for Sonnet 4.6, with adaptive thinking on by default.

DHH's opinionated Arch Linux and Hyprland setup — one install script that turns a fresh machine into a tiled, keyboard-driven, themed desktop with the developer tools already in place.

The specification for describing an HTTP API in a machine-readable document — paths, operations, parameters, request and response schemas, auth — from which docs, clients, servers and tests are generated. Formerly the Swagger specification; 3.1 aligns its schemas with JSON Schema.