Glossary

The CSS relational pseudo-class — .card:has(img), label:has(+ input:invalid), form:has(:focus-visible) — that selects an element by what it contains or what follows it; the “parent selector” CSS never had, and a way to style by state without a class that JavaScript would have had to add

An experiment that shows two variants of a page or feature to randomly split groups of users, and compares a chosen metric to learn which performs better

Accessibility, as a numeronym — a, eleven letters, y — the way the word is written in code, commit messages, issue labels and the names of tools (eslint-plugin-vuejs-accessibility is linted under a11y); the same discipline the long word names, abbreviated because it is typed so often

Answer engine optimization — shaping a page so that a search engine or a voice assistant can lift one passage from it as the direct answer, shown or spoken without a click: a featured snippet, a knowledge panel, a Siri reply

Artificial general intelligence: AI that matches or exceeds human ability across most cognitive tasks, rather than excelling at a narrow set

Artificial intelligence: the field of building computer systems that perform tasks associated with human intelligence, such as perceiving, reasoning, learning, using language and acting toward goals

The ARIA Authoring Practices Guide — the W3C's catalog of how to build accessible interface components, one pattern per component, each giving the roles and attributes to apply, the keyboard interaction to implement, and a working example

Application Programming Interface

Accessible Rich Internet Applications — the everyday name for the role and aria-* attributes that tell assistive technology what an element is, what state it is in and what it is called

Artificial superintelligence: a hypothetical AI that greatly exceeds the best human performance in virtually every domain, including science, strategy and social skill

The discipline of making a thing usable by people with disabilities — through assistive technology, keyboard, contrast, structure, and language — as a property of the thing, not an accommodation added to it

In GitHub Actions, a packaged, reusable step that a workflow invokes by name and version — actions/checkout@v4, pnpm/action-setup@v4 — as opposed to a run: line, which is just shell

An implementation of a Block for one platform flavor — vanilla, declarative, AEM as a Cloud Service — written against the published contract rather than ported from another adapter

Adobe's annual creativity conference, in person and online, where Creative Cloud and Firefly announcements are made

Adobe's annual digital-experience conference in Las Vegas, in person and online, covering Experience Cloud: AEM, analytics, customer journeys

A property of an object that suggests how it can be used: a button looks pressable, a handle looks pullable

A model running in a loop with tools — it reads, acts, observes the result, and decides the next step — rather than answering a single prompt

A finite, unambiguous procedure for turning an input into an output — sorting a list, finding a path, matching a pattern — judged by whether it is correct and by how its cost grows as the input grows

Measuring how a site or product is used — visits, pages, sources, events — and reading the measurements as evidence of behavior rather than as a scoreboard

Committing one logical change per commit: complete enough to build and pass on its own, small enough to describe in one subject line, and revertible without taking anything unrelated with it

In AEM, the instance where content is created — the one authors log into, with the editor, the dialogs, the workflows and the DAM — as distinct from the Publish instances that serve the public; everything an author does happens here and reaches the world only when it is activated

The set of decisions a content author can make about an Element, described independently of the interface that presents them

The element for a self-contained composition that would make sense on its own — a blog post, a news story, a product card, a comment, a forum entry, a glossary term — the unit that could be syndicated, listed, or read out of context, announced as an article to assistive technology

The element for content related to what is around it but separable from it — a sidebar, a pull quote, a related-links box, a table of contents beside an article — announced as a complementary landmark when it sits at the top level

The CSS property that gives a box a preferred width-to-height ratio — aspect-ratio: 16 / 9 — so that when one dimension is set the other follows, which is what an image placeholder, a video frame or a square avatar needs and what the padding-bottom percentage hack used to fake

Behavior-driven development — TDD with the tests written as examples of behavior in the language of the people who asked for it: Given a state, When an action, Then an outcome, agreed before the build and executable after it

Block, Element, Modifier — a CSS class-naming convention from Yandex in which a standalone component is a block (.card), a part of it is an element (.card__title), and a variation of either is a modifier (.card--featured, .card__title--large); flat specificity, no nesting, and the markup says what the CSS is for

The ordered list of everything a team might do next — features, bugs, stories, chores — kept by one owner who decides what is at the top

The Edge Delivery Services realization of a Component Contract — EDS's own nomenclature

CSS’s account of what an element occupies: a content box, padding around it, a border around that, and margin outside — with box-sizing deciding whether a declared width means the content alone (content-box, the default) or content plus padding and border (border-box, what every reset sets), and margins that collapse between vertical neighbors

In biopharma, a specific marketed medicine under its trade name — Skyrizi, Rinvoq, Humira — as distinct from its molecule, its indications, and the therapeutic area it sits in

In the Core (the Agentic DS direction), a brand-owned definition of selected overrides and approved choices, resolved with Core defaults into the values a supported channel adapter consumes

Object storage’s unit of organization — a flat, named container of objects (files plus metadata) addressed by key, reachable over HTTP, with no directories, no filesystem and no limit that a laptop would recognize; S3 is the API every other vendor speaks, and a bucket is where uploads go once a server has more than one instance

Behavior that differs from what was intended or promised — and the backlog item that records it, with the steps that reproduce it

A line of work remaining against time across a sprint — falling toward zero if the sprint is on track, flat or rising if it is not — read every day, not at the end

The element for a quotation set off from the text as its own block — someone else’s words, with an optional cite attribute for the source URL and, by convention, a <footer> or <cite> element inside or after it naming the author — as against <q> for a quotation inside a sentence

