Glossary
The terms in Kevin’s messages, the skills and the code, each defined in a sentence or two with where it lives.
This glossary defines the terms that appear in Kevin Liu's messages, in the General Translation (GT) skills and in the code of gt-cloud and Prototemplate. Each entry defines its term in one to three sentences and names the file, skill or document that owns it. The owner holds the full rule, so where the two disagree the owner is right and this page needs a fix. The vocabulary covers 2026-07-20 to 2026-10-05, and the retired terms in the last section point to decisions.md.
Paths without a prefix are in a Prototemplate checkout. A path marked gt-cloud: is in gt-cloud, gt: marks one in the open-source gt repository and content: one in the content repository.
Company and products
| Term | Meaning | Where it lives |
|---|---|---|
| General Translation (GT) | General Translation, Inc. builds the full stack for localization: open-source i18n libraries, context-aware translation APIs, a platform for review and delivery, and the Locadex agent. GT is the short form and the mark. | BRAND.md sections 1 and 2; gt-product-map.md section 1 |
| gt (the libraries) | GT publishes its open-source i18n libraries from one public monorepo. On npm the package named gt is the CLI, and generaltranslation is the core library the others build on. | gt:packages/; BRAND.md section 1 |
| gt-next and its siblings | These framework packages render translations and format locale-sensitive values in an app: gt-next, gt-react, gt-tanstack-start, gt-react-native, gt-vue and gt-node, with gt-flask and gt-fastapi for Python. gt-cloud's own apps translate their UI with gt-next. | gt:packages/next and its neighbours; the Python SDKs in generaltranslation/gt-python; gt-product-map.md section 3 |
<T> | The <T> component marks a block of JSX for translation. Wrap the largest static block once, never nest it, pass dynamic parts through Var, Num, Currency, DateTime, Plural and Branch, and guide one block with its context prop. | gt-components references/react.md; gt-cloud CLAUDE.md |
gt() | The gt() function translates a string. It covers the user-facing props that <T> does not reach, such as a placeholder, a title or an aria-label. | gt-components references/react.md |
msg() | The msg() function marks the strings of a data array where the array is declared. The component that renders the array reads them through useMessages() or getMessages(). | gt-components references/react.md |
useGT | The client hook returns the gt function itself, so the line is always const gt = useGT(); and never const { gt } = useGT(). | gt-cloud CLAUDE.md |
getGT | Async server components and generateMetadata get the function with const gt = await getGT();, imported from gt-next/server. | gt-cloud CLAUDE.md |
| The gt CLI | The CLI signs in with gt login through GT's sign-in page in the browser, and gt translate translates a project after a --dry-run. Because gt init and gt configure wait on interactive prompts with no timeout, an agent passes --no-interactive and a flag for every question. | gt:packages/cli; gt-product-map.md section 7 |
| Locadex | Locadex is GT's hosted AI agent. It internationalizes a codebase, generates translations, opens pull requests and keeps the app localized afterwards. Its name is never translated, and drawings seat its real mark as an alpha mask (the gt-ui rule no-gif-mark refuses a gif). | gt-cloud:apps/locadex, public/brand/locadex-mark.svg; gt-brand; gt-product-map.md section 3 |
| Context Group | A Context Group is a reusable collection of translation context kept at the organization level: a Glossary and the style prompts. A project applies groups in priority order, and context then narrows from the organization to the project to the component (<T context="...">). | gt-cloud:apps/dashboard, route org/[orgId]/context/[groupId]; gt-product-map.md section 4 |
| Glossary | The Glossary is the terminology half of a Context Group. It lists product and brand names, feature names, technical terms and phrases that stay untranslated, and its standing example is that Locadex is never translated. | the group's glossary route; gt-product-map.md section 4 |
| Directives | Directives was Kevin's July name for the style half of a Context Group: tone, audience, formality, conventions and formatting. The dashboard, the API and the pricing page call it Custom Prompts, copy uses that name, and the code keeps directives (DirectivesEditor). | the group's custom-prompts route; gt-product-map.md section 4 |
| The dashboard | The dashboard is GT's product app at dash.generaltranslation.com. It holds projects, Context Groups, the translation editor, review, billing, and the sign-in and onboarding pages on the plate frame, and its product surfaces are judged against the brand deck. | gt-cloud:apps/dashboard; gt-cloud .agents/skills/gt-dashboard; gt-aesthetic section 1 |
| The translation CDN | The translation CDN is an edge service on Cloudflare Workers that serves translations. Through it a team pushes translation updates over the air without redeploying its app. | gt-cloud:apps/edge; gt-product-map.md section 3 |
| Setup for Agents | Setup for Agents is the second button in the landing hero (gt-cloud #5049). It copies the start prompt that takes a coding agent from an empty project to a first translation, and every change to the prompt, the CLI or the quickstarts is proven by handing the prompt unchanged to a fresh agent on a fresh app. | content:docs/en-US/overview/for-coding-agents.mdx, served at /agent-prompt.md; gt-website section 6 |
| The report card | The report card is a public page that grades how localized any site is on six checks: hreflang, language declaration, routing, metadata, content and charset. Prototemplate's copy is the /report-card page of the shipped site. | generaltranslation.com/report-card (gt-cloud:apps/landing/src/app/[locale]/(home)/report-card, apps/landing/src/lib/report-card/); /d/production/report-card, src/components/try/, src/lib/try/ |
Repositories and places
| Term | Meaning | Where it lives |
|---|---|---|
| gt-cloud | The gt-cloud repository is GT's private product monorepo on turbo and pnpm. It holds the dashboard, the landing site with the docs and blog, the API, workers, the AI proxy, the edge CDN, Locadex, the admin app and the shared packages, and it squash-merges small PRs from k/<topic> branches once three required checks pass and the review bots are answered. | github.com/generaltranslation/gt-cloud; gt-cloud AGENTS.md; gt-ship section 5 |
| The gt repository | The public monorepo generaltranslation/gt holds the CLI, the JavaScript libraries, the core library, the compiler and the MCP server. CLI changes such as the login callback page land there. | github.com/generaltranslation/gt; gt-product-map.md section 8 |
| The content repo | The public generaltranslation/content repository holds the docs, blog posts and authors, and gt-cloud mounts it as the apps/landing/content submodule. Every landing deploy checks out the tip of content main, so merging a content PR publishes it, and when a post needs new components, images or redirects the gt-cloud side merges first. | gt-website sections 4 and 5; gt-product-map.md section 8 |
| Prototemplate | Prototemplate is Kevin's public hub and wiki for GT work. Its Next.js site, served at www.prototemplate.com, prototemplate.vercel.app and prototemplate.kevinliu.studio, holds the brand book, the design canon, the deck, the design lab, the marks, the films, the graphics, the skills and this handbook. Its main holds the primary copy of the canon, all rights are reserved to General Translation, and its dev server runs on localhost:3005. | github.com/Kevin-Liu-01/Prototemplate; prototemplate section 1 |
| The deck | The deck is the GT brand deck: 93 slides built from deck/ into one self-contained viewer that /deck frames. It is the reference for every product surface, and the Prototemplate viewer shell was modeled on its viewer (2026-09-08). | deck/, deck/DECK-GRAMMAR.md, pnpm build:deck; gt-deck |
| The Dossier | The Dossier (singularity-dossier) is the direction the shipped GT site grew from, and it stays in the gallery. Kevin called it complete on 2026-08-06 ("dossier is indeed our completed version and treat it as such"), and it was the reference for every marketing page until 2026-10-07, when he ruled "fix the dossier references". Since then the shipped generaltranslation.com has been the site's reference (decisions.md). | /d/singularity-dossier and its /enterprise; BRAND.md section 8; gt-aesthetic section 1 |
| Toolchain | Toolchain is the direction that served as the single source of truth for the forks from July. It set one ruled column, bento rows, isometric line diagrams and the tc-* vocabulary that the gt-cloud landing engine still uses, and its enterprise and pricing pages are literal specs, copy included. | src/app/d/toolchain/, /d/toolchain; ARCHITECTURE.md "The SSOT rule" |
| A direction | A direction is one exploration of the GT site's design, served at /d/<slug> and registered in DIRECTIONS, where four entries are full sites (the Dossier, Orbit, Signal and production). In July and August Kevin named directions by their label numbers, and the labels were renumbered more than once (Toolchain was 10 then and is 01 now). | src/lib/directions.ts; /directions/<slug>; retired ones at /archive/<slug>; gt-explorations section 3 |
| A fork | A fork is a direction built on Toolchain's sections and diagrams, imported directly and re-skinned through its own root class (.lensgate-root, .terminusboard-root). Fork work never edits Toolchain's files, and a forked session is a different thing, defined under Working terms. | ARCHITECTURE.md "The SSOT rule" |
| The presenter | The presenter at /present is a full-screen tool built on 2026-07-30 to review the directions. It runs an intro, the case for the redesign, a craft gallery, a live viewer of the first 16 prototypes and a scoreboard. | src/app/present/ |
| /d/production | This route rebuilds the shipped generaltranslation.com page for page in Prototemplate, with the dashboard's sign-in, onboarding, consent, device and CLI pages and their draggable state console (?state=<id> opens a state). Review galleries that Kevin asks for live here, outside gt-cloud PRs. | src/app/d/production/, src/components/plate/; gt-ship section 3 |
| /dev/states | The dashboard's /dev/states route is a development-only gallery of every sign-in and onboarding state. It stays on its own gt-cloud branch and never ships in a PR (2026-10-01). | gt-cloud's own gt-dashboard skill |
| The review server | The review server is the running dev server Kevin reviews a branch on. The landing's pnpm dev serves localhost:3001 and Prototemplate serves localhost:3005, each extra worktree takes a port of its own, and the session keeps the server up and says which branch and commit it serves. | gt-local-dev section 1; gt-website section 2; prototemplate section 7 |
| motion/ | The motion/ folder in Kevin's Prototemplate checkout is untracked, and the Videos session builds the films there with HyperFrames from the brief motion/MOTION.md. Other sessions read it and never stage, edit or delete it, and the published copies live in public/media/ and on /motion. | gt-films section 1 |
| The scratchpad | The scratchpad is the temporary folder Claude Code gives each session for specs, context files, harnesses and recorded fixtures. Nothing in it reaches a PR, and its files can vanish at the desktop app's date change, so durable work goes into a repository. | gt-ship section 3; gt-local-dev section 6 |
Design vocabulary
| Term | Meaning | Where it lives |
|---|---|---|
| Rail | A rail is the single hairline on each side of the page column, drawn once by the column wrapper (.tc-rail with border-inline: 1px solid var(--tc-hair)). Since 2026-09-28 a column has one rail on each side, and the single-rail lint holds it. | DESIGN.md section 3; gt-landing-pages "Rail and bands" |
| Band | A band is a horizontal section of a landing page. A band inside the column (.tc-sec) draws only its bottom rule, and a full-bleed band (.tc-band.tcb, .v0-dep) spans the viewport and draws its own rail pair once, at the column edges. | gt-landing-pages "Rail and bands" |
| Hatch spacer | A hatch spacer is a strip 28 to 40px tall with a hairline on each edge over a 45 degree hatch. It separates home bands (.v0-hatch) and rows inside a section (.tc-hatch), and it owns both of its edges, so the section before it drops its bottom rule. | gt-landing-pages "Hatch spacers"; DESIGN.md section 2 "Sanctioned devices" gives the shell's version, the book page's band (.pt-book-band), which also draws its own rule on both edges (2026-10-06) |
| Seam | A seam is the 1px line where two rows, cells or sections meet, formed by the row's hairline ground showing through a 1px gap. DESIGN.md section 10 also calls the slide-to-reveal handle the seam (RevealSeam, --seam-cut). | DESIGN.md sections 2 and 10 |
| The row owns every seam | This ownership rule for grids says that the row draws every structural line between its cells, cells draw no borders, and a framed cell shows the row's ground through a 1px padding reveal. Where a row meets a line that already exists, the cell sits flush and drops that side's reveal. | DESIGN.md section 2 "Ownership"; gt-landing-pages "The row owns every seam" |
| BentoRow and BentoCell | These two grid primitives implement that rule. The row is a grid with gap-px over the --tc-hair ground (props cols, eqHeads and headH), and the cell has no border props (framed adds the reveal). | gt-cloud:apps/landing/src/components/landing/shell/Bento.tsx, src/components/shell/Bento.tsx; gt-components |
| Registration cross | A registration cross is a small 1px plus seated exactly where two real hairlines cross. Kevin calls them corner crosses and DESIGN.md calls them border crosses, each landing section seam paints one at both rail corners, and a cross floating in app UI is ornament (2026-09-25). | DESIGN.md section 2 "Sanctioned devices"; gt-landing-pages "Registration crosses"; gt-aesthetic section 3 |
| The doubled line | The doubled line is GT's connector. One SVG path is stroked twice, a full ink stroke under a narrower stroke in the surface color, which leaves two parallel hairlines at a constant gap. It is the one sanctioned double line, also called the thread, and the GT mark draws every stroke in this grammar. | DESIGN.md section 5; src/components/shared/diagrams/DoubledLine.tsx; gt-diagrams |
| The plate | The plate is the dashboard's auth frame for the sign-in, consent, device, CLI and onboarding pages, with the form column on the left up to --plate-edge and the dithered field on the right. Elsewhere a plate is the one second surface under diagrams (--pt-plate), a layer of an isometric stack, or one of the speed marks. | gt-cloud:apps/dashboard/src/components/frame/PlateFrame.tsx, src/components/brand/FieldStack.tsx and src/app/brand-tokens.css there; the port in src/components/plate/ |
| Hairline roles | The three line weights each have one job. The hair weight (ink at 18% in light) draws large surfaces and the lines that divide a page, hair-soft (ink at 9%) draws list rows, and edge (ink at 62%) frames a picture or a capture, so a large surface drawn in the edge weight reads as a boxed image. | DESIGN.md section 2 "Line law for chrome"; src/components/viewer/tokens.css |
| The book page | Every Prototemplate page with a book head renders one structure: the page's plain name as the title with nothing drawn above it, a lead of one to three lines, the panel (Updated, then the page's facts), one rule, an optional note and contents, one hatch band, then sections opened by a Section n divider. A page differs from another only in its words and its facts. | DESIGN.md section 4, The book page; BookHead in src/components/viewer/BookView.tsx; pnpm lint:heads |
| Rounded controls, square shells | Prototemplate's corner law: the shells that hold the interface (the frame, the sidebar, the toolbar bar, the sheet, rules and bands) are square, and everything a reader presses, types into or picks up is rounded: controls at 6px, a part inside one at 5px, chips at 4px, cards and popovers at 6px. | DESIGN.md section 2, Corners; the radius tokens in src/components/viewer/tokens.css; pnpm lint:radius |
| Ink | Ink is #070707, the darkest of the four absolute colors, used for content text on paper and as the ground of the dark theme. Raised ink (#101010) is the one dark artifact surface for code, config and diffs. | DESIGN.md section 1; src/app/globals.css |
| Ink-2 | Ink-2 is the second text step, for secondary text and leads (--pt-ink-2, #3a3d44 in light). On a light surface, text a reader needs is set in ink-2 wherever titanium would fail contrast. | gt-aesthetic section 3; src/components/viewer/tokens.css |
| Titanium | Titanium is #8a8f98, the third and last text step, for captions, counters and keys. It measures 3.25:1 on white, so the dashboard plate darkens it to #6e737c for its 13px captions. | DESIGN.md section 1; gt-aesthetic section 3 |
| Paper | Paper is #ffffff, the light ground. Dark mode is a token remap in which paper collapses onto ink, so each theme has one surface. | DESIGN.md section 1 |
| GT blue | GT blue is the one accent, #2f5ce0, lifted to #86a8ff on dark bands. It marks actions, hover, highlights and icons while text and underlines stay ink, and a drawing gives it to one element. | DESIGN.md section 1; BRAND.md section 5; gt-aesthetic section 3 |
| The mobile type ladder | The mobile type ladder is the set of --tcm-* tokens that set type and spacing under 720px, declared in the engine's last 720px block and read as var(--tcm-X, <px fallback>). The mobile cut in v0-pages.css outranks the engine on the sgdh-root pages, so a change to the ladder is made in both places. | DESIGN.md section 12 |
| The svh and dvh law | On a mobile stage, whatever must reach the true screen bottom sizes from 100dvh, and every height that takes part in layout uses 100svh. A layout height in dvh grows the document each time the URL bar shows or hides. | DESIGN.md section 13 |
| Read lines | The read lines are the two scroll anchors of a scroll story. A beat locks in when its copy block's center crosses the read line at 55% of the viewport, and its copy lights as it rises through the highlight line at 80%. | DESIGN.md section 14; src/app/d/_v0/sections/FullStack.tsx |
| The moving type law | The moving type law governs a word that morphs between languages. The word is one shaped text node with lang and dir, its width is measured from a hidden probe and is the only layout property that animates, and the host drives one clock per page. | DESIGN.md section 8; src/components/shared/EverySentence.tsx; gt-motion section 5 |
| Box-air | Box-air is the mobile standard for boxed cells: block padding of 36 and 38px (--tcm-box-pt, --tcm-box-pb), 28px (--tcm-box-gap) between a box's head and its artifact, and no copy within 20px of a hairline. | DESIGN.md section 12 "The box-air standard" |
Material and motion
| Term | Meaning | Where it lives |
|---|---|---|
| Bayer dither | Bayer dither is ordered dither through a 4x4 or 8x8 Bayer threshold matrix, and it is the brand's only texture. A tone ramp prints as whole square cells in one ink, and alpha veils, smooth gradients and error diffusion are refused. | DESIGN.md section 7; src/lib/dither.ts; gt-dither section 1 |
| The studio field | The studio field is the GPU engine for the animated Bayer materials: createStudioField with ten BAYER_PRESETS sharing one WebGL context. Preset 02, bayer-8x8 (bayer8), is the default, the landing hero's field and the reference for material on product surfaces. | src/lib/studio-field.ts, gt-cloud:apps/landing/src/lib/studio-field.ts; gt-dither sections 2 and 3 |
| Glyph field | The glyph field is the canvas engine (createGlyphField) that rains glyphs from eight writing systems and condenses them into words, conserving matter between morphs. Its glyphs stay solid anti-aliased type, because dither on moving glyphs flickers (2026-08-06, 2026-09-28). | src/lib/glyph-field.ts, gt-cloud:packages/ui/src/lib/glyph-field.ts; BRAND.md section 7; gt-dither section 3 |
| Glyph rain | Glyph Rain is a direction, and the landing component of the same name mounts the glyph field rising (GlyphRain.tsx, drift: 'rise'). Kevin uses the name for the effect wherever it appears, such as the careers page and the pricing close. | src/app/d/glyph-rain/, gt-cloud:apps/landing/src/components/landing/shared/GlyphRain.tsx; gt-landing-pages |
| Ink field | The ink field is the closing band's material (createInkField). The glyph field's eight-script glyphs rise off the ink in the band's margins, stay clear of the content box measured from the live DOM, and answer the pointer. | src/app/d/glyph-rain/sections/band/inkField.ts, gt-cloud:apps/landing/src/components/landing/shared/InkField.tsx; gt-components references/instruments.md |
| Event horizon | Event Horizon is the direction where component walls dive into a black-hole gate, and the name also covers its WebGL lensing engine. The landing's careers and 404 heroes stand on that field, and as page-scale material in the app it was judged too heavy and deleted (2026-09-25). | src/app/d/event-horizon/, src/lib/horizon-field.ts, gt-cloud:apps/landing/src/lib/horizon-field.ts |
| The terminus board | Terminus Board is the direction with a split-flap headline over a flip-wave grid of languages, styled on an airport departures board. The landing's blog header is a split-flap board built from it, and its face settle is the one overshoot easing the landing allows. | src/app/d/terminus-board/; gt-cloud:apps/landing/src/components/blog/BlogHeroBoard.tsx and flap.ts; gt-motion section 2 |
| Gem smoke | Gem smoke is Paper Shaders' Gem Smoke material (Apache-2.0) as Glyphfield renders it, in blue, fire and ink palettes. It is the films' palette, it fills two deck section openers and the designed blog covers, and it can wrap a mark such as the bar monogram as a glass shape. | motion/kit/gemsmoke.js; gt-films sections 5 and 6; gt-deck references/full-picture-slides.md |
| Glyphfield | Glyphfield is Kevin's open-source shader and animation studio at glyphfield.com/studio, where new GT material starts before it ships as engine code or an export. Agents drive it through window.glyphfield.studio, and its name refers to the studio while "glyph field" names the engine above. | github.com/Kevin-Liu-01/Glyphfield; gt-dither section 4; gt-cloud .agents/skills/glyphfield |
| Artifact pictures | Artifact pictures are photographs and scans of objects, artworks and places, screened through the house 8x8 dither at 1 CSS px cells. They appear on the dashboard's sign-in and onboarding field, the plate port, the deck's mood slides and the transition demo in the build log on /docs/handbook/libraries, and each one shows writing, language or the earth, carries no readable English prose and credits its source. | docs/ARTIFACT-PICTURES.md; gt-dither section 5 |
| The Blue Marble standard | The Blue Marble standard is the tone and screen standard every artifact picture is cut to, taken from the Blue Marble picture of the earth on the onboarding field. A scene lands on mean tone 0.361 and standard deviation 0.342, the cutter is pnpm mood-tone, and the picture lint pins the standard file by sha256. | scripts/media/mood-tone/standard.json; docs/ARTIFACT-PICTURES.md, "The rules" items 3 and 4 |
| Speed marks | The speed marks are the seven race-type GT marks Kevin chose on 2026-09-29 to show beside the current doubled-line mark: the bar monogram, its lockup, the plate, double cut, the livery stack, the dithered monogram and the ASCII monogram. They are generated from geometry and font outlines and never redrawn by hand. | scripts/build/speed-marks.mjs (pnpm build:marks), public/marks/, /marks, deck slides 17 to 23; gt-brand references/marks.md |
| The bar monogram | The bar monogram is the speed mark that builds G and T from rectangles on a 120-unit cap, slanted forward 12 degrees, with one cut at mid cap height and three speed bars leading into the G. It holds at 16px and has lockup, dithered and ASCII versions. | public/marks/bar-monogram.svg; gt-brand references/marks.md |
This plate mounts the studio field. Each numbered chip remounts it with one of the ten BAYER_PRESETS, and chip 02 is bayer-8x8, the field of the landing hero.
This plate runs the glyph field. Glyphs from eight writing systems fall and condense into the word for language in one script after another, and the glyphs of each word become the next word.
This plate runs the ink field in its interactive mode. Glyphs rise off the ink, the glyphs near the pointer shiver, and a click bursts the nearest one.
This plate runs the event horizon field: a photon ring around a dark core, with ruled lines bending into it.
Gates and tools
| Term | Meaning | Where it lives |
|---|---|---|
| The line auditor | The line auditor (scripts/lint/lines.mjs) reads computed CSS in Chrome and fails on doubled lines, two owners on one seam, self-stacks, invisible seams and chrome borders outside the three hairline roles. The shell audit pnpm lint:lines:shell walks the shell routes against the dev server on 3005, pnpm lint:lines <url> audits any page, and SVG strokes still need 2x crops checked by eye. | DESIGN.md section 2; gt-lints section 2, references/line-auditor.md |
| The page check | The page check (pnpm check:pages) loads every page on a table of phones, tablets and desktops in both themes, reading phones and tablets as touch devices. It reports overflow, clipping, console errors, tap targets under 40px, layout shift and failed interactions in .pagecheck/REPORT.md, and it runs on the touched pages each round and on the whole site before a release. | scripts/check/pagecheck/ and its README; gt-lints section 2 |
| The practices ratchet | The practices ratchet (pnpm lint:practices) counts nine code checks per file against a baseline, among them bare useEffect, any, !important, raw hex in TypeScript and the retired rail vocabulary. It fails when a file's count rises, so recorded debt is paid down in its own changes. | scripts/lint/practices.mjs, scripts/lint/practices.baseline.json; gt-lints section 2 |
| The gt-ui oxlint plugin | The gt-ui plugin holds gt-cloud's design and copy laws as oxlint rules, among them single-rail, inter-only, icon-tiers, no-em-dash, no-eyebrow, no-smooth-scroll, mono-is-not-voice and shared-cta. Prototemplate runs a whole-file copy through pnpm lint:code and recopies it whenever gt-cloud's version changes. | gt-cloud:tooling/oxlint-plugins/gt-ui.ts, scripts/lint/oxlint-plugins/gt-ui.ts; gt-lints references/gt-ui-rules.md |
| The picture lint | The picture lint (pnpm lint:pictures) holds every artifact picture to the Blue Marble standard by hash, size, tone and credit. It runs before next build, so a picture defect stops the build, and pnpm test:pictures breaks one thing per test to prove the lint catches it. | scripts/lint/pictures.mjs; gt-lints section 2; gt-dither section 8 |
| The type lint | The type lint (scripts/lint/type.mjs, started 2026-10-05) holds Prototemplate's type to the rsms InterVariable through the type tokens. It allows no other family, no weight above 500 and no positive tracking, and it keeps mono to code and to named entries such as numbers, paths and hex values. | gt-lints "The type lint"; gt-brand references/type.md |
lint:all | Prototemplate's pnpm lint:all chains the static lints, the browser audits against the dev server on 3005 and the lint tests with &&. Run the browser gates one at a time, and read package.json for the exact chain. | package.json; prototemplate section 9 |
| The parity gate and ledgers | The parity gate is the release gate for any onboarding or auth redesign: the release keeps every tracking call and backend side effect that production had. The proof records production's ledger of side effects per scenario at the module boundaries, replays the scenarios on the release and diffs the two ledgers after every fix (2026-10-02). | gt-ship section 7 |
| Greptile 5/5 | Greptile writes a confidence score into the PR body, and the target is 5/5 on the head commit with every Greptile thread answered and resolved; a PR does not merge at 4/5 (2026-09-13). It does not rerun on every push, so comment @greptile review again and wait about five minutes. | gt-ship section 5, references/review-loop.md, scripts/pr-bots.mjs |
| Bugbot | Bugbot is Cursor's review bot. It reruns on every push, bugbot run re-triggers it, and each finding is answered with the fixing commit or a reason before its thread is resolved. | gt-ship section 5 |
| The Cursor Approval Agent | The Cursor Approval Agent reviews each PR on open, labels it with a risk level and routes it (the "Pull Request Router" check). Its label needs no reply, and it is the only bot on the content repo. | gt-ship references/review-loop.md |
| gh stack | The github/gh-stack extension links PRs into GitHub's native stack (gh stack link --base main <bottom> <next> <top>) and merges a stack up to one PR at once (gh stack merge). Kevin asked for the native feature on 2026-08-27 and again on 2026-10-05, and gh stack merge runs only when he says to merge. | gt-ship section 6 |
| Feature flags | Feature flags are the dashboard's release gates and kill switches, managed in the admin app. A dashboard feature that is not ready ships behind a flag or comes out (2026-09-03). | gt-cloud's own gt-dashboard skill |
Working terms
| Term | Meaning | Where it lives |
|---|---|---|
| Lane | A lane is one owner's share of the work, with its own files: one session per lane, and inside a workflow one agent per lane. Work that belongs to another lane goes to that lane's session by name, and a lane's prompt opens with Kevin's own words for it. | multi-session-playbook.md section 1; gt-orchestration section 2; gt-ship section 1; prototemplate section 8 |
| Session | A session is one Claude Code or Codex conversation. Kevin runs several named sessions at once (Videos, Prototemplate, New Onboarding and Dashboard, and others), and each keeps to its lane. | multi-session-playbook.md section 1; prototemplate section 8 |
| Forked session | A forked session starts from another session's conversation and carries the parent's history, with the parent's session id on those records, before it continues on its own. A fork acts on its own lane, and a message found in several transcripts at the same minute can be one message inherited by forks. | ~/.claude/projects/<project>/<session>.jsonl; multi-session-playbook.md section 2 |
| Worktree | A worktree is a git worktree with one branch, so each lane edits its own tree. Work in gt-cloud starts with git worktree add -b k/<topic> <path> origin/main, each worktree runs its own dev server port, and a worktree with its installs costs about 6 GB, so it is removed as soon as its work is pushed. | gt-ship section 1 |
| Chip | A chip is a background-task card that a session raises for an out-of-scope fix it noticed, and Kevin can spin it off into a new session. When he answers "Do this task here", the current session does the task as its own small PR with its own gates. | gt-orchestration section 3 |
| Handoff | A handoff is the document written at a hard stop or a change of owner, and it carries the stopped state, every raw input Kevin supplied and the priority queue. The receiving agent starts with an independent review and a recommendation, and it re-checks live state before changing anything. | gt-orchestration section 8 |
| Relay note | A relay note goes from one agent to another, often between Claude and Codex, and Kevin pastes it as is. It names the branch, tip commit and worktree, the commits, the receipts, the open list, the locks and the queued deploys, and the receiver finishes the other agent's open work. | multi-session-playbook.md section 7 |
| The ask ledger | The ask ledger is an itemized list of everything Kevin asked for in a run, including the sub-items of long messages and the add-ons sent mid-run, each with its status. It closes every report on multi-ask work, and a long run keeps it in a file so it survives compaction. | gt-reporting section 3 |
| The PR slate | The PR slate answers "give me my PR list" with every open PR across gt-cloud, gt and content in merge order, in nine groups from merge now to the items only Kevin can do. Each line carries the full link, a one-line purpose and its line counts, and the Slack version is lowercase plain text in a code fence. | gt-reporting section 5, scripts/pr-slate.mjs |
| Explorations stay local | Exploration and redesign rounds stay uncommitted or on a branch until Kevin has reviewed them on localhost and says to land them, because Prototemplate main deploys the public site (2026-09-14). | gt-aesthetic section 5; gt-ship section 8; gt-explorations |
| Kevin merges | An agent merges a PR or runs gh stack merge only when Kevin says so in that session. | gt-ship sections 5 and 6 |
| The agent guide | AGENTS.md at the root of Prototemplate is the entry point for an agent: the read order, the principles in brief, which skill to load for a task, the house rules, and how to import the hub into another project. CLAUDE.md imports it for Claude Code. | AGENTS.md; /docs/handbook/agents |
Kevin's shorthand
| Term | Meaning | Where it lives |
|---|---|---|
| "image 1" | "Image 1" names the first image attached to the message, and "image 2" the second, in attach order. Each numbered note maps to a region of its image, and the image is the spec. | gt-reporting section 7; gt-aesthetic section 5 "Rules of the loop" |
| "equivalent" or "equal" | Both measures take the larger value (2026-09-30). | gt-aesthetic "Reading Kevin's asks", references/verdicts.md |
| "keep its aesthetic" | The geometry and the material stay, and only the named thing changes. | gt-aesthetic "Reading Kevin's asks" |
| "smaller" or "larger" | The value moves to the next rung of the existing ladder, as when the 13px card facts went to the 12px rung (2026-09-28). | gt-aesthetic "Reading Kevin's asks" |
| "fully" | The work covers every section, capability and detail with real diagrams, visuals and code. A placeholder or a partial pass does not count. | operating-principles.md section 15 |
| "continue all" or "keep going" | Resume every open lane and every unfinished item, the hard ones included, without pausing between waves. In a forked session the words cover the fork's own lane, and after a restart or a compaction the work resumes from the plans kept on disk. | operating-principles.md section 1; gt-orchestration section 6; multi-session-playbook.md section 2 |
| "no new spawns" | Agents already running finish, their work is committed and pushed, and no new agent starts (2026-08-06). | gt-orchestration section 1 |
| "show me" | Put the result where Kevin can see or hear it: before and after crops, a running localhost URL, or a small HTML gallery or listening page for a set. | gt-reporting section 1; operating-principles.md section 8 |
| "second pass" | A second pass reviews a finished page against its reference before it is shown, and pages that skipped one are redone (2026-08-17). | gt-aesthetic section 2 |
| "try again" | After an API error or a spend limit, re-run the step that failed, starting from a fresh read of the state. | multi-session-playbook.md section 3 |
| "commit and push" | Commit and push at once to every target he names, staging explicit paths. | gt-ship sections 2 and 8 |
Retired terms
These terms still appear in older messages, commits and skills. The ruling that retired each one, its date and its reason are recorded in decisions.md.
| Term | What it was | What replaced it |
|---|---|---|
| Switzer | Switzer was a second typeface used beside Inter in the July rounds. | Retired 2026-09-18: Inter is the only face, gt-cloud #4887 removed the files, and inter-only holds it (decisions.md). |
| Lenis | Lenis was the smooth-scroll library behind the July scroll stories. | Retired from the site 2026-07-31: scrolling is native and no-smooth-scroll holds it. The presenter's last Lenis code was removed on 2026-10-08. Its paging still animates the jumps between slides, under a named exemption in .oxlintrc.json (decisions.md). |
| Double rails | The double rails were a second pair of lines 10px outside each rail, also called the outer pair or doubled rails. | Retired 2026-09-28 in gt-cloud #5007: one rail per side, held by single-rail and the practices ratchet's rail checks (decisions.md). |
| DirectionDock | DirectionDock was the control pill on the direction pages in July. | Retired 2026-07-31 and deleted 2026-09-08. DirectionCorner (src/components/viewer/DirectionCorner.tsx) took its place and hides under ?chrome=0 (decisions.md). |
| apps/redesign on port 3006 | The July explorations app ran from apps/redesign in a gt-cloud worktree on the branch redesign/diagram-standard. | Retired as the primary copy on 2026-09-08: Prototemplate main holds the canon and serves on 3005, and prose that names 3006 is stale (decisions.md). |
| The dictionary pictures | These artifact pictures showed pages of readable English: the dictionary, Johnson, OED and Oxford pictures. | Retired 2026-10-05: artifact pictures carry no readable English prose, and the picture lint rejects the retired names (decisions.md). |
Sources
- Prototemplate: BRAND.md sections 1, 2, 5, 7 and 8; DESIGN.md sections 1 to 5, 7, 8 and 10 to 14; ARCHITECTURE.md; docs/ARTIFACT-PICTURES.md;
package.json;.oxlintrc.json;src/lib/directions.ts,src/lib/surfaces.tsandsrc/components/viewer/tokens.css;scripts/lint/practices.mjs;motion/kit/gemsmoke.js(header); all read 2026-10-05. - Skills:
prototemplate,gt-aesthetic,gt-ship,gt-lints,gt-dither,gt-landing-pages,gt-website,gt-components,gt-brand,gt-deck,gt-films,gt-motion,gt-diagrams,gt-orchestration,gt-reporting,gt-local-devandgt-explorations. The handbook pages gt-product-map.md, operating-principles.md, multi-session-playbook.md and decisions.md hold the procedures behind the working terms and the rulings behind the retired ones. - gt-cloud at origin/main e17fce499 (2026-10-05):
apps/landing/package.json(dev),apps/dashboard(components/frame/PlateFrame.tsx,components/brand/, the context routes),apps/landing/src/lib/(studio-field.ts,horizon-field.ts,report-card/) andapps/landing/src/components/blog/. - The gt repository:
packages/*/package.jsonfor the package names. - Kevin's messages to Claude Code and Codex from 2026-07-20 to 2026-10-05 and the session transcripts behind them, for the shorthand and the working terms.
GT product and architecture map
What General Translation sells and to whom, how the products fit together, the copy that must be exact, and where each part lives.
Numbers
Every load-bearing number in one place, grouped by area, each with its reason, its token or constant, the lint that holds it and the page that explains it.