the operating-rules file the Codex harness reads at the start of a repo, the way Claude Code reads CLAUDE.md
the 4 earned levels of agent trust: suggest → draft → apply-low-risk-but-approve → auto-with-audit-logs
a search model that turns the question and each document into separate vectors and compares them; fast but judges topic-overlap, not whether a passage actually answers the question
a computation that returns the exact same output every single run (no random variation); the reranker is bit-deterministic, which is what let it replace the model whose answers flipped run-to-run
using a per-task *mix* of AI models instead of one; because each model's skill is uneven across tasks ("jagged intelligence"), a well-chosen blend beats the single best model
an open-source text-to-speech model with an emotion-intensity dial, run locally per scene; the step up from Kokoro's flat delivery without paying for a cloud voice
a safety stop that halts a loop after N failures so a broken run can't spiral
an eval that just reads a number from somewhere (e.g. broken-link count) and tracks it over time, rather than passing or failing — turns a one-off check into a trend you can watch move
the maximum amount of text a model can read in one call (prompt + its own answer); the real ceiling a bundle/input has to fit inside, and why the daily-brief bundle is char-capped
a slower, more accurate model that reads the question and a candidate passage *together* and scores how well the passage answers it; used to re-rank a shortlist the bi-encoder retrieved
when a speech-to-text model gets stuck repeating the same phrase over and over (e.g. "one PDF you have, one PDF you have…") instead of transcribing what was actually said; usually triggered by hard-to-hear or pause-heavy audio
same input always gives the same output; no randomness, so a check can't flip green/red on identical state
training a smaller, cheaper model to copy a bigger one's outputs, capturing most of its skill for less
Anthropic's feature where an agent reviews its past sessions between runs and tidies its own memory (merge duplicates, drop stale, spot patterns) — memory curation, not model retraining
a piece of text turned into a list of numbers ("vector") so a computer can match items by MEANING rather than exact words; what semantic search compares under the hood
a periodic check that flags anything new which SHOULD be covered by an automated system but isn't yet, so nothing silently escapes coverage
matching the same company across messy sources into one clean record; the real hard part of a data product, not the scraping
a fixed, scored test that measures an AI's output against a defined "good" — the unit-test equivalent for prompts and agents, so you can prove a change improved things, not just hope
pair a writer agent with a separate checker that must fail on something real (tests/build), not just agree
getting an AI to imitate by showing it a handful of real examples first, instead of giving it rules to follow
the score an optimisation loop tries to maximise; here, the eval *is* the fitness function the hill-climbing loop climbs
a fixed, known test input kept in the repo, so every proposed change is judged against the same case rather than a story about it
a prompt-*optimization* loop (auto-tunes prompts toward a goal); not an eval/measurement harness — it improves the ask, it doesn't grade the output
telling an agent the exact end-state plus the proof of success required, so it can't fake "done"
an agent repeats until a *separate evaluator model* confirms the goal is met — you hand off the stop-condition, not just the check
the frozen folder of input→ideal-output examples an eval tests against every time, so quality drift is caught by comparison
a saved known-good output that a test compares against, so a change that breaks behaviour gets caught loudly
a cheap, deterministic check against the live thing itself (fetch the page, check the remote, stat the resolved path) instead of a file or note that merely describes it — the antidote to false signals
a small shared note two AI agents leave each other (here Claude ↔ Codex, who don't share a chat): what was just done, what's next, the code version — so whoever works next picks up where the other stopped
the program that runs an AI model and gives it tools/files/permissions (Claude Code and Codex are two harnesses); the model is the engine, the harness is the car around it
checking a model on material it was never trained on, so it can't just repeat what it memorised — why the voice A/B generates sentences that aren't in the training script
an open-source always-on agent runtime (memory + skills + scheduler + tools) — the orchestration *layer*, distinct from a model or a model-runner
a judge rule that a commitment requiring a person's physical act (test on a device, read, record) can only be ticked by proof of the act, never by related build work existing
combining keyword search with meaning-based (semantic) search because no single method finds everything
fan a prompt to several models, then one model judges and merges their answers into the final
a small, free, fully-offline text-to-speech model that runs on your Mac; trialled for the podcast and parked (sounded synthetic vs NotebookLM)
how far an automated fixer may act alone: fix it · assume-and-say-so · ask you first
using a second AI model whose only job is to grade the first model's output; the AI-world version of a four-eyes / code-review check
using one AI model to score another model's output against a rubric, for fuzzy qualities (tone, voice) that a simple text match can't measure
a proposed "map for AI" file (like robots.txt) that hands LLMs a clean view of your site; emerging, cheap to add, not yet proven to be used
designing the repeating *cycle* (observe → act → check → adjust) as the unit of work, instead of tuning a single one-shot prompt
a standard way to plug external tools and data into an AI agent
one of the feedback sources the loop reads to decide what to improve: eval scoreboard · internal audit · apply-now ledger
checking that the AI grader still agrees with your own labels, so the ruler you measure quality with doesn't silently drift
a loop that improves other loops: it reads the system's own scores, picks the weakest spot, and fixes it without being told where
a model split into specialists where only a few run per word, so it can be big overall but cheap to run
a rule telling a browser "check with the server before reusing a saved file"; stops visitors seeing an old stylesheet after a redesign
the runtime that runs open AI models locally on a Mac; since v0.14.0 it speaks the Anthropic API, so Claude Code can point at a local model
a loop fired by an event or a schedule with no human in the loop; you hand off the prompt itself (your autopilot conductor is one)
showing the model only the tools/context it needs at each step, instead of loading everything upfront
it surfaces a plan and waits for you; it never changes anything on its own
shrinking a model's numbers to fewer bits so it fits on local hardware, trading some accuracy for size
the model first *retrieves* the relevant source passages, then answers *from* them with citations, instead of from memory — so it can quote the exact clause and refuse when it finds nothing
the step that feeds stored feedback back into the next run, so the system actually learns from it instead of just recording it
how fast transcription runs vs the audio's length: "10× real-time" means 1 hour of audio transcribes in ~6 minutes
a speech-to-text failure where the model gets stuck repeating one phrase over and over instead of transcribing what was actually said; long, pause-heavy voice notes trigger it, and the fix is retrying with settings that stop the model from feeding its own output back to itself
an interactive prompt where you run code line-by-line and inspect the result each time; an RLM treats your whole corpus as a variable inside one
a second, more careful model that re-orders search results by actual relevance to the question before they're used
an agent games the score instead of doing the task, e.g. deletes the test so it "passes" (Goodhart at the agent level)
instead of stuffing a huge corpus into the prompt, you load it as a variable in code and write code to peek/chunk/recurse over it — handling inputs far beyond the context window
the app that *runs* an AI model on your own machine (e.g. Ollama); not the model itself, just the player that loads it
a permission fence around what an AI agent's commands may DO (read-only · can-edit-files · full-access) — NOT a separate copy of your files; the agent still edits the real files on disk
the privacy rule that filters what an agent may read *before* it writes anything, so it can't leak what it never received; safer than asking the model to "not mention" something
a process runs and reports what it *would* do, but changes nothing — so you can audit its judgement before letting it act for real
stripping the silent gaps out of a recording before transcription, so the engine can't hallucinate filler into the dead air
a background "custodian" agent that quietly indexes, de-dups and refreshes your knowledge base while the working agent is idle (= your daily-ingest / weekly-lint crons)
the long number in an X post's URL secretly encodes the exact moment it was posted, so you can decode the date from the link alone
the AI model keeps nothing between chats; every session starts blank, so "memory" is something you build around it, not a model feature
the layered set of technologies a system is built on, bottom to top: runtime → libraries → tools → models → services → your own code
the randomness dial on an AI model's word choices; 0 means it picks the same words for the same input every time, higher values vary the phrasing
scoring the *path* an agent took to an answer (wasted loops, backtracks, tool efficiency), not just the final output — catches a good result reached the wrong way
reading all your session transcripts in time order to mine them for patterns, corrections, and efficiency metrics
software that reads written text aloud in a synthetic voice (the reverse of transcription)
deleting old guardrail rules a smarter model no longer needs — they just make it waste effort reconciling conflicts
the string a fetcher sends to identify its browser; some sites serve or block content by UA, so the same law can 403 as "Chrome" but download as "Googlebot"
stores meaning as numbers (embeddings) so you can search by similarity, not exact words (Cloudflare Vectorize powers "ask the law")
Cloudflare's database for embeddings (text-as-numbers); the search Worker looks up "which pages mean something close to this query" in it
an AI that reads images and text together, so it can answer from a screenshot, not just words
the unique acoustic fingerprint of a person's voice; what a voice-cloning model learns from a recording, and what you're handing over when you upload a sample to a cloud service
the list of folders a sandboxed agent is allowed to write into; anything outside stays read-only, so you widen it deliberately (here to let Codex write the handover note that lives outside the code repo)
the server's "too many requests, slow down" signal; the only cue you're near the usage ceiling
how many things one change can break; the price of sharing code (one bug hits all), managed by versioning + doing risky merges last and gradually
a small, low-risk task run first to check the pipeline works before the bigger ones go through
when two parallel systems that should match fall out of sync (one gains a feature the other lacks); a drift-checker reports it so the gap is visible instead of silent
using several independent locks instead of one, so a single mistake never exposes the data
a scheduled check that compares your docs/specs against the live system and flags where they've fallen out of date
register ONE script per hook event that then calls each guard, so adding a guard means editing a script (easy) not the locked config file
releasing a queue slowly, one or two pages a day, instead of dumping it all at once
a shell safety-net (`trap … ERR`) that runs a chosen command — log it, ping Telegram — automatically the moment any command errors, so a crash announces itself instead of dying silently
when a safety check can't run, it BLOCKS the action rather than letting it through — used where a leak is worse than a stall (e.g. the coaching transcript refuses to write if redaction can't run, rather than risk writing un-redacted work secrets)
when a safety check can't run, it lets the action through rather than blocking it — so a broken checker never wedges the whole system (the opposite is fail-closed)
when a safety check can't run (error, missing file), it ALLOWS the action rather than blocking it — so a bug in the guard never halts real work; the opposite is fail-closed
a safety design where if the guard itself errors (e.g. a rate-limit counter), requests are let through rather than blocked, so a broken guard never takes the whole service down
if an extra polishing step breaks, let the original through rather than losing the whole thing
"first in, first out": a queue that serves items in the order they arrived, oldest first (the opposite is LIFO, newest first) — here, deep-reads/dossiers publish in the order they were captured
a step built so it CAN'T be skipped (e.g. a hook that blocks an edit until you've searched first), used when a soft reminder keeps getting ignored — the discipline is enforced by the system, not by remembering
one file that records when each data source was last checked/verified, kept in one place so the "is it stale?" answer can't drift across separate docs
a program that runs on a schedule with no screen to watch, instead of you starting it
a script the system runs automatically at a set moment, e.g. re-running tests after a tool finishes
safe to run repeatedly: running it twice changes nothing the second time
the macOS background-job manager: it reads small config files (one per job) and runs your scripts on a schedule or when a watched file changes; the Mac equivalent of "cron"
a fake secret-marked note planted in a private scope; an automated test fails loudly if that marker ever shows up in an output it shouldn't, proving the scope filter works
a running record file that logs each run's pass/fail so failures can't hide
an offline document-parsing pipeline that OCRs scanned PDFs and rebuilds their tables (the OCR path, when the fast converter finds no text)
a pipeline step deliberately allowed to fail without stopping the whole run (so a hiccup never blocks the morning brief); the catch is it must loudly announce its own failure, or it dies silently
a tiny file storing a running program's ID number, so a script can find that exact program later and stop it cleanly
a shell setting (`set -o pipefail`) that makes a chain of piped commands fail if *any* step fails, not just the last one — so a quiet failure mid-pipe (e.g. `grep` on a missing folder) can crash the whole script
a script git runs automatically just before a push; if it exits with an error the push is blocked — our mechanical "reviewer" that scans outgoing commits for secrets and identity leaks
a guard script that runs the instant before an Edit/Write and can block it; the source of the red "Failed to…" deny messages you see mid-session
a holding list of items waiting their turn to be processed or reviewed
a bug where two things happening at once interleave in a bad order — e.g. a comment arriving in the split second between "read the queue" and "archive the queue" could be archived unread
a who-does-what table (Responsible / Accountable / Consulted / Informed); here, which cron or agent owns each piece of a pipeline
cleanly killing an old process and its children before starting fresh, so stale sessions can't pile up
the logbook pattern: keep recent entries live, move older ones to a dated archive so the file stays lean
when a step fails but the program still exits "successfully", so no alarm fires and a broken feature looks healthy
only ONE job is allowed to write a given dataset, so two writers can't overwrite each other (why the laptop's law-refresh cron was retired once the cloud took the job)
detect what's new by saving a dated copy of a list on a schedule and comparing it with the previous copy; the new rows are the news
a script Claude Code runs automatically each time a turn finishes; used here to notice when a session was cut off by a usage limit
macOS's permissions ledger (which app may access disk, automation, mic…); major OS upgrades can reset it, which is what breaks unattended jobs
a cheap paid first offer that gets a client in the door before the bigger retainer
a small script the harness runs the instant you send a message; it can read the message and inject extra instructions before the assistant acts (here: detect which context a session is and wall it)
a small recurring check that notices when a job dies silently and pings you
a tiny second guard that only checks the main guard is still alive; needed because the guard's own death is the one failure nothing else announces
the "Run workflow" button on a GitHub Action: lets you trigger a scheduled job manually, from the website or phone — the remote fix button
an image lives with its deliverable by default; the moment it's used from a 2nd folder it auto-moves to the shared `assets/` folder and its links are rewritten — so "shared vs single-use" is enforced by the system, not tracked by hand
the single principle a part of the vault sorts by (Time / Category / Project); naming which axis each zone uses stops a permanent note being filed into a topic folder by reflex
Obsidian's built-in database: shows your notes as a live, sortable table filtered by their frontmatter — no plugin or script to regenerate
the `Clippings/` folder where new clips land before the daily sort files them into `raw/`
a sweep that reconciles what was built back into the milestones and memory records
on each refresh, compare incoming data to what you already hold and keep only the differences — the mechanism that turns raw pulls into a change-tracked dataset
an Obsidian plugin that runs database-style queries *inside* a note (older code-block approach; Bases is the newer native version)
remove an item from the search database so it stops showing up in search results and briefs (used when walled content accidentally got indexed into the wrong context)
a docs framework that separates four kinds of writing (tutorial · how-to · reference · explanation) so a document reads for humans instead of one undifferentiated wall
two files that share a name but actually do different things, so they only *look* like a duplicate to merge; the right move is to relabel them, not combine them
the standard physics engine for drawing network graphs (the one behind Obsidian's graph view): dots repel, links pull, and it settles into a stable layout then stops
the `---`-fenced settings block at the top of a note (title, link, tags) that tools read, separate from the body
a search-engine table that lets you find any word across all documents fast; the keyword half of the local semantic search
inbound = things reading your data on your own machine (search, the AI, the brief); outbound = things sending it out (publishing). Different risks, different walls
rebuilding the search map for only the files that changed, instead of the whole vault
moving/renaming a folder on the same disk keeps its underlying identity, so nothing is copied and a running program using it doesn't break — which is why such a move is instant and safely reversible
what decides if something belongs in `raw/`: sources fed *in* from outside → `raw/`; anything your processes *produce* (transcripts, briefs, posts) is an output → never `raw/`. Immutability is not the test
laying a diagram out in left-to-right columns (inputs → process → outputs) so the direction of flow reads at a glance without labels
when a remote link (e.g. an image hosted elsewhere) later breaks or vanishes, leaving a note pointing at nothing; fixed by pulling the file into the vault so it's yours
a fast converter that turns born-digital PDFs and Office files into markdown without OCR (the fast path, for documents that already contain real text)
a per-folder memory store Claude loads based on which directory you launch it from
a hand-made table-of-contents *note* that links to scattered notes wherever they live, instead of a folder that walls them off; gives one curated doorway while keeping every note in the shared, searchable graph
when a folder moves, its Claude memory is stranded at the old path and stops loading
prefixing each label with its parent section (e.g. "App1 2.3") so identical numbers in different appendices don't clash and get merged into one bloated unit
the visual map of your notes as dots joined by their [[links]] — it shows clusters (tightly-linked topics) and orphans (notes nothing points to)
convert everything into one common format (here, plain-text markdown) so the same tool can read and search all of it, no matter how it arrived (voice, screenshot, web page)
Google's free tool that turns your notes into a two-host audio "podcast"; you steer the style, it improvises the words
Projects-vs-Areas distinction: a Project has a finish line ("done" exists) → `portfolio/`; an Area is ongoing, never done → `interests/`; it defines what "finished" means per folder
a marker on each publishable item recording its source + that it was cleared, so nothing reaches the public without a traceable "cleared" reference
holding a suspicious incoming message aside instead of filing it, pending a keep/delete decision — how the capture guard stops a wrong-bot send
a standard web link a podcast app subscribes to; new episodes appear automatically (apps can't add loose audio files, only feeds)
your folders/taxonomy/layout written as a swappable config file instead of baked into code, so a new install = drop in a different config
packaging the "shape" of your data (categories, folder rules, the tagging map) as editable config a new install can customise, instead of baking it into code
one file everyone reads from, so the copies can't drift apart
a query language for linked-data (graph) databases; how the Swiss register was pulled in bulk without any account, just questions sent to a public endpoint
SQLite's built-in full-text keyword search (the exact-match half of the hybrid vault search)
the one official source of truth (here, the markdown vault); the search index is just a rebuildable copy of it
showing only a recent slice of a growing list (e.g. the last 2 days of decisions) instead of the whole history, so a section stays short
the simple "key: value" text format used inside a note's frontmatter block
a note method of atomic, own-words notes that connect by *links* not folders; the ancestor of the AI second brain
a small, never-committed text file holding a project's passwords/keys as NAME=value lines; its committed twin `.env.example` keeps the names but empty values as a template
a "permanently moved" signal from the server: visitors and Google arriving at an old address get forwarded to the new one instead of an error page
a Claude Code terminal command that links your GitHub login to your Claude account, so phone/web sessions can open your private repos
an explicit list of what's permitted (e.g. which pages may publish); anything not on the list is blocked by default
a long secret key that lets a program authenticate to a service on its own (no human login), scoped to only what it needs; unlike a browser login session it doesn't expire, so it's the right credential for unattended jobs like a deploy cron
a git option (`pull --rebase --autostash`) that temporarily shelves your uncommitted edits, does the rebase, then puts them back — so a sync doesn't fail on "you have unstaged changes"
a way to draw a system at four zoom levels — Context, Container, Component, Code — so one diagram doesn't try to show everything at once
adding a version stamp to a file's address (style.css?v=abc123) so browsers fetch the new copy after a change instead of showing a stale saved one
a blank drawing surface in a web page where graphics are painted by code (e.g. moving sparks), separate from the text
a narrow exception added to a blanket rule, e.g. "never allow git push — except for this one repo"
a country-code domain ending like .je (Jersey) or .uk; a strong local signal, sometimes pricey
a global network that serves a static site from everywhere at once; why static sites basically never go down
the tool runs inside the visitor's own browser; the file never travels to a server, so there's nothing to store or leak
a bot-check page a website shows before letting you in. *Managed* clears itself in a few seconds once your browser proves itself (a cookie called cf_clearance); *interactive* needs a human to tick "Verify you are human". Scripts can't pass either — which is why some data pulls need a browser + one click
a hosted, SQLite-compatible SQL database (the 790k-row fund register behind the site)
free hosting that serves a folder of files at a web URL; here it serves the podcast feed + episodes
a cloud job (GitHub Action) committing its own output file back into the repo, so results live in version history instead of vanishing with the run
a deliberately-temporary symlink left at an old path during a move, so existing references keep working until they're repointed and the shim is removed
the browser part that paints the page to pixels; when it "wedges" the page's data is fine but screenshots/measurements come back blank or zero
the ONE place a setting (like the vault's location) lives, so everything reads it from there instead of having the value typed into many files; change it once, everything follows
settings/config files (skills, slash-commands, cron plists) treated like source code: kept in a git repo so they're versioned and backed up, not just living loose on the machine
stamping a file's fingerprint into its web address so a browser can never serve a stale copy
requiring independent evidence (a git commit, a done-marker) before an automated action fires, so it can't act on a guess
the browser's cross-site security rule: a web page can only read data from another domain if that domain's server explicitly says "this origin is allowed" (a wrong setting shows as "search unavailable")
a small SQL database that lives at Cloudflare's edge, so a website can run real searches (name lookups, joins) fast and cheap without you running a server
code that exists in the repo but nothing ever runs; it looks like a working part until you trace who calls it — nobody
the short lag while a CDN's servers worldwide pick up a newly deployed version, so two requests moments apart can see different versions of the same page
what most hosts charge each time a file is downloaded; R2 waives them, which is why it fits audio
a server-side cursor for bulk-reading a search database: each request hands back the next page plus a ticket for the one after, until the whole set is exhausted; it can't pause/resume, only run or restart
one physical business location (a branch or shop), as distinct from the legal company that owns it; France publishes register data at this finer level
the pool of proof (git commits, done-markers, session logs) an auto-ticker searches before marking something finished
fixing by adding a new commit on top of the old ones; works for stale files but NOT for leaks, because the leaked line still sits inside the earlier commit being pushed
a second, separately-maintained copy of the same codebase; the infra project's whole goal is ONE codebase, not two (kill the coaching fork)
surgically editing past commits so a file's old content is removed from the repo's whole history, not just the latest version — used to scrub a leaked file out of local backups
the integration code that links your in-house systems/data to external AI agents; McKinsey's claim is that 60–70% of the value sits here, not in the model
a table where each cell's colour intensity shows its value, so you spot the big concentrations at a glance instead of reading numbers
the simplest API login: username:password sent (encoded, not encrypted) in a header on every request; over plain http anyone on the path could read it
an interactive widget (e.g. a photo tool) dropped into an otherwise-static HTML page, so the page stays fast and search-crawlable while only the widget runs JavaScript
machine-readable facts hidden inside a web page so search engines and AI answer engines can quote it directly
macOS's built-in encrypted store for passwords/tokens; the safe place to keep a secret instead of writing it into a file
the umbrella term for animated / moving text
a tool that auto-scans your files/code for problem patterns (here: hardcoded paths) and flags them
a busy server deliberately answering with an empty placeholder (e.g. HTTP 202 + no body) instead of the real page, to survive a traffic spike; looks like success to naive scripts, which is why the freshness checker had to learn to treat it as failure
the ordering rule that any self-correction must re-run its measurement before the report is composed, so you never receive a verdict the system already knows is stale
a CSS rule meaning "if the screen is narrower than X, use this layout instead" — how one page adapts to phone vs desktop
a small shared core engine that each context extends with its own plug-in modules + config, so the core is built once and everyone inherits it
a small one-off script that upgrades old data/config to a new version's format during an update, so a code update never breaks existing notes
multi-tenant = one running system serves many customers (Slack); single-tenant / self-hosted = each customer runs their own copy (GitLab self-managed). Clients running it on their own machine = single-tenant
the internet's address-book servers that point your domain to where the site actually lives
"newline-delimited JSON": one JSON record per line in a plain text file. Lets a crawler append records one at a time and lets you count/stream them by lines without loading the whole file
a regex rule that matches a word ONLY when it is NOT preceded by some text (e.g. `(?<!domain/)BNP` blocks a bare "BNP" but allows it inside a `domain/` tag) — used to make a guard precise instead of over-blocking
a push git refuses because the remote has moved on since you last synced (someone/something else pushed first); the fix is to pull-rebase then push again
a CSS property that makes an element travel along a path you define; the browser animates it on the GPU, so it's essentially free
reading a rendered word's pixels so each becomes a particle, letting the text dissolve or assemble itself
a small script git runs automatically right before a commit; it can block the commit if a check fails (here: catching a hardcoded path leaking back in)
pushing the site live to the internet, as opposed to just saving the files on your machine
building a page so it works in plain HTML first, with the interactive layer as a bonus on top — keyboard, screen-reader and no-JavaScript users still get everything
mark public/private with a flag (GitHub + allowlist), not the folder name, so going public needs no move
Cloudflare's cheap file storage with no per-download fee — the free home for the podcast audio
turn a page or drawing into a flat picture of pixels; whatever was underneath (text, layers) stops existing as separate objects — why redaction by rasterising is irreversible
the modern, structured replacement for whois; gives a clean "registered / not registered" answer
replaying your local commits on top of the newer remote ones so the two histories line up again, instead of tying them together with a merge blob — used to "catch up" a clone that fell behind
a still image shown in place of an animation for people or devices that have motion turned off
a check that re-runs known-good answers so a change can't silently break them; here, computing every deadline's date from a formula and asserting it still equals the verified date
a hosted copy of your code repo on GitHub that your laptop syncs to, for off-machine backup
a small script that turns a source file (like markdown) into the finished output (like an HTML page)
a copy command that only moves what changed and (with `--delete`) makes the copy an exact mirror of the source — used to keep a backup folder in step with the live one
a fast Python linter: it scans code and flags real errors (syntax mistakes, undefined names) before they ship
one small first commit that reserves all the shared wiring (stubs, enum cases, folders) so parallel builders never edit the same file afterwards
one structured file describing every scene of a video (the words + the visuals + timing); every later production step reads from it, so one file drives video, infographic and subtitles
styling tied to one page/section (here via a `body.regs` class) so a redesign physically cannot leak into the other 399 pages
version numbers like 2.3.1 that signal how big a change is, so an install knows when an update is safe vs needs a migration
a page whose full text arrives already built in the HTML, readable by a plain fetch (the opposite of an SPA)
the small file a site drops in your browser after you log in, proving "this is still me" for a while; saved once (`.x_state.json`) and reused so an unattended job can read authed pages — expires eventually, unlike an API token
a small piece of code that slips between a program and the thing it calls, adding behaviour (like a fallback) without changing either side
copying a folder's current files into a repo as one commit, without carrying its old commit-by-commit history
a small pre-drawn image reused many times instead of redrawing it from scratch each frame — the trick that keeps particle effects fast
a whole relational database that lives in a single file, no server to run (behind the local semantic-search index)
collapsing several commits into one whose content is the final state; how a leaked line is removed from everything that leaves the machine while the originals stay recoverable locally
git's "set my uncommitted edits aside" shelf: tuck away work-in-progress so the folder is clean for another operation (a push/rebase), then pop it back afterwards — the fragile bit is when someone else changed the same files meanwhile
forcing an AI to answer in a fixed, machine-readable shape (e.g. JSON fields) instead of prose, so software downstream can use it reliably
a git repo pinned inside another repo as a pointer, so one clone can pull in another project at a fixed version
folding another repo's files *and its whole commit history* into a subfolder of yours; the heavier alternative to a snapshot import, and the one deliberately rejected when Utilities was consolidated
a tiny pointer file that stands in for a folder elsewhere: open the old path and the system silently follows it to the real new location, so nothing that still expects the old path breaks
the distinctive handshake pattern a client makes when opening a secure connection; servers can tell curl from a real browser by it no matter what the client claims to be — why Cloudflare showed the analytics beacon to a browser but not to a file-grep-style fetch
colours (or other design values) replaced by the nearest official named value from the design system's palette, so every shipped pixel sits on one scale instead of near-miss one-offs
a copy of a real config file with the machine-specific bits (paths, your name) swapped for fill-in placeholders; a renderer puts the real values back, so the same template works on any machine — and on yours it changes nothing but the path
RAM the CPU and GPU share, so a machine runs bigger AI models than its raw spec suggests
a computer you rent in a data centre that's always on, independent of your own laptop — used to run heavy jobs or your own AI model 24/7
a tiny script that reports real browser page-views, filtering bots and crawlers out of raw server hits
a web protocol that lets a file share be listed and downloaded by scripts (folders over HTTP); how Brazil's 7.6GB register share is fetched without a browser
a small program that runs on Cloudflare's servers around the world, no server of your own needed; our semantic search runs as one
a throwaway copy of your code folder so an agent can work without risking the real files
a security scanner for Python code: it flags risky patterns (e.g. running a shell command built from user input)
a citation/id built from several nested levels stacked together (e.g. Chapter + Part + Section → "QIAIF Pt I s.12"), needed when the inner numbering restarts under each parent so a bare "Section 1" is ambiguous on its own
a network map centred on ONE node — it plus only its direct connections (e.g. one fund provider + all the funds it links to)
a named setting read at runtime (e.g. `REGFUND_DATA_ROOT`), so a value like a data path lives in ONE place instead of being typed into every script
sending each task only the context it needs for relevance, even though the engine is allowed to read everything; it's an efficiency move, not a privacy wall
software that spots names/orgs/numbers in text (named-entity recognition), used at the exit to catch identifiers a fixed denylist would miss
Companies House's public register of who ultimately owns or controls a UK company; the beneficial-owner filing
replace real names/IDs (a client, a VAT number) with consistent realistic fakes everywhere, so the worked example still reads true but exposes no real data — unlike "[REDACTED]", it stays usable as a portfolio piece
being allowed to *see* data isn't being allowed to *use it for anything*; the rule that lets one engine read everything internally while the exit gate controls what's ever published
a website that can install and run offline like an app; here it doubles as *proof* of the "works without uploading" privacy claim
a rule that only lets a strategy trade when the broader market condition suits it (e.g. price above its 200-day average); it sits in cash otherwise
an AI loop that improves its OWN setup/harness, not just its answers: an inner loop optimises the work, an outer loop optimises the inner loop's harness — the recursive ceiling of harness-engineering
the part of a document miner that decides where each clause/unit starts and ends (splitting one long PDF into individually-citeable pieces)
realistic fake documents/records you generate yourself: the shape of the real thing with none of the privacy risk, and perfect labels for free
Apple's built-in document-camera component: auto-detects page edges and de-skews, the same scanner Notes uses
reading a table that has no ruled lines by grouping words according to where they sit horizontally on the page; how the CalSTRS private-equity PDF was mined
a note stamped onto your vault when a new source contradicts an earlier belief, so the clash resurfaces in the brief until you resolve it (the system argues with you instead of burying it)
a short dated note capturing one decision + why + what was rejected, so the reasoning isn't lost later
shaping content so AI answer engines cite it, not just so it ranks in the blue-link search results
a data row that stores only a count (e.g. "11 funds"), not the actual names behind it
a standard template for documenting software architecture (12 fixed sections: goals, constraints, context, building blocks, runtime, decisions…) so any reviewer knows where to look
a checklist file Homebrew reads to install or verify all of a machine's command-line tools in one go — the "shopping list" for rebuilding a Mac's toolset
how much sentence length/shape varies; humans vary a lot, AI doesn't, so low burstiness is an "AI-written" tell
a script that checks which folder you started in and only acts when it's the right project
editing AI-written text to remove the tell-tale patterns (vague claims like "most teams", puffery, em-dash spray) that make it read as machine-generated rather than human
a URL that jumps to one specific spot inside a document (e.g. `…#art_15` opens Article 15), not just the document's front page
block everything unless it's explicitly allowed; the safe default for a publish/approval gate
instead of two systems each keeping their own copy of a feature, one calls the other's shared copy (here: the coaching bot asks the main engine to transcribe), so the feature lives in exactly one place
how long readers pause on a post; a core signal platforms like X rank reach by
a checkpoint a change must pass (e.g. Plan, Build, Audit, Verify) before it moves on
structuring content so AI answers (Google AI Overviews, ChatGPT) quote and cite you, not just so Google ranks you
one codified repair pattern a self-healing system is licensed to apply: how to detect the problem, fix it, and verify the fix actually worked
a self-improvement loop that generates a variant, scores it with an eval, keeps it only if the score went up, and repeats — "climbing" toward better output
a rule in a document miner that only accepts sections whose numbers keep climbing, so out-of-order or duplicate ones (a stray "see 10.3" mid-chapter, or an appendix restarting at 1.x) are rejected
a job that reads across ALL your contexts once to make one combined view (e.g. "what exists in one stack but not the other"), as opposed to a per-context job that only looks at its own room
product-led growth (self-serve sign-up) vs selling via demos + contracts; PLG is the only lane for a solo builder with no sales team
in AI governance, the single decision point an autonomous system passes before it acts (policy/risk/permission/human-approval checks) — here, the autopilot's go-gate
an automated pre-commit check that blocks hardcoded machine-specific paths/secrets, so the code can install cleanly on someone else's machine; it caught the context-router's own hardcoded vault names
assume the plan already failed and write its autopsy, to surface the risks before they happen
generating many pages from one template + a data table (e.g. one page per "X vs Y"), instead of writing each by hand
press a key to record your voice, release/press again to stop; the audio is then transcribed
a rule layer applied after search finds candidates, deciding what comes FIRST: e.g. boost canonical specs, demote raw transcripts, prefer newer notes. Fixes "the right note is in there but never on top"
reusing accumulated skills/answers so the system does not re-derive the same reasoning every time
when two records of the same fact fall out of sync because an update landed in one but not the other (e.g. a venture's progress noted in the journal but not the file the radar reads) — the failure that makes an automated system "remind" you to do something already done
a check that runs when something changes and blocks the ship if quality dropped; gates catch breakage at change-time, while an improvement loop also measures quality over time between changes
letting the system rewrite a judge's scoring criteria (its "rubric") and keep the new version only if it judges more accurately against your labelled examples
teaching a term step-by-step: say it plain → name it → reuse it, so it sticks
one exact, agreed phrase a system emits to signal a specific state (e.g. a refusal), so detection can match the whole signal instead of guessing from fragments
the % of AI answers on your topic that mention or cite you; the AEO success metric, not clicks
a process-mapping shorthand (Suppliers · Inputs · Process · Outputs · Customers) for describing a process end-to-end in one line
counting each item by how big it was, not just how many there were (here: small work=1, medium=3, large=6), so a few big sessions outweigh many tiny ones
restating a request back as the task about to be executed (goal, scope, assumptions) so the asker corrects the restatement instead of rewriting their prompt; cheaper than "prompt engineering" because the burden of precision moves to the answerer
a research technique: ask the same question from several different expert viewpoints, map where they disagree, then synthesise — so you get past the surface "majority" answer
one control that flips between two states; here one hotkey = press to start recording, press again to stop
a deterministic script that re-fetches every source a draft cites and drops anything it can't confirm; the machine check that replaces human review before publishing
Apple's signed archive format; double-click to unpack (how Xcode ships outside the App Store)
shorthand for "accessibility" (a + 11 letters + y): whether a page works for keyboard, screen-reader and colour-blind users — e.g. never signalling status by colour alone
the SEC's unique ID for one EDGAR filing (like an invoice number for a submission); knowing it lets you link straight to the original filing document
a second AI that did NOT write the code attacks it hunting real defects; findings are verified (or refuted with proof), never obeyed blindly
a law whose articles only edit another law ("in Article 18, replace…"); thin as a standalone document — the content belongs inside the consolidated base text
a rough draft video of storyboard stills cut to the narration track, used to check pacing before expensive animation; the last cheap change point
you can only add entries, never edit or delete old ones — keeps a tamper-evident history
replacing live data in one indivisible step (build the new copy beside the old, then rename it over): readers never see a half-updated state
the rules a platform makes you agree to; breaking a category ban (e.g. "advisory") can get your account rejected
a marked region in a document that a script rewrites from ground truth, so the numbers are never hand-typed and two docs can't disagree
halve the range each try; how the compressor finds the best quality that still fits your size target
finding a bug by repeatedly cutting the suspect area in half and re-testing until one piece is left holding the blame
tracking two clocks on each record: when a fact was true in the real world (the register's own change date) AND when your system recorded it — needed because a source's change date isn't the same as when you pulled it
the "Home / Section / Page" trail at the top of a page; it tells a reader (and a search engine) where the page sits in the site's hierarchy
a register's own "entire database as one download" offering, as opposed to querying one record at a time
a macOS command that stops the Mac going to sleep while a job runs, and lets it sleep again the moment the job ends
a macOS command that keeps the Mac awake so a long overnight job isn't paused by sleep
checking whether your stated confidence matched reality — were your 70%-sure calls right about 70% of the time?
the US law permitting unsolicited B2B email if headers are honest, unsubscribe works, and a postal address is shown
a map that shades each area by a value (e.g. companies per 100k people); the standard "coloured regions" statistical map
a robot that runs your tests on every code change and blocks broken code from going live
a rule that colours a cell automatically based on what's in it (or in another cell), rather than you shading it by hand
a table that scores a classifier by counting, for each category, how often it guessed right vs which wrong category it picked — how you measure a router/tagger's accuracy
a cluster where every member is reachable from every other through the links; here, a corporate "family" joined by ownership edges
EUR-Lex's ID for a law *with all its amendments folded in* (starts `0…`); the `3…` ID is the text as first published, which silently goes stale as amendments land
the four things you ever do to data: Create, Read, Update, Delete
when a buyer discovers you inside an AI chat but arrives later via a branded Google search, so the referral looks like it came from Google, not the AI that actually recommended you
making new training examples by modifying existing ones, e.g. dirtying clean text to mimic a bad scan while keeping the clean version as the answer key
a structured store of data plus the software (the database management system) that holds it, enforces its rules, and answers questions — a spreadsheet that grew up and got a manager
a rarer zip compression variant Python can't read; Florida's registry zip needs the system unzip tool streamed instead of extracting
a register's daily/weekly "what changed" file, so you fetch only new or changed records instead of re-downloading the whole register
a source's "what changed since yesterday" channel (just the diffs), so you download the handful of changes instead of the whole multi-GB file each refresh
a guard that blocks an action a single time to make you pause, then clears itself for ~10 min so you just re-issue — a nudge, not a wall
a named design value (a colour, a spacing step, a font size) defined once in the stylesheet and reused everywhere, so changing it once changes the whole site
finding that a record exists, versus adding detail to one you've already found
an empty flag file a job drops when it finishes so it won't repeat; if it's never cleared, the job silently stops running
multiply two lists of numbers pairwise and add the results into one score of how much they "agree"; the single operation behind semantic search and (at scale) a transformer's attention
the oversized first letter that opens an article, a print-magazine touch
Google's trust scorecard for a source: Experience, Expertise, Authoritativeness, Trustworthiness
one health metric counting another health metric's failure as its own, so a single problem rings twice
the EU bridge that lets one country's digital identity (like Denmark's MitID or Belgium's itsme) log into another EU country's public services
EUR-Lex's stable per-law landing page (`eli/dir/2011/61/oj`) that always shows the date of the law's *current* consolidated version — the freshness signal a date-pinned snapshot URL can't give you
a hold that stops something publishing until a set time — here a 7-day floor: a deep-read can't go public until a full week after it reached you
a shell safety setting that stops a script the instant any command fails; great for catching breakage, but it can kill a script before its own error-recovery code gets to run
the file permission that marks a script as runnable; the system refuses to start a script without it
the number a program returns when it finishes: 0 means success, anything else means it failed (how a script knows whether to carry on)
when the main tool fails, an automatic switch to a backup that does the job instead, so the work still completes (here: Claude → Codex when Claude is logged out)
a hash of a source page/PDF; if the hash changes, the source changed and we re-check it
code that sends something (a message, a file) without checking whether it arrived; fast and simple, but a failure is invisible — the log says "sent" even when nothing was delivered
a fault that keeps toggling: fixed, then breaks again, then fixed again; a repair loop like that signals a deeper root cause, not a bad repair
a minimum-count sanity check: if a data pull comes back implausibly small (e.g. Ireland's register < 15,000 rows), fall back to the last good copy and alert, instead of importing the too-small result — catches a lone broken source that a percentage-drift band would miss
matching each spoken word to its exact moment in an audio file, so on-screen text can highlight in sync as it's read aloud
an element or rule that runs edge-to-edge across the whole page instead of stopping at the centred content column (a too-wide rule over narrower text looks misaligned)
documents where the correct answers are human-verified, so you can score an AI against them
GLEIF's full daily republication of the global LEI database, downloaded whole rather than queried per-entity
"when a measure becomes a target, it stops being a good measure"; the main way self-improving systems break, and why you also check that the grader itself still agrees with you
when a feature can't run, it does nothing harmless instead of erroring — a clean no-op
Google's free dashboard showing how your pages appear in search: impressions, clicks, average rank
a tag telling Google "this page has FR/DE/HI versions — show the right one per user"; without it the language versions compete against each other
building a site so its text/UI can be swapped per language without touching the code
the standard calendar-file format (one file holds many events) you can open or import into Outlook/Google Calendar
the standard calendar-file format (.ics); publishing one lets readers subscribe so your deadlines appear inside their own Outlook/Google calendar
a score for how rare a word is; rare words identify a document, common ones don't
a pre-sorted lookup the database keeps so it finds rows instantly instead of scanning every one
a protocol that instantly tells search engines (Bing, and thus ChatGPT's index) which pages just changed, instead of waiting days for them to re-crawl
a ping that tells Bing/Yandex a page changed so they re-crawl in minutes, not weeks
a change is tried, the result is scored, and it's kept only if the score improved (else undone); how a system self-improves without making things worse
the slow zoom/pan a video applies to a still image so it feels filmed rather than static (named after the documentary maker)
two of your own pages competing for the same search term, so neither ranks as well as one strong page would
Legal Entity Identifier, the global 20-character ID for a company in financial markets (ISO 17442); the bridge that links one register to another and to the ownership graph
a word's dictionary form; "tengo" belongs to the lemma "tener", which is how tapping any conjugation still finds the verb
a file that records the EXACT pinned version of every library installed (e.g. `requirements.lock.txt`), so the same setup rebuilds identically on another machine
the width of a text column; ~60–80 characters per line reads best, so a too-wide text block reads as a "wall"
a checkout service (e.g. Gumroad, Lemon Squeezy) that is legally the seller of your product, so it collects and remits the sales tax/VAT for you instead of you registering yourself
the EU's standard industry-code system; every register uses a NACE-family activity code, so mapping to it gives one sector language across countries
a nickname you give a block of cells (e.g. `LST_Country`) so formulas and dropdowns refer to the name instead of the address; a *dynamic* one resizes itself when the block grows
the one finished page a team measures every other page against, so the site stays visually consistent instead of drifting page by page
a login method for machines: instead of a username/password you hold a client-ID + secret, swap them for a short-lived token, and send the token with each request. The token expires and auto-renews, so you register once and never re-login
optical character recognition: reading the letters out of an image (a photo, screenshot, or quote-card) so the text becomes searchable. Runs on-device here via Apple Vision
a compact columnar file format for big tables; lets you query 40M rows straight off disk without loading it all into memory
a doc shrunk to a short note that just links to where the real content now lives, killing a duplicate copy that would otherwise drift
one cheap test call before an expensive batch job, so a broken setup fails loudly in seconds instead of silently wasting the whole run
a check that runs before code leaves your laptop and refuses the push if something is stale or wrong
two scores for a search result list: precision@k = of the top k results, how many were relevant; recall@k = of all the relevant items, how many showed up in the top k
a row's unique ID / that same ID stored in another table to link them, giving a one-to-many relationship (store each fact once)
a single page listing every account, key-NAME and login a machine rebuild needs (names only, never the secret values)
disk space macOS can silently reclaim when needed (old caches, synced files); Finder counts it as "free" but `df` doesn't — which is why free-space numbers jump around and `df` is the number installs actually fail against
the Mac quietly slows 'background-priority' processes (less CPU, slower network); why a long crawl launched in the background ran near-idle until relaunched at a higher priority class
betting a quarter of the mathematically "optimal" stake size, because the optimal formula assumes you know your edge exactly and you never do; the professional standard for sizing
the share of the real population a filter actually catches; the rest is silently missed
Google's "I'm not a robot" bot-check (a checkbox, sometimes an image puzzle); each pass is a single-use token that expires in ~2 min, so a script can't reuse one — bulk data pulls behind it need a human solve per request, which is why some registers (Cayman CIMA) stay out of reach
a login is two keys: a short-lived *access token* (used for each call, expires in hours, auto-renewed) plus a longer-lived *refresh token* that does the renewing; when the refresh token itself expires you're logged out and must sign in by hand
the pile of items waiting on the human's yes/no across a system, measured as a count + the oldest item's age; unmeasured, it silently outgrows the human
feed a generated document back through extraction and confirm you get its known answers back; proves the data and its labels agree
the tiny call a web page makes as it loads so analytics can count a real visitor; if it fires, measurement is live even when no tracking code appears in the page's source files
instead of overwriting a record when it changes, you close the old version and open a new one, each stamped valid-from/valid-to — so you keep the full history of how a company's name/address/status changed over time
the blueprint of a database: which tables and columns exist and what type each holds; the rulebook a plain spreadsheet lacks
hidden machine-readable labels describing what a page or tool is, so search engines and AI understand it
a scanned image with an invisible text layer behind it, so you can select and search it
the page of results a search query returns; a "SERP gap" = a query where no good page exists yet, i.e. an open ranking opportunity
the background script that caches a site so it keeps working offline (the engine behind a PWA)
a small extra app target that makes your app appear in other apps' Share sheets; document-type registration alone only gets you into Files and "Open in"
the % of a fixed set of test questions where the AI engines cite your site; the honest metric for AI visibility, since AI referral clicks are largely unattributable
the self-declared industry classification every UK company files (e.g. 64304 = open-ended investment company); a proxy, not a verified fact
installing an app onto your own iPhone directly from a Mac with a cable, without the App Store
a web page that loads nearly empty and builds its content in the browser with JavaScript; a plain fetch/scraper gets the empty shell, not the text
dividing test cases into groups by what matters (e.g. pass vs fail examples) and drawing from each group, so no half of a train/test split accidentally misses the signal entirely
one fully finished still image in the proposed look of a video, approved BEFORE any scenes are produced — so a taste change never forces re-making everything
Apple's official beta-testing channel for sharing an unreleased app with testers; needs the paid developer account
the invisible, selectable text hidden behind a PDF's visual page; extraction reads this layer, so a corrupt one (doubled letters) or a missing one (a scan) breaks text tools even though the page *looks* fine
a search that returns the k closest matches degrades as the collection grows: near-miss entries crowd out or pad the truly answering ones
the 6-digit rotating code (Google/Microsoft Authenticator) that is your second login factor; back it up or you lock yourself out if the phone dies
splitting labelled examples into two halves: tune on one ("train"), check on the other ("test") — so the system can't just memorise the answers it was shown
a bundle of changes done all-or-nothing / the four reliability guarantees (Atomic, Consistent, Isolated, Durable) — why money data lives in a database, not a spreadsheet
a library you didn't ask for directly; it got installed only because something you DID choose needs it (vs a "direct" dependency you picked yourself)
how long a credential (or cached item) stays valid before it auto-expires; a security dial: shorter = a leak dies sooner, but you must renew before it lapses or the automation stops
"terminal user interface": an interactive app that runs inside the Terminal window (typing `codex` opens one), as opposed to a graphical desktop app
a fast algorithm for grouping connected things into clusters; here it walks ownership links to collapse companies into one "family"
a database write that inserts a record if it's new or updates it if it already exists ("update-or-insert" in one step); bulk APIs often cap how many you can send per request
a database write that inserts if new, updates if it already exists; it never deletes — why removing a source file doesn't remove the search vectors it already created
the EU's free VAT-number validation service; a live check that a company's VAT registration is still active
testing a strategy so every decision uses only data available at that moment in the past, never hindsight; the honest way to backtest
near-native code that runs inside the browser page itself; how heavy tools (image/PDF engines) can stay "nothing leaves your device" on the web
a calendar you subscribe to by URL that auto-refreshes, versus a one-time .ics file you import
Apple's framework that drives an app's real UI in tests (taps buttons, reads the screen) so "it works" is proven by a machine
health/legal/finance pages Google holds to a higher trust bar because bad info can harm someone
a command-line tool that downloads video/audio from YouTube, X, Vimeo etc. (and can pass your saved login cookies to reach authed content); here it pulls a post's audio so Whisper can transcribe it locally