California's Consumer Privacy Act (2020, amended by the CPRA in 2023): residents may know what personal information a business holds, have it deleted, and opt out of its sale or sharing — an opt-out model, where GDPR is opt-in

Continuous delivery — every change that passes the pipeline is releasable, and shipping it is one button a human presses

Content delivery network — a fleet of servers placed near readers that serve a site’s static files, and often its cached pages, from the nearest one, so that distance to the origin stops being the latency; the edge is also where TLS terminates, where bots are stopped, and where a DDoS is absorbed

Continuous integration — every change is merged into the shared branch early and often, and every merge is proved by an automated run: build, tests, lint, and whatever else the branch is gated on

Cross-Origin Resource Sharing — the browser rule that a page on one origin (scheme, host and port) may not read a response from another unless that other server says so in a header; Access-Control-Allow-Origin is the server's consent, and the browser enforces it, not the server

Change Risk Anti-Patterns — Alberto Savoia's metric combining a method's cyclomatic complexity with how little of it the tests cover; high complexity with low coverage is the code most likely to break when changed

Cascading Style Sheets — the presentation language of the web: rules that select elements and declare how they look and lay out, resolved by a cascade that decides which declaration wins when several apply

CSS’s two-dimensional layout model — a container with display: grid declares rows and columns (grid-template-columns: 9rem minmax(0, 1fr)), and children are placed into the cells by line number, by name, or by flowing in order; the tool for any layout where things must line up in two directions at once

CSS for placing one element relative to another anywhere in the document — the target names an anchor (position-anchor: --trigger) and positions itself with anchor() values (top: anchor(bottom)), with position-try fallbacks that flip or shift it when it would leave the viewport — so tooltips, popovers and menus need no JavaScript to find their trigger

Values declared once on an element (--ui-radius: 0.5rem) and read anywhere below it with var(--ui-radius) — the cascade’s own variables, inherited, overridable per element or per data-theme, readable and writable from JavaScript, and the mechanism every design token on the web resolves through at runtime

A copy of a result kept closer to the asker than the source — in the browser, at the edge, in the server’s memory — so the next identical request is answered without doing the work again; every cache is a bet that the answer has not changed, and the rules for when to stop believing it (TTL, ETag, invalidation) are the whole design

A frozen copy of a page's markup and whatever stylesheets were reachable, with a URL and a date

A research method for information architecture in which participants group labeled cards, each a piece of content or a feature, into categories that make sense to them

A CSS feature — @layer base, components, utilities; — that groups rules into named layers with an explicit order, so that a rule in a later layer wins over any rule in an earlier one regardless of specificity; the way to make a reset lose to a component and a component lose to a utility without !important or selector arithmetic

A curated, chronological record of notable changes to a project, written for the people who use it: one section per version, newest first, each with its release date

An output surface a brand appears on — the web (EDS, AEM), email, banner and display advertising, interactive sales aids — each realized from the same Core by its own adapter, and each supporting only the slice of the library that makes sense there

The second of GTD’s five steps: taking each thing out of the inbox and deciding what it is — is it actionable? if not, trash, someday/maybe or reference; if so, what is the next action, and is it one step or a project?

The third, now-retired way to write a Vue component: as a TypeScript class with decorators — @Component, @Prop, @Watch from vue-class-component and vue-property-decorator — so that this.count was a class field and methods were class methods; the shape Vue 2 TypeScript projects and Vue CLI’s TypeScript preset produced between 2017 and 2020

Figma's mapping of one published component node to its code component — a real 1:1 link, not an inference — shared with Figma's MCP server so that reading a design or writing to the canvas references the governed component rather than a lookalike

The harness summarizing the older part of a context window to make room — what the agent keeps is the summary, not the material

The Core's record of what one reusable component is — its kind, variants, shape, scope-keyed props and states, constraints, detection hints, accessibility contract and Component Token Contract — independent of any brand or rendering technology

In the APG, a widget that contains navigable descendants and is one stop in the page's tab sequence — Tab reaches it, and the arrow keys move within it. A listbox, a menu, a radio group, a tab list, a tree, a grid

Vue 3’s way of writing a component as functions — ref, computed, watch, lifecycle hooks — inside <script setup>, so that related logic sits together and can be lifted out into a composable (useX()) and reused across components, instead of being split across the Options API’s data, computed, methods and watch buckets

Figma's annual conference, held in San Francisco at the Moscone Center, in person and online, where Figma announces new features

A hand-authored, line-by-line reading of one adapter against its contract — for every field in the record, what the adapter does about it, cited to file and line, re-read at each pin

A rule in a Component Schema relating two things nothing else connects, usually a prop and a field it restricts, with an authoring-time action (onViolation) and, where needed, a deterministic runtimeFallback

In the APG, the parent element that groups a set of related widgets or content and carries the role saying what the group is — the tablist holding tabs, the listbox holding options, the menu holding items

CSS rules that respond to the size of an element’s container rather than the viewport — container-type: inline-size on the parent, @container (min-width: 32rem) on the child’s styles — so that a component lays itself out by the space it is actually given, and the same card is one column in a sidebar and two in a main area without knowing which it is in

The authorable shape of a component's content — what an author fills in: a headline, a proof point, a CTA, an image, and how many of each — defined once and decoupled from where the content is stored or how any channel displays it

In GTD, the tool, place or person an action needs before it can be done — @computer, @phone, @errands, @home, @agenda-with-Sam — and the list that groups next actions by it, so that in any situation the list shows only what is possible there

The fixed amount of text a model can attend to at once — the whole conversation, the files it has read, the tool results — beyond which the earliest material falls out or is summarized

A specification for commit messages, type(scope): description, with an optional body and footers, that gives history a shape a machine can read: changelogs, semantic version bumps and release notes derived from the log

A small named value a server asks the browser to store and send back on every subsequent request to that origin — the mechanism that gives a stateless protocol a memory of who is asking

The single brand-agnostic, technology-silent source of truth that defines what every reusable piece of a design system is — its values, structure, content shape and approved compositions — without any brand's actual values or any platform's code

The captured production specimens a Component Contract's anatomy is counted against — each part carries how many of them it occurs in

Distributed denial of service — flooding a site with more requests than it can answer, from many sources at once so no single one can be blocked, until legitimate readers cannot get through; the distributed part is what makes it an infrastructure problem rather than a firewall rule

The Domain Name System — the distributed directory that turns a name a person can remember (uxlab.tools) into the address a network can route to, and the records beside it that say where a domain's mail goes, who may send it, and what a name is an alias for

Document Object Model — the live tree of objects a browser builds from a page's HTML, which scripts read and change and which the browser renders; the page as it is now, not as it was sent

The Design Tokens Community Group — the W3C community group whose Design Tokens specification (2025.10) is three modules: the Format Module, a JSON file format for tokens so that one written once can be read by every tool in the chain; the Color Module, the object a color token's value is; and the Resolver Module, how one set of tokens yields different values in different contexts — light and dark, a brand, a density

Developer experience — the user experience of the people who build with a thing: how long from clone to running, how the API reads, what an error says, how a change is tested and shipped, and how much of that a newcomer can work out alone

A way of arranging data in memory that makes some operations cheap and others expensive — an array, a linked list, a hash map, a set, a stack, a queue, a tree, a graph

The HTML list of name–value groups — <dl> holding pairs of <dt> (the term, or name) and <dd> (the description, or value) — for a glossary, a spec sheet, metadata, a FAQ, or any list where each item is a label and its content; renamed the description list in HTML5 because the pairs need not be definitions

Putting a built version of the software onto an environment where it runs — distinct from a release, which is the moment users can reach it

The HTML pair for a disclosure — <details> holds content that is hidden until opened, <summary> is the always-visible line that toggles it — with the open state, the keyboard handling (Enter and Space on the summary), the open attribute and the toggle event all provided by the browser; the disclosure pattern, and most of an accordion, with no script

Given the same input, always producing the same output — no dependence on time, randomness, ordering, or what else is running

Figma’s mode for the people who build what was designed — a file view that trades editing tools for inspection: measurements and spacing between any two nodes, the variables and styles a node actually resolves to, generated code for CSS, iOS and Android, a diff of what changed since the last look, and a section marked Ready for dev so a developer knows which frames are claims and which are sketches

The HTML element for a dialog box — <dialog> opened with .show() or, for a modal, .showModal(), which puts it in the top layer, makes everything behind it inert, traps focus, closes on Escape, and returns focus to the opener; a <form method=“dialog”> inside it closes it with a value

A personal website of notes that are published unfinished and tended over time, linked by topic rather than ordered by date

AEM’s caching and security layer — an Apache module in front of the Publish instances that caches rendered pages and assets on disk, filters which requests are allowed through at all, and balances the rest across the Publish farm; a page is rendered once and served from the dispatcher until an activation invalidates it

Writing the documentation first, the README, guide or usage example a person would read, and building what it describes, so the explanation is the spec and the proof that the thing can be adopted

The Design Council's picture of a design process as two diamonds: diverge to understand the problem, converge on the right one; then diverge on solutions, converge on the right one

Salesforce's annual conference, held each September at the Moscone Center in San Francisco and streamed on Salesforce+

Disagreement between a token's provenance sources — what production says, what the design file says, what was authored

Optional Component Schema data that a page scanner uses to find likely instances of the component on a page it knows nothing about: native elements, the ARIA pattern's required attributes with a minimum sibling cluster, and class or id keywords

The generic block-level container with no meaning of its own — a box to put a class, a style or a layout on when no semantic element applies — and therefore the element to reach for last, after <main>, <section>, <article>, <nav>, <aside>, <header>, <footer>, <figure>, <ul> and the rest have been ruled out

End-to-end — driving the built product the way a user does, in a real browser against a running server, and asserting on what the user would see

Work done in the CDN's points of presence rather than at the origin — caching, TLS termination, redirects, rewrites, bot filtering, A/B splits, authentication checks, and increasingly small functions that run at whichever location the reader reached

The platform-agnostic building block — semantic markup plus optional behavior, defined independently of any delivery platform

One addressable operation of an API — a URL plus a method, with a defined request and response

The fifth of GTD’s five steps: doing — choosing the next action to take from the lists, by context, time available, energy and priority, and taking it, trusting that everything not chosen is safely somewhere it will be seen again

Existing only for the duration of one use — an environment stood up for a pull request and torn down on merge, a container that keeps nothing between runs, state that lives in memory and dies with the process

A body of work too large for one sprint, held as one item until it is broken into stories — the container, not the deliverable

A company's live web properties as they exist today — the sites, their components, their stylesheets — as opposed to any design system's description of them

A function registered on a DOM node — or on window, document, a socket, an emitter — to run when a named event fires there: element.addEventListener('click', handler); the browser calls it with an event object, bubbling up from the target unless something stops it

The EU's 2002 directive on privacy in electronic communications, amended in 2009 to require consent before storing or reading anything on a person's device that is not strictly necessary — the "cookie law" that the banners come from

A capability a user can see and name — the thing a release note leads with — usually larger than a story and smaller than an epic

Figma’s Model Context Protocol server — a local or remote endpoint an AI coding agent connects to, which hands the agent the design context for a selected node (its structure, variables, styles, components, and the Code Connect mapping where one exists) and, in the other direction, lets the agent create and update nodes in a file

One problem, with a severity and a piece of evidence a reader can chase

CSS’s one-dimensional layout model — a container with display: flex lays its children out along one axis, distributing space (justify-content), aligning across the other (align-items), wrapping when told to, and letting each item declare how it grows and shrinks; the right tool for a row of things or a column of things

A diagram of a process as steps and decisions connected by arrows, the standard shapes being rectangles for steps, diamonds for decisions and ovals for start and end

Type that scales smoothly with the viewport or container instead of jumping at breakpoints — font-size: clamp(1rem, 0.9rem + 0.5vw, 1.25rem) — a minimum, a preferred value tied to a viewport or container unit, and a maximum, so that a heading is never too small on a phone or too large on a monitor and never changes size at an arbitrary width

The Web API that represents a form’s fields as a list of name–value pairs — new FormData(formElement) reads them all, .append() adds one, .entries() iterates — and that fetch sends as multipart/form-data, which is how a file upload reaches a server; on the server, readFormData(event) or readMultipartFormData(event) reads it back

The element for content that is referred to as a unit from the main flow — an image, a diagram, a code listing, a table, a poem — with an optional <figcaption> that names it, so that the caption is programmatically tied to what it captions and the figure can be moved (to an aside, a page’s end) without losing sense

The element for closing content — at the page level, the site footer with the copyright, legal links and colophon, which is the contentinfo landmark; inside an <article>, that piece’s tags, related links or author note, which is not a landmark

The element that groups controls into one submission — inputs, selects, buttons — with action and method for where and how it goes, a submit event the whole thing fires (Enter in a text field included), and a form landmark when it has an accessible name; the unit FormData reads and validation runs over

The EU's General Data Protection Regulation (2018): personal data may be processed only on a lawful basis, for a stated purpose, no longer than needed, with the person able to access, correct, export and erase it — and a breach reported within 72 hours

Generative engine optimization — making content findable, quotable and correctly attributed by AI assistants that answer questions directly instead of returning links: clear claims, stable URLs, structured data, permissive crawling, and being the source others cite

Getting Things Done

Generative AI: models that produce new content, such as text, code, images, audio and video, from patterns learned in their training data, in response to a prompt

The browser API — navigator.geolocation.getCurrentPosition(success, error, options) — that asks the user’s permission and returns their position (latitude, longitude, accuracy, and a timestamp), from GPS, Wi-Fi or the network, with watchPosition for updates and options for accuracy and age

A plain-language way of writing an example as a test: Given a situation, When something happens, Then the outcome — readable by the person who asked for the behavior and runnable by a tool like Cucumber

The particular approach an organization uses to keep its design system current, consistent, and adopted — who may change what, how a change is proposed and reviewed, and how drift from the system is found and corrected

Building for the most capable environment first, then making sure the experience falls back to something usable — not something broken — where a feature is missing

In design, the invisible structure a layout is composed on — columns and gutters (twelve is the convention), a baseline for type, margins — so that elements align to shared lines rather than to each other by eye, and a page reads as one system across breakpoints

Historically Black College or University: in law, a college or university established before 1964 whose principal mission was, and is, the education of Black Americans, and that is accredited (or making reasonable progress toward it)

HyperText Markup Language — the document language of the web: elements that say what a piece of content is (a heading, a list, a button, a form field), which the browser turns into a DOM, an accessibility tree and a default rendering before any CSS or JavaScript arrives

HyperText Transfer Protocol — the request–response protocol of the web: a client asks for a resource by URL with a method (GET, POST, PUT, DELETE…), and a server answers with a status code, headers and a body

The three-digit number an HTTP response opens with, saying how the request went: 2xx it worked, 3xx look elsewhere, 4xx you asked wrong (or may not), 5xx we failed — the first digit is the class a client can act on without knowing the rest

A confident, fluent statement by a model that is not true — a function that does not exist, a flag that was never there, a test result that was not run

The software around the model that turns it into an agent — the loop, the tools, the permissions, the context management — as distinct from the model itself

The element for introductory content — at the page level, the masthead with the logo, site name and primary navigation, which is the banner landmark; inside an <article> or <section>, that piece’s own heading group, byline and date, which is not a landmark at all

Internationalization — i, eighteen letters, n — designing a product so that it can be adapted to any language and region without changing the code: strings out of the templates and into message files, dates, numbers and plurals formatted by locale, layouts that survive text that is twice as long or reads right to left

The Internet Engineering Task Force — the open body that standardizes the internet's protocols below the page: HTTP, TLS, DNS, URLs and URIs, JSON, OAuth, WebSockets — as numbered RFCs, by rough consensus and running code

Bill Wake's six tests of a good user story — Independent, Negotiable, Valuable, Estimable, Small, Testable: it can be built in any order, its details are a conversation rather than a contract, it delivers something a user would notice, the team can size it, it fits in a sprint, and there is a way to know it is done

Important Safety Information — the safety text a pharmaceutical brand site is required to present, often as a persistent bar that expands

In GTD, the single place everything lands before it has been decided — a thought, an email, a ticket, a scrap — so that capturing costs nothing and deciding can wait

The specific condition a medicine is approved by a regulator to treat, in the exact population and use the label states — a drug is not approved in general, it is approved for an indication

Running a trained model to get an answer — as opposed to training, which produced the weights in the first place; the phase you pay for per request and wait for in real time

The structure of an information space: how content is organized, labeled, navigated and searched, so people can find what they need and understand where they are

Testing several units together through a real seam — a component with its composables, a route handler with the database, a page with its content query — so the test fails when the pieces disagree

The generic tracked item in a tool like GitHub or Jira — a bug, a feature, a task, a question — with a number, a title, a discussion and a state, open or closed

"Keep it simple, stupid" — the design principle that most systems work best when kept simple, so simplicity is a goal to design for and complexity something to justify, not the other way around

A way of managing work by making it visible on a board of columns — to do, doing, done — and limiting how much may sit in any column at once, so the team finishes before it starts

AWS Lambda — a single function deployed on its own, invoked by an event (an HTTP request, a queue message, a file landing in a bucket, a schedule), run in a container the platform creates and discards

The HTML elements that map to ARIA landmark roles and give a page its navigable regions — <main> (main), <nav> (navigation), <aside> (complementary), <header> (banner) and <footer> (contentinfo) at the top level, <form> (form) and <section> with a name (region) — so that a screen-reader user can jump between the parts of a page the way a sighted one scans them

The reusable page shell — where chrome (navigation, header, footer) and the content slot live; page- and content-agnostic

Static analysis for style and likely mistakes — unused variables, inconsistent formatting, patterns a team has decided against — run by a linter against rules the project chose

The element for one item of an ordered or unordered list — <li> inside <ul> or <ol>, and nowhere else — carrying its position in the list, its value in an ordered one, and any content at all: a line of text, a link, a card, a nested list

Spreading incoming requests across several identical servers — round-robin, least-connections, or by hash — so that no one of them is the limit and any one of them can be taken out for a deploy without readers noticing; the balancer is the one address the world knows, the instances behind it are interchangeable

A browser key-value store scoped to an origin, holding strings, surviving reloads and restarts, readable and writable only by JavaScript and never sent to the server — with sessionStorage as the same API scoped to one tab

CSS properties named by flow direction rather than physical side — margin-inline-start instead of margin-left, padding-block instead of padding-top and -bottom, inset-inline-end instead of right — so that a layout written once is correct in a right-to-left language or a vertical script without a mirrored stylesheet

A proposed schema file that holds the treatments and token contract shared by more than one component, with no kind, shape or states of its own; components name it instead of each repeating the same touchpoints

Model Context Protocol: a standard for exposing tools and resources to an agent from a separate process — a browser, a database, a design tool — so the harness need not know each one

Medical, Legal and Regulatory review — the committee sign-off every piece of pharmaceutical promotion goes through before it is seen by a doctor or a patient: medical checks the claims against the data, legal checks the exposure, regulatory checks the label and the rules, and nothing ships without all three

Small, single-purpose moments of feedback in an interface, such as a toggle sliding, a button confirming a tap or a field validating as you type, that tell the user something happened

An architecture that splits an application into small services, each owning its own data and deployed independently, communicating over the network — as against a monolith, which is one deployable unit

The smallest version of a product that lets a team learn, with real users, whether the idea is worth building out

In AI, a kind of data a model can take in or produce: text, code, images, audio, video, documents. A model that handles more than one is multimodal

The trained artifact itself — a set of weights that, given a sequence of tokens, produces a probability distribution over what comes next; the thing that reasons, as distinct from the harness that gives it tools and a loop

The usual ways AI models are grouped and compared: the job a vendor positions a model for, and the axes benchmark leaderboards rank them on

The shorthand for the CSS that arrived between about 2021 and 2025 and is now Baseline across browsers — container queries, cascade layers, :has(), subgrid, nesting, logical properties, relative color and color-mix(), clamp()-driven fluid type, the Popover API and <dialog>, scroll-driven animations, anchor positioning — the set that made most of a preprocessor and much of a component library’s JavaScript unnecessary

Deliberately breaking the code in small ways — flip a comparison, drop a branch, change a constant — and running the tests; a mutant that survives is a test suite that would not have noticed

The element for a page’s primary content — the part that is unique to this page, not the navigation, header or footer repeated on every page — exactly one visible per document, the target of a skip link, and the main landmark a screen reader jumps to first

National Provider Identifier — the 10-digit number US healthcare providers, individual and organizational, use to identify themselves in standard transactions; issued by CMS through NPPES and public in the NPI Registry

CMS's public lookup of every NPI — name, taxonomy (specialty), practice address, phone — searchable on the web and through a free JSON API with no key

In GTD, the single, physical, visible thing that has to happen next to move something forward — not the outcome, the next step toward it

The element for a block of navigation links — the site’s sidebar, a breadcrumb, a table of contents, pagination — announced as a navigation landmark, usually wrapping a <ul> so the links are also a counted list

The IETF's delegated-authorization framework (OAuth 2.0, RFC 6749; 2.1 in draft): a user grants an application limited access to their account at another service without handing over a password, and the application receives a scoped, expiring access token to act with

The property of a system whose internal state can be inferred from what it emits — logs, metrics, traces — well enough to answer a question nobody thought to ask when it was built

Vue’s original component shape — one object with data(), computed, methods, watch, props and the lifecycle hooks as named options — where the framework wires this so every option can reach every other; the way Vue 2 codebases are written and a way Vue 3 still supports in full

The HTML element for a list whose order matters — <ol> with <li> children — numbered by default, with start, reversed and type attributes for the numbering, and announced by a screen reader with each item’s position

The third of GTD’s five steps: putting each clarified thing where it belongs — a next action on its context list, a multi-step outcome on the projects list, a dated commitment on the calendar, a delegated one under waiting for, an idea under someday/maybe, and information in reference — so that the right list shows the right things at the right time

In the Core (the Agentic DS direction), the permission category for a change: configuration (within an existing contract, automated checks and one named reviewer), extension (changes the contract and needs governance review), or locked (no ordinary brand or agent override)

The CSS property that says how a replaced element — an <img>, a <video> — fits the box it is given when their ratios differ: cover fills the box and crops, contain shows all of it and letterboxes, fill stretches, none keeps the intrinsic size; object-position says which part to keep when cropping

Projects, Areas, Resources, Archives

The Prescription Drug User Fee Act — the 1992 US law, renewed every five years, under which drug companies pay the FDA a fee with each application and the FDA commits to review timelines in return; in everyday use, the PDUFA date is the day by which the agency has said it will decide on a drug

The UK's Privacy and Electronic Communications Regulations (2003): the ePrivacy Directive as enacted in Britain — consent for non-essential cookies and similar storage, rules for marketing email and SMS, enforced by the ICO

Personally identifiable information — any data that identifies a person on its own (a name, an email, an IP address, a device fingerprint) or in combination with other data; the thing every privacy law is about

A specific problem, frustration or friction a person hits while trying to get something done: the moment a product fails them

The learned weights a model is made of — the number quoted as 7B, 70B or 2.1 trillion, being how many of them there are

A governed composition of component contracts that solves a recurring problem — a FAQ section, a pricing comparison, a multi-step content display — carrying the ordering, layout and regulatory-sequencing rules a single contract cannot express

The harness setting that decides which of an agent's actions run unasked, which prompt a person, and which are refused outright

A fictional but research-based profile of a type of user, with goals, context, behaviors and frustrations, used to keep design decisions anchored to someone specific

The commit a downstream repository names as the version of a source it read, kept beside the date it was read; a count or a citation is against a pin, not against a checkout

The ordered stages a change passes through between a push and production — typically install, build, test, lint, security scan, quality gate, deploy — each one able to stop the change

The HTML attribute and DOM API — popover on an element, popovertarget on a button, showPopover() / hidePopover() — that makes any element a light-dismissable overlay in the browser’s top layer, with the open-and-close, the Escape key, the click-outside and the focus behavior handled by the platform

A count committed before the thing it counts exists — what an adapter will cost in files, lifecycle entry points and authored-row columns — so that the order is checkable in git log rather than asserted

The whole of bringing a product from a problem worth solving to something people use and keep using — discovery, definition, design, build, release, and the measuring that starts the loop again — as one continuous practice rather than a hand-off between departments

Building a page in layers — meaningful HTML first, then CSS, then JavaScript — so that each layer improves the experience for the browsers that can use it and none is required for the page to work

The practice of getting a defined outcome delivered — scope, schedule, people, risk — through whatever method the organization uses, from a Gantt chart to a kanban board

To close a gap in the semantic layer by adding an intent-named token available to every contract, rather than a value named for the one place that needed it

One investigation with a question, an outcome, its metrics and dates, recorded so it can be cited instead of reconstructed

A configuration value of a Component Schema, drawn from a small set the design system defines or a boolean, and keyed by scope: props.component for one value per instance, props.item for one value per repeated item

A working model of a design, from clickable screens to throwaway code, built to answer a question or test an idea with people before committing to build it

In AEM, the instances that serve the public site — read-only copies of the content Author has activated to them, usually several behind a dispatcher, holding no editor and no authors; activating a page is the act that replicates it from Author to Publish

A buffer of work to be done later, in order, by someone else — a request writes a job and returns; a worker takes the job when it can; the queue holds what is between them and survives either side being slow or down. Retries, dead letters and idempotent jobs are where the design goes

Responsible, Accountable, Consulted, Informed

Representational State Transfer — Fielding's architectural style for the web: resources named by URLs, manipulated through a fixed set of verbs, with the server keeping no client state between requests

Recursive self-improvement: an AI system improving its own capabilities, including its ability to improve itself, so that each generation builds a better successor

The three-step loop of TDD: write a test that fails (red), write the least code that makes it pass (green), then improve the code without changing its behavior while the test keeps it honest (refactor) — and go around again

In GTD, information that is not actionable but worth keeping — a manual, a receipt, an article, a decision — filed so it can be found when a future action needs it, and never on an action list

The ongoing work of making the top of the backlog ready — splitting, clarifying, estimating and ordering items before a sprint starts

The fourth of GTD’s five steps: looking at the whole system often enough to trust it — the calendar and next-action lists daily, everything in the weekly review — so that what is on the lists is current and what is in the head can be let go

An ordering rule a regulated market imposes on a page — a disclosure that must render directly beneath a pricing block, safety information that must follow a claim — expressed in a pattern as structure, not left to brand discretion or a reviewer's memory

CSS syntax for deriving one color from another — oklch(from var(--color-primary-500) calc(l + 0.1) c h) — by unpacking a color into its channels in a chosen space and rewriting any of them; the way to say “this color, but lighter” or “this hue at 40% alpha” without a second token

An Atlanta tech conference, billed as "The South's tech conference", founded in 2019 by engineer and entrepreneur Justin E. Samuels

The meeting at the end of a sprint about the sprint itself — what went well, what did not, and one or two things the team will change next time

A data attribute named after a component's id and carried on its root element, such as data-accordion or data-button, so that selectors and identifiers can be scoped to one component and never reach another nested inside it

Security Assertion Markup Language — the XML standard (OASIS, 2.0 since 2005) for single sign-on between an identity provider and a service provider: the provider signs an assertion saying who the user is and what attributes they carry, the browser posts it to the application, and the application verifies the signature and starts a session

Software Development Kit — the library, types, and tooling a vendor ships so a developer can use its platform in a language rather than over raw HTTP

Search engine optimization — making a page understandable and worth ranking to a search engine: a title and description that say what it is, one canonical URL, structured markup, fast rendering, and links from pages that matter

A third-party attestation (AICPA) that a service provider's controls over security, availability, processing integrity, confidentiality and privacy are designed — Type I — and operating over a period — Type II — as described

Five object-oriented design principles collected under one acronym by Robert C. Martin: Single responsibility, Open–closed, Liskov substitution, Interface segregation, Dependency inversion — a module should have one reason to change, be extended without being edited, honor the contract of what it replaces, expose only what a caller needs, and depend on abstractions rather than details

Secure Sockets Layer — the name everyone still uses for TLS (Transport Layer Security), the protocol that encrypts the connection between a browser and a server and proves, with a certificate signed by an authority the browser trusts, that the server is the one the name says; HTTPS is HTTP over it

Single sign-on — signing in once, with one identity provider, and being signed in to every application that trusts that provider; the application never sees a password, only an assertion from the provider that this person is who they say

The boundary around what an agent's commands may read, write and reach — a directory, a network allowlist, a set of credentials — enforced outside the model

CSS animations whose progress is driven by scrolling rather than by time — animation-timeline: scroll() ties the animation to a scroll container’s position, animation-timeline: view() to an element’s progress through the viewport — so a reading-progress bar, a parallax layer or a reveal-on-scroll needs no scroll listener and runs off the main thread

The person on a Scrum team who owns the process rather than the product or the code — runs the ceremonies, removes what blocks the team, and keeps the practice honest

Tiago Forte's name for an external, digital system for what you know — captured, organized, distilled, and expressed — so that memory is not the bottleneck

A diagram of how participants, such as a user, services or components, exchange messages over time, with each participant a vertical lifeline and each message an arrow in order

A hosting model where you deploy a function or a container rather than a server, the platform starts an instance when a request arrives and stops it when traffic stops, and you are billed for execution rather than for uptime

One continuous run of an agent against a task, from the first message to the point its context ends — the unit that handoffs bridge

The section of a Component Schema that declares a component's authored content: its fields, their order, what repeats, and which fields can hold other components

An alternative to the minimum viable product: the first release should be simple (small in scope), lovable (people want to use it) and complete (it does its one job fully, rather than being a partial version of something bigger)

A category of position a Template offers — header, hero, rich text, footer — as distinct from an instance, which is one occurrence of it on a page

Writing a structured specification (requirements, acceptance criteria, constraints) before implementation, and treating it as the source of truth that code, tests and AI coding agents work from

Frozen markup captured from a real AEM realization, kept as evidence — a control that generated CSS is checked against

A fixed, short timebox — one to four weeks — in which a team commits to a set of backlog items and ends with something reviewable

The meeting at the end of a sprint where the team shows what it finished, working, to the people who asked for it — and hears what they think

Anyone with a stake in a piece of work's outcome — who can be affected by it, block it, or be asked about it — whether or not they are doing it

A template repository cloned or forked as a project's starting point

The data a user interface is a function of at any moment — what is selected, open, loading, entered, fetched — and, in a front-end framework, the question of where each piece lives: in one component, lifted to a parent, or in a store (Vuex, Pinia) that any component can read and change

A model of behavior as a finite set of states, where the system is in exactly one state at a time and events trigger transitions between them

Stateless — every request carries everything needed to serve it, and the server keeps nothing about the caller between requests; HTTP is stateless by design, which is why a cookie or a token has to be sent again each time

Examining source code without running it — for type errors, unreachable branches, style violations, known-unsafe patterns — by tools that read the program as data

A backlog item written from the user's side — who wants what, and why — small enough to finish in a sprint and to say whether it is done

A way of replacing a legacy system without a rewrite: put a facade in front of it, route one capability at a time to a new implementation behind the same facade, and retire the old system when nothing routes to it any more

The other half of container queries: @container style(--variant: compact) applies styles when the container’s custom property has a given value, so a component can restyle its children by a token its parent sets, without a class on every child

A one-board design deliverable — headline and body type, a palette, a button, a link, a texture, a few adjectives — that establishes what a site will feel like before any page is laid out; more specific than a moodboard, less committed than a comp

A CSS Grid feature — grid-template-columns: subgrid (or rows) on a child that is itself a grid — that makes the child use its parent’s tracks instead of its own, so that nested content aligns to the outer grid: every card in a row puts its title, body and footer on the same lines as its neighbors

The element for a thematic grouping of content with a heading — a chapter of a page, one group of a catalog, a step of a form — which becomes a region landmark only when it has an accessible name (aria-labelledby pointing at its heading) and is otherwise just a <div> that means something

The generic inline container with no meaning of its own — the <div> of text — for styling or hooking a run of characters inside a line when no semantic inline element (<em>, <strong>, <code>, <time>, <abbr>, <a>) says what it is

The allowlist on a composable field naming which stateful components (a widget or a composite) may nest inside it, alongside maxNestingDepth, a depth budget counted through containers

Ecma International's Technical Committee 39 — the committee that specifies JavaScript, as ECMAScript (ECMA-262), through a staged proposal process where a feature advances from an idea (stage 0) to shipping in engines (stage 4) and a yearly edition of the language

Test-driven development — writing the test before the code it tests, watching it fail, writing the least code that makes it pass, then cleaning up with the test as a safety net; the red–green–refactor loop, repeated in small steps

The HTML element for two-dimensional data — rows and columns with a header row (<thead>, <th scope=“col”>), a body, and often a caption — which a screen reader navigates cell by cell announcing the headers, and which is the right element for data and the wrong one for layout

The smallest unit of work on a board — a thing one person does in a sitting or a day, usually a piece of a story — tracked to completion rather than estimated

A reusable page-type composition — which Component Contracts or Elements go where for a kind of page — rendered inside a Layout

Mike Cohn's shape for a test suite — many unit tests at the base, fewer integration tests, a handful of end-to-end tests at the point

Kent C. Dodds' shape for a test suite — static analysis at the base, a thin band of unit tests, a wide band of integration tests, and a small cap of end-to-end tests

The collective name for the nine historically Black Greek-letter fraternities and sororities that make up the National Pan-Hellenic Council, founded between 1906 and 1963

A complete set of values applied to a whole surface at once — every token, for every component — so that the same markup reads as a different place: this site's nine (System, Lyra, Nord, Dracula, Catppuccin, Carnival, Reef, Broadsheet, Manifest), each a CSS file keyed by data-theme

The broad field of medicine a brand or indication belongs to — immunology, oncology, neuroscience, eye care, virology — and the axis a pharmaceutical company organizes its commercial and medical teams along

In GTD, a date-based holding place for things you do not want to see until a particular day — a reminder, a document, a ticket to re-check — physically 43 folders (31 days and 12 months), digitally a dated deferral that surfaces the item on the day

A function an agent can call — read a file, run a command, fetch a page, drive a browser — and whose result comes back into its context as text

A purely stylistic way of rendering one component — a primary against a secondary button, or two differently styled accordions — with the same content model, the same props and states, the same behavior and the same accessibility pattern; only the values differ, and they resolve through the component's token contract

Static analysis that verifies every value is used in a way its declared type allows — a string is not passed where a number is expected, a property that may be absent is not read as if present

JavaScript with a static type system layered on — types are written in the source, checked by a compiler, and erased in the output

User Interface

Unified Modeling Language: a standard visual notation for modeling software, with structure diagrams such as class and component diagrams, and behavior diagrams such as sequence, state and activity

User Experience

Peter Morville's seven facets of a worthwhile user experience, drawn as cells: useful, usable, desirable, findable, accessible, credible — and, at the center, valuable

Present everywhere — a language, a runtime, a pattern that can be assumed on any platform without checking

Testing one unit — a function, a class, a component — in isolation from the rest of the system, with its collaborators replaced or absent

The HTML element for a list whose order does not matter — <ul> with <li> children — announced by a screen reader as a list with its count, styled with bullets by default and with nothing at all when a nav or a card row needs the semantics without the marks

How well a specific person can use a thing to reach a specific goal — effectively, efficiently, and without regret — measured by watching them try

A visualization of the steps a person goes through to reach a goal with a product or service, along with what they do, think and feel at each stage

A genuine fork in a component's content model, props, states or behavior that still satisfies the same accessibility pattern — a different supported content shape may be a variant; populating an existing optional preview field is not; one that only looks different is a treatment

How much backlog a team finishes per sprint, in whatever unit it estimates in — points, stories, items — averaged over recent sprints

The World Wide Web Consortium — the standards body Tim Berners-Lee founded in 1994 that publishes the web's specifications for CSS, the accessibility guidelines (WCAG) and WAI-ARIA, SVG, and much of the rest, through working groups whose documents advance to Recommendation

Accessible Rich Internet Applications, from the W3C's Web Accessibility Initiative — a set of attributes (role, aria-label, aria-expanded, aria-live…) that tell assistive technology what a piece of interface is, what state it is in and what it is called, when the HTML alone cannot

In GTD, the list of things you have handed to someone else and still care about — a request sent, a task delegated, an order placed — each with who and when, so that the follow-up is a next action of yours and not a worry

The open specifications — HTML, CSS, DOM, HTTP, ECMAScript, WAI-ARIA and the rest — that browsers implement in common, maintained by the W3C, WHATWG, IETF and TC39, so that a page written to them works in any conforming browser without being written for one

The Web Model Context Protocol — a browser API, navigator.modelContext, through which a web page declares the things it can do as named, typed tools (find a flight, add to cart, file a ticket) so that an agent driving the browser calls them directly instead of reading the screen and guessing where to click

A long-lived, two-way connection between a browser and a server, opened by an HTTP upgrade and then free of HTTP’s request-and-response shape — either side sends a message whenever it has one, which is what a live scoreboard, a chat, or a collaborative cursor needs and what polling only imitates

In GTD, the standing appointment — once a week, an hour or two — where every inbox is emptied, every project is checked for a next action, the calendar is read two weeks back and two forward, and the someday/maybe list is looked at; the habit that keeps the rest of the system trustworthy

In the APG, an interactive interface building block a person operates to do something or move through content — a button, a combobox, a slider, a tab list

A low-fidelity layout of a screen: structure, hierarchy and content placement, without visual design, so layout can be discussed before color and type distract from it

A unit of execution that runs beside the main one and takes work off it — in the browser, a Web Worker or Service Worker on its own thread; on the server, a process that consumes jobs from a queue so the request that enqueued them can answer at once; at the edge, a function that runs on every request (Cloudflare Workers)

Web Workers: a browser API that runs a script on a background thread, off the main thread, with no access to the DOM

"You aren't gonna need it" — the Extreme Programming rule against building for a requirement that has not arrived: implement what the current story needs, and add the generalization when a second case actually appears