Skip to main content
Signal Over Noise
  • Search
  • Topics
    • Security & Risk
    • Agents & Tooling
    • Working with AI
    • Building
    • The Industry
    • All topics
  • Latest
  • Guides
  • About
  • Members
  • Subscribe

Glossary

Plain definitions of AI and integration terms, with what we've learned from actually using them.

Showing 114 of 114 terms

The Signal Over Noise Take

Authenticator app 2FA — not SMS, not email-based — is the single most important thing you can do to secure your accounts. A close family member lost their email completely. Not “forgot the password” lost. Fully taken over — recovery email changed, recovery phone changed, locked out completely. If they’d had app-based 2FA enabled, none of it would have happened. The distinction matters: SMS-based 2FA is vulnerable to SIM swapping. Email-based 2FA is useless if your email is what’s been compromised. App-based codes from Google Authenticator or Authy can’t be intercepted remotely. Set it up before you need it.

Read more in:

  • SoN-31 When They Take Your Email

    Authenticator app 2FA identified as the single most important defence against email account takeover

Visit Agent SDK

The Signal Over Noise Take

The Agent SDK is how you build Claude into your own systems rather than just using Claude’s systems. It’s the difference between using someone else’s agent and deploying your own. The SDK handles tool use, state management, and multi-step execution. In March 2026, Anthropic clarified that personal use with Max subscriptions is still permitted — the restriction is on third-party services routing through consumer accounts.

Related terms:

  • claude code
  • mcp
  • ai agents
  • claude

Read more in:

  • V2-01 Stop Prompting Better. Start Programming Your Gaps.

    Building agent-based systems that can reason and act autonomously

The Signal Over Noise Take

Everyone wants to build agents. The word sounds impressive, and the demos look magical. But in my experience, premature agents are one of the most common failure modes in AI implementation. An agent makes sense when the domain is complex enough to need judgment, when multiple related tasks benefit from shared context, and when the problem evolves. For everything else, you want a skill — a repeatable recipe that does the same thing every time. I have 30 custom agents in my setup, but I built them after months of using simpler skills first. Start with recipes. Graduate to agents when the domain earns it.

Related terms:

  • skills
  • orchestration
  • mcp
  • llm

Read more in:

  • V2-02 The Art of Breaking Things Down

    Defines agents as 'experts' — specialized roles with context and judgment, contrasted with skills as 'recipes'

  • V2-04 The Orchestration Loop

    Warns that premature agents are a trap — start with skills, graduate to agents when the domain earns it

The Signal Over Noise Take

Alignment sounds abstract until you watch your AI confidently claim your work includes projects you never built, or enthusiastically agree with your bad ideas because it’s trained to be agreeable. At the personal level, alignment is about building a system that actually serves your interests — not one that tells you what you want to hear. At the species level, it’s what Geoffrey Hinton is worried about: we’re building systems that process information beyond human capacity while assuming they’ll behave like better versions of current tools. There’s no technical basis for that assumption. The gap between what we can build and what we understand about controlling it keeps widening.

Related terms:

  • guardrails
  • ai safety

Read more in:

  • SoN-29 The Godfather of AI's Warning

    Geoffrey Hinton argues we don't understand AI systems well enough to guarantee control

The Signal Over Noise Take

Companies developing AI spend far more on pushing capabilities than on safety research. The incentive structure rewards speed — whoever gets to market first wins. Whoever pauses to ensure safety falls behind. Hinton’s point isn’t that we should stop development; that’s not realistic. It’s that we should demand safety research, push for regulation, and treat AI safety as seriously as we treat drug safety or aviation safety. The near-term risks — job displacement, misinformation, malicious use — aren’t future concerns. They’re already here while we debate whether AI poses existential risks.

Related terms:

  • ai alignment
  • guardrails

Read more in:

  • SoN-29 The Godfather of AI's Warning

    Hinton advocates mandatory safety testing before deployment and investment matching capability research

The Signal Over Noise Take

People unconsciously detect AI writing and trust it less — even when they can’t articulate why. The tells aren’t just individual words, though “delve” and “game-changer” are reliable flags. It’s structural patterns: three consecutive short declarative sentences (staccato fragments), “This isn’t X, it’s Y” comparisons, perfect grammar with zero original insight. The 30-second test: could this content have been written for anyone in my industry? If yes, it’s slop. I built The AntiSlop to catch 35+ of these patterns before publishing, because phrase-based detectors miss the structural tells. The fix isn’t stopping AI use — it’s teaching AI your voice and editing ruthlessly.

Related terms:

  • ai voice
  • prompt engineering

Read more in:

  • SoN-25 Writing With AI Isn't Cheating

    Detects AI slop patterns including vague superlatives, flattery sandwiches, and the 30-second test

  • V2-04 The Orchestration Loop

    Introduces The AntiSlop — a tool that detects 35+ AI writing tells across content, language, style, and structure

The Signal Over Noise Take

AI should make you more efficiently yourself — not more formal, not more impressive, just more clearly you. I built a style guide by feeding AI ten pieces of my best writing and asking it to analyze the patterns. It told me things I didn’t consciously know: “You use short, punchy sentences after longer explanatory ones for emphasis.” “You frequently start sentences with ‘But’ and ‘And’.” After three months of iteration, the guide went from one page of generic observations to three pages of specific patterns. The “don’t” list matters more than the “do” list — “don’t use ‘moreover’ or ‘furthermore’” is clearer than “be casual.” If someone who knows you couldn’t identify the output as yours, keep editing.

Related terms:

  • prompt engineering
  • system prompt
  • ai slop

Read more in:

  • SoN-25 Writing With AI Isn't Cheating

    Frames AI as an accessibility tool for voice amplification, not replacement

  • SoN-26 Building Your AI Style Guide

    Step-by-step system for building a living style guide that teaches AI your writing patterns

The Signal Over Noise Take

Allowancemaxxing, for me, is making sure I’ve used as much of my allowance windows as I can, for the weekly limits on my Max plans across Anthropic, OpenAI and Cursor. If I get to within a day of a reset and I’ve only used a small percentage, it feels almost like FOMO. It’s like a waste. It’s my own reading of what tokenmaxxing could be, because to me it makes more logical sense than just spend, spend, spend. The habit is simple: know how much allowance you have left and when it resets, and keep a list of low-level donkey work ready to start when there’s plenty left. Saved limit resets are the get-out-of-jail-free card for the other problem, running short before the reset, so use them with caution.

Related terms:

  • tokenmaxxing
  • tokens

Read more in:

  • Essay Use your Claude, Codex and Cursor usage limits before they reset

    Where the term comes from: using your plan's allowance before it resets, and what to do when it runs out first

The Signal Over Noise Take

APIs are the thing that separates “I had an interesting conversation with AI” from “I built something that runs.” They’re what let the AI’s output reach beyond a chat window and actually affect the world — deploy code, send alerts, create calendar events, query databases. Before AI, having an API available on a service wasn’t that relevant to most people — what would you do with it if you couldn’t write code? Now your AI can write the code. Which makes “does it have an API?” the first question I ask before adopting any new tool. If the answer is no, that tool is a dead end for AI integration.

Related terms:

  • cli
  • webhook
  • mcp
  • n8n

Read more in:

  • V2-11 The Helpers

    APIs are the primary 'helpers' that let AI output reach into the real world and do something

  • V2-08 The Co-Operating System

    DNS API calls, certificate provisioning, and deployment commands powered the server migration

The Signal Over Noise Take

Attention is how a model decides what to look at. Reading a long document, it doesn’t treat every previous word as equally relevant; it scores them and leans on the ones that matter for the word it’s producing now. That’s the whole reason these systems handle context at all. It’s also the expensive part — the cost of comparing everything to everything grows fast with length, which is why context windows have limits and why most architecture research is really about making attention cheaper. When a model “loses the thread” halfway through a long input, this is the machinery that’s straining.

Related terms:

  • context window
  • positional embeddings
  • parameters
  • llm

Read more in:

  • Essay Kimi K3 Is Open. I Still Can't Run It.

    Multi-head latent attention, and a new attention-residual mechanism across layers

The Signal Over Noise Take

Automation is the part where AI stops being a conversation and starts being infrastructure. But there’s a trap: AI makes building automation feel so easy that you can end up automating things that don’t need automating. I built workflows that trigger other workflows and mapped out a ten-phase app roadmap before writing a single line of code. That’s not productivity — that’s a treadmill. The diagnostic question: does this automation have a stopping point that isn’t “when I decide to stop”? Five minutes of weekly invoice filing beats two hours of quarterly scrambling. That’s good automation. Building systems that support other systems indefinitely is the treadmill.

Related terms:

  • n8n
  • webhook
  • orchestration
  • skills

Read more in:

  • V2-02 The Art of Breaking Things Down

    Distinguishes between automation (skills/recipes) and judgment (agents) when decomposing problems

  • V2-11 The Helpers

    A health check system running automatically every six hours with zero human intervention

  • SoN-32 The Productivity Treadmill

    Warns against building automation workflows that trigger other automation workflows as a treadmill

The Signal Over Noise Take

Public benchmarks are worth something and less than they’re quoted for. Two problems compound: the questions leak into training data, so scores drift upward without capability moving, and a vendor-run benchmark inevitably measures what that vendor is good at. Treat a self-published result as a claim, not a finding, until someone independent reproduces it. The benchmark that actually matters is the one you build yourself — thirty real examples from your own work, with answers you can check. It takes an afternoon, it’s not impressive enough to publish, and it will tell you more about which model to use than any leaderboard will.

Related terms:

  • frontier model
  • fine tuning
  • model routing
  • parameters

Read more in:

  • Essay The Donkey Work Doesn't Need a Genius

    Their own benchmark, on their own task, not independently reproduced

  • Essay Kimi K3 Is Open. I Still Can't Run It.

    A small, consistent gain in validation loss and downstream benchmarks

The Signal Over Noise Take

Blast radius is the question that survives every fashionable security debate, and it’s the right one to ask about AI agents. Most agent incidents aren’t breaches; nobody steals anything. An agent does something reasonable-looking with more access than the task needed, and the damage is measured by what it could reach. Note that this is not the same problem as vulnerable code, even though both get filed under “security” — scanning the code an agent touches says nothing about what the agent can do while running. Before granting access, ask what the worst plausible action would cost, then grant the narrowest credential that still does the job.

Related terms:

  • least privilege
  • scoped token
  • zero trust
  • incident response
  • ai agents

Read more in:

  • Essay OpenAI Published Its Homework on Exactly the Question I Keep Asking

    What the agent itself can do once running: credentials held, files writable, damage possible

The Signal Over Noise Take

AES is the workhorse: your disk encryption, your HTTPS sessions, your password manager. It’s also the most heavily attacked algorithm in existence, which is precisely why it’s trusted — decades of people trying to break it and mostly failing. That context matters when a headline announces an attack. Most published results target reduced-round versions, a deliberately weakened variant used as a research proving ground, and say nothing about the full cipher you actually rely on. The honest reading of such a result is that the margin of safety narrowed slightly, not that anything you use is broken.

Related terms:

  • post quantum cryptography
  • red teaming
  • two factor authentication

Read more in:

  • Essay "AI Found a Security Bug" Is the Wrong Headline

    A new attack technique against reduced-round AES-128

The Signal Over Noise Take

If the same article sits on your site, Medium and LinkedIn, search engines have to pick one to treat as the real one — and left to themselves, they may not pick yours. A canonical tag is you making that call explicitly: this address is the original, the rest are copies. It’s a single line of HTML, most publishing platforms have a field for it, and cross-posting without setting it is how people end up watching someone else’s domain outrank them for their own writing. If you’re syndicating anything anywhere, this is the one technical detail worth getting right.

Related terms:

  • posse
  • pesos
  • noindex
  • web crawler

Read more in:

  • Essay Substack Writers, You Need a Website

    The version that still exists after any of those platforms pivots

Visit ChatGPT

The Signal Over Noise Take

ChatGPT is the tool most people start with, and there’s nothing wrong with that. It’s excellent for specific tasks and its Custom GPTs feature is a reasonable entry point for building persistent AI setups. Where it falls short for me is integration — ChatGPT’s Code Interpreter works with uploaded files, but it doesn’t live in your terminal or connect to your local system the way Claude Code does. If you’re using ChatGPT, the PAST Framework works just as well there. And read OpenAI’s own prompting guide — it’s different from Anthropic’s, because the models have genuinely different preferences for how you structure requests.

Related terms:

  • llm
  • custom gpts
  • claude

Read more in:

  • V2-10 Same Prompt, Different Model, Worse Results

    ChatGPT emphasises message roles and system messages for persona — different prompt dialect than Claude

  • SoN-23 One Year of Writing About AI

    Still used regularly for specific tasks despite Claude being the primary tool

  • SoN-30 Four Questions That Fix Your Prompts

    References ChatGPT as a tool where the PAST Framework applies to fix vague prompting

Visit Claude

The Signal Over Noise Take

Claude is my primary AI tool, and I’m transparent about that. I chose it not because it’s the “best” model in some abstract sense, but because MCP integration made it the most connected tool in my stack. It reads my files, executes tasks, and operates from persistent context. It also prefers XML tags for prompt structure, handles 16,000+ word system prompts well, and will honestly tell you what it’s bad at if you ask. That said, I still use ChatGPT and Gemini for specific tasks. The model matters less than the connection to your actual work.

The multi-model reality is worth noting. Microsoft chose Claude over GPT to power Copilot Cowork — their flagship M365 agent feature — despite a $13B investment in OpenAI. That tells you something about where model quality stands. Opus 4.6 with 1M context at flat pricing (no long-context surcharge) makes it the most capable reasoning engine I’ve used. But capability without integration is just a benchmark score. Claude wins in my stack because it connects to everything.

Related terms:

  • claude code
  • mcp
  • llm

Read more in:

  • V2-01 Stop Prompting Better. Start Programming Your Gaps.

    Claude's most capable models used during a twelve-day experiment building a full brain system

  • V2-06 The Talking Wrench

    Claude will tell you it sometimes fabricates citations — one of the known limitations it openly shares

  • V2-10 Same Prompt, Different Model, Worse Results

    Claude prefers XML tags for structure and handles massive system prompts well

Visit Claude Code

The Signal Over Noise Take

Claude Code changed what was possible. Before it, AI lived in a browser tab — you’d copy context in, copy output out, and nothing connected. Claude Code lives in your terminal, reads your files, updates your notes, references past decisions. It’s the reason my co-operating system works at all. But it’s also where maintenance debt accumulates fastest. I run 96 skills, 30 agents, and a 16,000-word system prompt through it. That system is powerful and also fragile — 95 minutes of weekend maintenance revealed silent failures I hadn’t noticed. The tool is transformative. It also needs tending.

March 2026 moved the needle again. Voice mode lets me issue commands hands-free while working on something else. /loop runs session-scoped cron jobs — I use it for monitoring tasks that check every few minutes. Code Review dispatches multi-agent teams to check PRs for $15-25 each, and MCP elicitation means connected tools can pause and ask me for input mid-task instead of guessing. Claude Code is evolving from “assistant you type to” into “assistant that runs alongside you.”

Related terms:

  • mcp
  • cli
  • co operating system
  • claude

Read more in:

  • V2-01 Stop Prompting Better. Start Programming Your Gaps.

    Claude Code as the terminal-native AI that reads files and executes tasks — the catalyst for the co-operating system

  • V2-10 Same Prompt, Different Model, Worse Results

    96 skills running inside Claude Code, with maintenance challenges at scale

The Signal Over Noise Take

AI generates more code than humans can review. Claude Code Review is the logical response: multi-agent teams that check PRs for different issue types, then verify and rank findings. At Anthropic internally, substantive review comments went from 16% to 54% of PRs. The price — $15-25 per review — tells you this is premium quality tooling, not a free feature. The self-referential loop (AI reviewing AI code) is either a virtuous cycle or a fragility. Time will tell which.

Related terms:

  • claude code
  • ai agents
  • claude

Read more in:

  • Insight Agents Reviewing Agent-Generated Code

    Claude Code Review dispatches parallel AI agents to check PRs — 54% substantive review rate vs 16% before

The Signal Over Noise Take

The most interesting thing about Claude Cowork isn’t what it does — it’s where it lives. Microsoft built their flagship M365 agent feature on Claude, not GPT, despite a $13B investment in OpenAI. That’s a $30/user/month bet on Anthropic inside Microsoft’s own platform. For anyone still debating single-vendor AI strategies, the debate is over. If Microsoft is hedging, you should be too.

Related terms:

  • claude
  • mcp
  • ai agents

Read more in:

  • Insight Microsoft Built Copilot Cowork on Claude, Not GPT

    Microsoft chose Anthropic's Claude as the engine for their flagship M365 agent feature

The Signal Over Noise Take

This is Anthropic’s answer to the adoption gap. You can build the best model in the world, but enterprises adopt through partners and consultants, not API docs. The $100M investment and “Claude Certified Architect” credential signal that Anthropic understands implementation is the bottleneck — not capability. For consultants and implementation specialists, this is worth watching closely.

Related terms:

  • claude
  • claude code
  • integration over capability

Read more in:

  • Insight Claude Partner Network and Certification

    Anthropic's $100M investment in partner ecosystem with professional certification

The Signal Over Noise Take

CLI tools are the unsung heroes of AI integration. I have command-line wrappers for my email service, financial tracking, automation platform, note-taking vault, and browser rendering. Each one means AI can reach a tool that previously required opening a browser and clicking through a UI. That’s a fundamentally different level of access. When people ask how AI “does things” on my system, the answer is almost always “through a CLI.” The terminal is where AI stops being a conversation partner and starts being a collaborator that can actually execute.

Related terms:

  • api
  • mcp
  • claude code

Read more in:

  • V2-11 The Helpers

    CLI tools give AI a fundamentally different level of access — reaching tools that previously required a browser UI

  • SoN-23 One Year of Writing About AI

    Command-line work split across three AI systems for different tasks

The Signal Over Noise Take

Closed weights is the default for frontier models, and the trade is straightforward: you get the best capability available with no infrastructure to manage, and in return you can’t run it yourself, can’t audit it, can’t pin a version the provider retires, and can’t stop your prompts leaving your machine. What’s changed is that the line has stopped being about openness alone. A model can be open-weight and still effectively closed to you if running it needs 1.4 terabytes of memory — you’re renting access from someone with the hardware either way. The useful question isn’t “are the weights public?” but “could I actually run this if I had to?”

Related terms:

  • open model
  • open source
  • api
  • vendor lock in
  • frontier model

Read more in:

  • Essay Kimi K3 Is Open. I Still Can't Run It.

    A lab or a well-capitalised provider can run K3 and rent access to it

Visit Cloudflare Workers

The Signal Over Noise Take

Five dollars a month. That’s what it cost to go from “thinking about infrastructure” to “running infrastructure.” By late Sunday I had a health check system pinging five websites every six hours, storing results in a database, and alerting me via Telegram if anything went down. The AI wrote the Worker code, but the reason any of it actually worked was the helpers — Cloudflare’s API for deployment, D1 for storage, webhooks for routing. Workers are the kind of tool where “does it have an API” matters more than benchmarks, because the API is what lets AI build on top of it.

Related terms:

  • d1
  • api
  • cron job

Read more in:

  • V2-11 The Helpers

    A $5/month Workers upgrade enabled building a health check system, browser rendering tool, and edge architecture plan in one evening

The Signal Over Noise Take

Co-operating, because you work together. Operating system, because it’s infrastructure, not an app. This is the concept that ties everything I write about together. Your computer has an operating system that manages files and runs programs, but your knowledge work has no equivalent. Notes live in one app, tasks in another, and your AI assistant knows nothing about either. A co-operating system is the missing layer. The moment that made it click for me: AI connected a VPS pricing conversation from Saturday afternoon to an SSL certificate problem that evening — two unrelated conversations, one useful connection — because the context was shared. That’s the difference between a system and a session.

Related terms:

  • orchestration
  • context compounding
  • integration over capability

Read more in:

  • V2-01 Stop Prompting Better. Start Programming Your Gaps.

    Introduces the concept — AI and your brain working the same files, from the same context, toward the same goals

  • V2-08 The Co-Operating System

    A weekend server migration demonstrates the co-operating system in practice — context from one conversation informing decisions in another

The Signal Over Noise Take

A context window is finite and attention across it isn’t uniform, so every token spent on something irrelevant is a token not spent on your actual problem. That much is obvious. What isn’t obvious is that clutter almost never arrives by decision — it accumulates. Files loaded automatically because they matched a naming convention. Instructions from a project you finished in March. A conversation forty turns deep, still carrying the dead end you abandoned at turn six.

The insidious part is that it’s invisible from the inside. The model doesn’t announce what it’s carrying, and the output degrades in a way that reads like the model getting worse rather than the input getting noisier. I found a live example on my own site: a glossary entry filed as claude.md was, on a case-insensitive filesystem, indistinguishable from the CLAUDE.md convention — so a paragraph of marketing copy about Claude was being loaded as project instructions in every session. Harmless content, silently occupying the slot reserved for actual instructions.

The habit worth building is periodic subtraction. Ask what’s being loaded automatically and whether each piece is still true, still relevant, and still worth its space. This is the exact inverse of context compounding — the same mechanism, pointed the wrong way. Context that’s curated makes a model sharper over time. Context that merely accumulates makes it vaguer, and nothing in the tooling will tell you which one you’ve got.

Related terms:

  • context window
  • context compounding
  • tokens
  • system prompt
  • metadata

The Signal Over Noise Take

This is probably the single most important concept in this entire glossary. Most people use AI in sessions — one question, one answer, start fresh next time. A system remembers, builds on itself, and sometimes connects two unrelated conversations into something neither of you planned for. My setup surfaced a connection between a book I’d read in January and a gap in a consulting methodology I’d been refining since November. I wouldn’t have made that connection manually — not because I’m not capable, but because I’d never have had both things in front of me at the same time. Time invested today pays forward.

Related terms:

  • co operating system
  • context window
  • context clutter
  • orchestration

Read more in:

  • V2-01 Stop Prompting Better. Start Programming Your Gaps.

    Every conversation that builds on the last is worth ten that start fresh

  • V2-08 The Co-Operating System

    VPS pricing research from one conversation informed an SSL decision in another — because context was shared

  • V2-09 The Mirror and the Telescope

    Monday's notes inform Tuesday's connections — the compound effect of persistent context

The Signal Over Noise Take

Context window size matters less than context quality. I run a system prompt over 16,000 words long in Claude, and it works because every word earns its place. The trap is thinking a bigger context window means you can just dump everything in and let the model sort it out. In practice, what you put in the window — and how you structure it — determines whether the AI actually uses the information or quietly ignores it. Different models also have different preferences for where in the window you place instructions, which is one reason your prompts don’t travel between platforms.

The pricing change in March 2026 matters more than the size increase. Anthropic eliminated the long-context surcharge — 1M tokens at flat pricing. Previously, using the full context window cost significantly more per token, which meant most production systems stayed well under the limit to control costs. Now 1M context is economically viable for real workloads: entire codebases, full document sets, multi-hour conversation histories. The constraint shifted from “can you afford the tokens” to “can you structure the context well enough for the model to use it.”

Related terms:

  • llm
  • tokens
  • system prompt
  • context clutter

Read more in:

  • V2-10 Same Prompt, Different Model, Worse Results

    Discusses how Claude handles massive system prompts — over 16,000 words — within its context window

  • V2-01 Stop Prompting Better. Start Programming Your Gaps.

    The shift from sessions to systems depends on AI maintaining context across conversations

The Signal Over Noise Take

CI is the least glamorous idea in software and one of the most load-bearing: a check that runs automatically on every change is worth several that depend on someone remembering. It matters more now that AI writes a large share of the code, because volume has gone up and the review budget hasn’t — CI is where you put the checks that don’t get skipped when you’re in a hurry. One caveat that applies to any automated gate: a check you have never seen fail isn’t known to work. Break something on purpose once and confirm the pipeline goes red.

Related terms:

  • automation
  • guardrails
  • blast radius
  • cli
  • sdk

Read more in:

  • Essay OpenAI Published Its Homework on Exactly the Question I Keep Asking

    Codex Security designed to slot into CI, catching findings before a vulnerability ships

The Signal Over Noise Take

Corpus is just the word for “all the text we’re treating as one pile.” What makes it worth naming is that the boundary is a decision someone made: what got included, what didn’t, and who chose. A model’s answers are shaped by that boundary long before anyone writes a prompt. The same applies at small scale — point an assistant at your own document collection and its usefulness is capped by what you actually put in there. When an answer comes back thin, the corpus is usually the place to look before the prompt.

Related terms:

  • training data
  • metadata
  • llm
  • web crawler

Read more in:

  • Essay The ACM's Caution About LLMs Is Starting to Have a Cost

    The ACM's peer-reviewed corpus, and what happens if it stays outside the AI ecosystem

The Signal Over Noise Take

Cron jobs are the unglamorous backbone of automation. No AI, no intelligence, just “do this thing at this time, every time.” My health check Worker runs every six hours on a cron trigger. My weekly invoice filing skill runs every Friday morning. There’s nothing sophisticated about the scheduling — the sophistication is in what gets triggered. A cron job plus a well-built skill equals automation that runs while you sleep, and that’s the whole point. Not everything needs to be intelligent. Sometimes you just need a reliable alarm clock for your code.

Related terms:

  • automation
  • cloudflare workers

Read more in:

  • V2-11 The Helpers

    A Cloudflare Worker running on a cron schedule — every six hours, hitting five sites with health checks

The Signal Over Noise Take

The build order matters. Context is where you start — teach the AI who you are, how you work, what you value. Then encode repeatable procedures as Skills. Then build Agents for domains complex enough to need judgment. Then Integration connects the pieces. Then Iteration makes it better over time. Skip the foundation — jump straight to agents without context — and you get the pattern I see in every struggling AI initiative: impressive demos, limited daily value. The whole architecture is deliberately platform-agnostic. Same principles whether you’re on Claude, ChatGPT, Gemini, or local models.

Related terms:

  • co operating system
  • context compounding
  • skills
  • ai agents

Read more in:

  • V2-09 The Mirror and the Telescope

    Introduces csAIi — five layers (Context, Skills, Agents, Integration, Iteration) with build order that matters

Visit Custom GPTs

The Signal Over Noise Take

Custom GPTs are most people’s first experience of persistent AI context, and they’re a decent starting point. The problem is they rot. If you set one up with your team structure, product lineup, or pricing six months ago and haven’t touched it since, the AI is working from a snapshot that no longer reflects reality. The output still looks plausible — it just isn’t quite right anymore. My bigger concern is lock-in: your context lives inside OpenAI’s platform. If you switch models, that configuration doesn’t transfer. Build your context in portable markdown files instead, and any platform that reads text can use them.

Related terms:

  • chatgpt
  • system prompt
  • silent drift

Read more in:

  • V2-07 Silent Drift

    Custom GPTs with system prompts referencing outdated pricing or team structures as a common drift scenario

  • V2-10 Same Prompt, Different Model, Worse Results

    Custom GPTs as one of the setups that degrades when you haven't reviewed context since creation

  • SoN-23 One Year of Writing About AI

    ChatGPT's custom GPTs as powerful features for persistent context

Visit D1

The Signal Over Noise Take

I created a production database with a single command: wrangler d1 create cerebro-db. No server provisioning, no connection strings to manage, no maintenance overhead. That’s the kind of helper that makes AI-assisted building practical — the AI generates the schema and queries, and the infrastructure just exists. D1 is a good example of what I mean when I say the moat isn’t the model. The model is commodity. The integration layer — databases you can spin up in seconds, APIs that just work — that’s what turns AI conversations into running systems.

Related terms:

  • cloudflare workers
  • api
  • cli

Read more in:

  • V2-11 The Helpers

    D1 database created with a single CLI command to store health check results

The Signal Over Noise Take

Data sovereignty in AI isn’t the dramatic “who owns my data” question. It’s the practical one: your working context — the thing that makes AI actually useful to you specifically — is trapped in someone else’s system. Every platform switch blanks your mirror. All that accumulated context stays behind. The person who switches three times in six months has three shallow setups instead of one deep one. The fix is simple: build your context in plain text files on your own machine. When context lives in portable markdown, your investment transfers to any platform that can read text. The model is maybe 30% of the value. Don’t let the other 70% get locked in.

Related terms:

  • obsidian
  • co operating system
  • custom gpts

Read more in:

  • V2-09 The Mirror and the Telescope

    Context locked inside platforms as a practical data sovereignty problem — your working intelligence trapped in someone else's system

The Signal Over Noise Take

The most common failure mode I see isn’t “picked the wrong AI tool.” It’s “tried to solve something too big in one go.” People ask ChatGPT to “help me be more productive” and get generic advice they forget by Thursday. Decomposition is the antidote. My quarterly tax prep was a two-hour scramble until I broke it into four specific friction points — and discovered that three of them didn’t even need AI. They needed documentation, templates, and mail rules. Sometimes the right decomposition reveals you don’t need AI at all. That’s a feature, not a failure.

Related terms:

  • skills
  • ai agents
  • orchestration

Read more in:

  • V2-02 The Art of Breaking Things Down

    Entire issue dedicated to decomposing problems into skills and agents, with a real tax-prep example

  • V2-04 The Orchestration Loop

    Decomposition is step 2 of the loop — identifying friction points and deciding the right level of solution

The Signal Over Noise Take

When the person being impersonated needs time to verify the deepfake isn’t them, the rest of us have no chance. Hinton experienced this firsthand with a video showing him endorsing China. The solution isn’t better detection — it’s authentication. Verifying that legitimate content is real, rather than trying to catch every fake. We’re approaching a point where distinguishing real from generated is impossible without technical verification. Meanwhile, AI is making the existing social engineering playbook faster and cheaper to execute at scale. The speed is increasing. The playbook remains the same.

Related terms:

  • neural networks
  • ai safety

Read more in:

  • SoN-29 The Godfather of AI's Warning

    Hinton experienced a deepfake of himself endorsing China and needed a moment to verify it wasn't real

  • SoN-31 When They Take Your Email

    AI-powered voice cloning and personalized scams as an evolution of social engineering

Visit Deterministic

The Signal Over Noise Take

A deterministic system gives the same output every time you give it the same input. A calculator is deterministic: 2 + 2 is always 4.

OpenAI’s cookbook says its Chat Completions and Completions APIs “are non-deterministic by default (which means model outputs may differ from request to request)”. It also says that even with a seed set, “determinism is not guaranteed”.

A decision model is limited to a fixed list of allowed answers, such as yes or no, and it returns a probability for each. That limits the answer to a forced choice. It does not make the model deterministic. TypeSafe’s Choice cookbook says its “uncertain” label for answers under 0.60 “does not make the model deterministic”, and in its own 15-run test the chosen label flipped on 2 of 8 questions.

For a yes or no question, TypeSafe’s documentation says a good starting point is to let probabilities between 0.3 and 0.7 go to a person instead of either code path.

Related terms:

  • llm
  • tokens
  • hallucination

The Signal Over Noise Take

The metaphor does the work: you’re farming someone else’s field, and the harvest is only yours until the landlord decides otherwise. Every creator on a platform is doing this to some degree, and that’s fine — platforms are where the readers are. The mistake is treating the platform as the permanent record. Feeds get reordered, terms get rewritten, companies get acquired, and none of that requires anyone to warn you first. The fix isn’t abandoning the platform, it’s making sure the canonical copy of your work lives somewhere you control and the platform gets a syndicated version.

Related terms:

  • posse
  • pesos
  • vendor lock in
  • data sovereignty

Read more in:

  • Essay Substack Writers, You Need a Website

    You're not a homeowner, you're a tenant, and the landlord can rewrite the lease

The Signal Over Noise Take

Distillation is how you make a small, cheap model behave like a big, expensive one: you let it learn from the bigger model’s answers instead of from scratch. It’s a legitimate, widely used technique — and also the centre of a running fight, because if the “teacher” is someone else’s model, accessed against its terms, the result starts to look a lot like copying. That’s the accusation aimed at Kimi K3. Whether it counts as theft or just how the field works is genuinely unsettled — worth knowing the word so the headlines make sense.

Related terms:

  • llm
  • frontier model
  • open model

Read more in:

  • V2-29 Would you let an AI use your passwords?

    US officials accused Moonshot of distilling American models to build Kimi K3

The Signal Over Noise Take

Fine-tuning used to be a serious undertaking. It isn’t any more — a few hundred dollars and a few days can now produce a small model that beats frontier systems on one well-defined task, which quietly undermines the assumption that capability only comes from scale. The judgement call is when it’s worth it. If a task is narrow, high-volume and repetitive, a specialist trained on your own examples wins on both cost and accuracy. If it’s varied or judgement-heavy, you’ll spend the money and end up behind. And a tuned model is a maintenance commitment: when the task changes, it doesn’t notice.

Related terms:

  • training data
  • parameters
  • local models
  • model routing
  • gpu

Read more in:

  • Essay The Donkey Work Doesn't Need a Genius

    A 9B open model trained for about $500 in GPU time, beating every frontier model tested

The Signal Over Noise Take

In the AI conversation, FOBO has come to mean Fear Of Becoming Obsolete — the low-hum worry that the tools are moving faster than you are, and that your skills are depreciating in real time. (The acronym started life as Patrick McGinnis’s “Fear Of Better Options,” but the obsolescence sense is the one doing the emotional work now.) It’s worth naming because it drives bad decisions in both directions: panic-adopting every shiny new tool, or freezing and ignoring them entirely. The steadier read is that obsolescence rarely comes from the technology itself — it comes from refusing to engage with it. You don’t beat FOBO by out-running the models. You beat it by becoming the person who puts them to work on real problems, which is exactly the skill they don’t replace.

Read more in:

  • Post Tell AI Exactly What You Want and Who You Are

    The worry that the tools are moving faster than you are

The Signal Over Noise Take

“Frontier” is shorthand for the most capable models available right now — today that’s the top of the Claude, GPT and Gemini lineups. It’s a moving target: this year’s frontier is next year’s mid-range. The reason the label matters to you is comparison. When a new model “tops a leaderboard” or “closes the gap,” the real question is closing the gap to what — and the answer is usually the frontier. The interesting story of the last two years is how fast cheaper and open models have been catching up to it.

Related terms:

  • llm
  • open model
  • local models

Read more in:

  • V2-29 Would you let an AI use your passwords?

    Kimi K3 still trails the frontier models Claude Fable 5 and GPT-5.6 Sol

Visit Gemini

The Signal Over Noise Take

Gemini’s strength is obvious if you live in the Google ecosystem: it connects to Drive, Docs, and Gmail natively. That’s integration over capability in action — not the “best” model by benchmarks, but potentially the most useful if Google tools are where your context already lives. The prompting gotcha worth knowing: Gemini wants instructions placed at the end, after any data context, and negative instructions (“do not do X”) can actually produce the opposite of what you intended. It’s a different dialect. Read Google’s own guide before assuming your Claude or ChatGPT prompts will transfer.

Related terms:

  • llm
  • claude
  • chatgpt

Read more in:

  • V2-01 Stop Prompting Better. Start Programming Your Gaps.

    Gemini connects to Google Drive — deep integration with the Google ecosystem

  • V2-10 Same Prompt, Different Model, Worse Results

    Gemini wants instructions placed after data context, and negative instructions can backfire

The Signal Over Noise Take

The distinction that matters is between systems that judge and systems that make. Older AI mostly sorted things into buckets: spam or not, fraud or not. Generative systems produce something that didn’t exist before, which is why they’re useful for drafting and why they’re unreliable in a specific way — a classifier that’s unsure gives you a low score, while a generator that’s unsure gives you a confident sentence. As a market term it’s now doing a lot of work covering very different products, so when someone quotes a spend figure or a growth rate for “generative AI”, it’s worth asking which part they actually mean.

Related terms:

  • llm
  • multimodal
  • frontier model
  • hallucination

Read more in:

  • Essay Does the AI Capital Spend Actually Pencil Out?

    The $1.3 trillion the hyperscalers have sunk into it

The Signal Over Noise Take

The constraint that catches people out isn’t speed, it’s memory. A GPU can only work on what fits in its own memory, so the question “can I run this model?” is usually answered by capacity rather than performance — and it’s why a model can be free to download and still impossible for you to use. Apple silicon complicates the picture pleasantly, since unified memory lets a Mac address far more than a consumer graphics card, at lower speed. For most people the practical route is renting GPU time by the hour for the occasional heavy job, and running small models locally for everything else.

Related terms:

  • inference
  • local models
  • parameters
  • hyperscaler
  • fine tuning

Read more in:

  • Essay Kimi K3 Is Open. I Still Can't Run It.

    1.4 terabytes of memory, and why it isn't a threat to anyone's GPU budget

  • Essay The Donkey Work Doesn't Need a Genius

    About $500 in GPU time over three and a half days

The Signal Over Noise Take

My constraint document is more valuable than my instructions. The instructions tell the AI what to do. The constraints shape what kind of collaborator it is. “Don’t agree with me when you actually disagree.” “Don’t make things up about my work.” “Don’t cite numbers without checking the source.” Every single rule was added after something went wrong. I didn’t write any of them on day one. The document is never finished — I still catch things I haven’t written rules for. But unlike a human colleague, the AI reads and follows the constraint document every time. No ego, no “yeah but I thought this time was different.”

Related terms:

  • hallucination
  • system prompt
  • silent drift

Read more in:

  • V2-06 The Talking Wrench

    Building a constraint document that shapes AI into a reliable collaborator through accumulated rules

  • V2-07 Silent Drift

    Guardrails degrade when the context they reference becomes stale

The Signal Over Noise Take

Hallucination is the wrong word for what actually happens, but it’s the one we’re stuck with. In practice, it’s AI confidently making things up to fill gaps. I keep a file called SOUL.md that tracks every time my setup gets something significantly wrong — seventeen entries since December, including fabricated URLs, invented project details, and numbers pulled from outdated documents. The fix isn’t hoping for better models. It’s building rules: “Don’t cite numbers without checking the source.” “Don’t make things up about my work.” Every constraint was added after something went wrong. The document is never finished.

Related terms:

  • llm
  • guardrails
  • silent drift

Read more in:

  • V2-06 The Talking Wrench

    Describes asking AI about its own limitations, including its tendency to fabricate details

  • V2-09 The Mirror and the Telescope

    SOUL.md tracks seventeen instances of fabricated URLs, guessed numbers, and false claims

The Signal Over Noise Take

“Human in the loop” gives you permission to be passive, and it isn’t empowering, which is one step toward losing out to automation. The phrase also suggests something dangerous: that the agents know what they’re doing, and that you, the operator, know and trust that they do. That is dangerous thinking. Human in the lead is the alternative: you stay in control of the process, rather than just being kept in the loop. We need leaders in new fields, and we need humans in the lead.

Related terms:

  • orchestration
  • co operating system
  • ai agents
  • guardrails

The Signal Over Noise Take

Four companies are building most of the physical substrate the rest of the industry rents. That concentration explains a lot of otherwise confusing behaviour: why model prices can be subsidised, why capacity shortages hit everyone at once, and why the AI economy’s health gets discussed through the capital-expenditure lines of four balance sheets. For anyone building on top, the useful takeaway is that today’s pricing reflects a strategic land-grab rather than the cost of serving you. That’s fine while it lasts. It’s just not a number to build a business plan around.

Related terms:

  • gpu
  • inference
  • usage based pricing
  • generative ai

Read more in:

  • Essay Does the AI Capital Spend Actually Pencil Out?

    More than $1.3 trillion sunk into generative AI by the end of this year

Visit Illusion of Explanatory Depth

The Signal Over Noise Take

First studied on zips and bicycles, and now unavoidable, because AI makes it trivially easy to hold something you didn’t build and have never had to account for. A generated plan or script reads as understood — it’s coherent, it’s in your voice, it’s on your screen — right up to the first follow-up question you didn’t prepare for. The defence is cheap and uncomfortable: explain it out loud, unscripted, before anyone else asks. Wherever you start hand-waving is a gap. Better to find it at your own desk than in front of a client.

Related terms:

  • red teaming
  • hallucination
  • vibe coding
  • ai slop

Read more in:

  • Essay Rehearse the Deck You Didn't Write

    The first time his understanding of his own talk got tested was live, in front of people

The Signal Over Noise Take

The part people underestimate is that fixing the bug isn’t the end of the job. Patching a missing tag stops new exposure; it does nothing about copies already cached, scraped or forwarded. Same with revoking a shared link after the fact. So response splits into two tracks: close the hole, then work out what escaped while it was open and what you owe the people affected. Most small businesses have no plan for either, and the useful minimum is small — know who to call, know where your logs are, and assume anything that was public for an hour is public permanently.

Related terms:

  • noindex
  • blast radius
  • least privilege
  • zero trust
  • social engineering

Read more in:

  • Essay The Share Button Is a Publish Button

    Anthropic patched the tag on the 27th. The cached copies didn't get the memo.

The Signal Over Noise Take

Training happens once and costs a fortune; inference happens every time anyone asks anything, and is the cost that never stops. That’s why the economics of AI products are really inference economics, and why “can it run cheaply enough” decides more product outcomes than “is it clever enough”. It’s also the number that determines whether you can run something yourself: training a frontier model is out of reach for everyone outside a handful of labs, but inference on a small model is entirely achievable on a laptop. Most of the practical leverage available to an individual sits on the inference side.

Related terms:

  • tokens
  • gpu
  • usage based pricing
  • local models
  • parameters

Read more in:

  • Essay Kimi K3 Is Open. I Still Can't Run It.

    Roughly 4% more training compute and 2% more inference compute

The Signal Over Noise Take

This became the newsletter’s unofficial motto, and it keeps proving itself. A mediocre model with clear requirements and good integration produces better results than a powerful model sitting in a chat window disconnected from your files. I’ve watched people obsess over GPT-5 announcements and Claude Opus upgrades while their actual workflow is five disconnected tools that don’t talk to each other. The tools that survived my own stack audit weren’t the most powerful. They were the most connected. A $10/month tool that requires constant context-switching costs more than a $50/month tool that integrates with everything you already use.

Related terms:

  • co operating system
  • orchestration
  • api

Read more in:

  • V2-01 Stop Prompting Better. Start Programming Your Gaps.

    One of the four core principles — how your tools connect matters more than which tools you choose

  • SoN-23 One Year of Writing About AI

    The recurring theme across a full year of testing — integration beats capability every time

  • SoN-24 The AI Stack Audit

    A tight stack of five integrated tools beats a scattered collection of fifteen isolated capabilities

Visit Interface World Model

The Signal Over Noise Take

Runway coined this for Solaris, announced on 31 August 2026. The argument behind it: every interface today gets translated from a visual design into an intermediate representation — HTML, CSS, JavaScript — before it can do anything, and that translation throws information away. Remove the translation and you remove the loss. There is no DOM underneath, no component tree, no code.

Set against Fei-Fei Li’s world model taxonomy, an Interface World Model is a renderer: it outputs pixels for human eyes. Li names Google’s Genie 3 and World Labs’ own RTFM in the same class, and is direct about the ceiling — renderers optimise for visual plausibility rather than physical accuracy, so their outputs are beautiful and cannot be trusted to design a building or train a robot. That is not a criticism of Solaris, which is aimed at screens rather than machinery. It is a reason to keep the categories apart when a vendor uses the same two words for both.

The open question is what it costs to remove the code. When an interface is code, the code can be read, diffed and reviewed as evidence of what it was built to do. When it is generated, there is nothing to inspect but what appeared on screen while you were using it. Runway lists accessibility among the problems it has not solved, for the same structural reason: a screen reader traverses elements, roles and labels, and generated pixels that look like a button are not a button.

Related terms:

  • world model
  • ai agents
  • inference

The Signal Over Noise Take

The model is maybe 30% of the value. I’ve used Claude, ChatGPT, Gemini, and local models extensively, and the differences between them are real but narrowing. What actually determines whether an LLM is useful in your work isn’t the benchmarks or the parameter count — it’s whether you’ve connected it to your actual files, your actual context, your actual workflow. A mediocre model with clear requirements and good integration beats a powerful model you’re using through a chat window with no memory of who you are.

Related terms:

  • context window
  • tokens
  • prompt engineering
  • hallucination

Read more in:

  • V2-01 Stop Prompting Better. Start Programming Your Gaps.

    Discusses how LLMs like Claude, ChatGPT, and Gemini become dramatically more useful with persistent context

  • SoN-23 One Year of Writing About AI

    Compares multiple LLMs across a real working stack and why integration matters more than model choice

Visit Lateral reading

The Signal Over Noise Take

The Digital Inquiry Group’s summary of its study describes lateral reading as “leaving an unfamiliar website to search the open Web before investing attention in the site at hand.” Students were taught it as one of the “online evaluation strategies drawn from research with professional fact checkers.”

In the study, across an urban school district, students in the classrooms that practised it “grew significantly in their ability to judge the credibility of digital content.”

You can do the same with an AI answer: click through to the source it names, check that the source says what the answer claims, and search for who is behind that source before you rely on it.

Related terms:

  • hallucination
Visit Let's Encrypt

The Signal Over Noise Take

Let’s Encrypt is the kind of infrastructure that just works and saves real money. I was paying per-domain SSL certificate fees from my web host. Moving to a VPS with Let’s Encrypt eliminated that cost entirely across twelve domains. It’s not a glamorous tool and you won’t see it on any “AI stack” list, but it’s a concrete example of why knowing what’s available in the integration layer matters. The AI surfaced this connection. I wouldn’t have made it in the same timeframe because the pricing research and the SSL problem were in separate mental compartments.

Related terms:

  • vps

Read more in:

  • V2-08 The Co-Operating System

    Free SSL certificates via Let's Encrypt eliminated per-domain certificate costs across twelve domains

Visit Lethal Trifecta

The Signal Over Noise Take

The lethal trifecta is the clearest way I’ve found to think about when an AI agent turns dangerous. On its own, an agent that can read your private data is fine. One that can read random text off a web page is fine. One that can send an email is fine. Put all three in the same session and you have a problem — something hidden in the untrusted text can tell the agent to take your private data and send it out. Most “the AI did something awful” stories are really just this. The fix isn’t clever: make sure any one agent never holds all three legs at once.

Related terms:

  • ai agents
  • guardrails
  • ai safety

Read more in:

  • V2-29 Would you let an AI use your passwords?

    A logged-in agent tends to hand over all three legs of the lethal trifecta at once

The Signal Over Noise Take

Local models are the ultimate answer to the data sovereignty question. Nothing leaves your machine. Full file system access. No API costs per token. The trade-off is capability — local models are less powerful than frontier models like Claude or GPT-4, but for many tasks that difference doesn’t matter. I use Ollama running qwen2.5-coder for mechanical tasks — summarisation, classification, data extraction, initial drafts — and reserve Claude for anything requiring real reasoning. The model handles grunt work, I do quality control. Same division of labour, dramatically lower cost.

Related terms:

  • llm
  • data sovereignty
  • ollama

Read more in:

  • V2-01 Stop Prompting Better. Start Programming Your Gaps.

    Local LLMs via Ollama or LM Studio as one of the valid paths to AI integration — full file access, no data leaving your machine

  • V2-09 The Mirror and the Telescope

    Platform-agnostic architecture works whether you're on Claude, ChatGPT, Gemini, or a local model

The Signal Over Noise Take

Markdown’s whole value is that it’s boring. A markdown file written in 2012 opens today in any editor on any machine, because the formatting is just characters in the text rather than instructions locked inside a file format only one company’s software understands. That’s why it became the default for note vaults, documentation and increasingly for anything an AI model needs to read: models handle it cleanly, and so do humans, and so will whatever tool replaces both in five years. If you’re choosing where to keep writing you want to still have later, the format matters more than the app.

Related terms:

  • obsidian
  • vault
  • open source
  • vendor lock in

Read more in:

  • Essay Hubble, and the Assumption Baked Into a Notes App Now

    Plain markdown survives regardless of which app opens it

Visit MCP (Model Context Protocol)

The Signal Over Noise Take

MCP is what turned Claude from a chat window into the centre of my workflow. Before MCP, AI could suggest things. After MCP, it could do things — create calendar events, query databases, deploy code, manage files. I’ve built 11 MCP servers with CI/CD pipelines and connected 17 more. The protocol itself is straightforward: it gives the model a standardised way to call external tools. But the impact is disproportionate. MCP is the reason “integration over capability” works in practice — it’s the literal connector between the AI’s reasoning and your actual systems. Without it, you’re still copy-pasting between windows.

Two developments in early 2026 confirmed MCP is bigger than Anthropic. Apple shipped MCP support in Xcode 26.3, meaning the protocol now runs inside the world’s most widely used IDE for mobile development. And elicitation landed: MCP servers can now pause mid-task and ask the user for structured input — picking a file, confirming a choice, entering credentials — instead of guessing or failing silently. That turns MCP from “AI calls tools” into “AI collaborates with tools and humans in real time.” It’s becoming the USB of AI integration.

Related terms:

  • api
  • cli
  • claude code
  • orchestration

Read more in:

  • V2-01 Stop Prompting Better. Start Programming Your Gaps.

    MCP servers as the connection layer between Claude Code and external services

  • SoN-23 One Year of Writing About AI

    MCP integration with Claude was the turning point — it changed what Claude could do

Visit Meat proxy

The Signal Over Noise Take

The term comes from Niklas Gruhn, who published “Don’t be a meat proxy” on his personal blog on 3 August 2026. His complaint was specific: he would ask a question in Slack, leave feedback on a pull request, or argue with friends in a WhatsApp group, and get back “Claude said:” followed by a giant response pasted in verbatim. His objection is not that the other person used AI. It is that they used it and then made him do the reading.

Simon Willison picked it up the same day, crediting Gruhn as the coiner and Lobste.rs as where he found it, and the original post reached the top of Hacker News on the Monday. So if you have seen the phrase somewhere else since, that is the chain it travelled down.

Gruhn’s fix is the part worth memorising: prompt the AI by all means, but do not just relay the output. Read it, understand it, validate it, and then write a response in your own words — which he calls “a decent certificate that you’ve done the prior steps.” Putting something in your own words is the receipt proving you did the reading, in the same way a book report was never really about the summary.

Why it matters beyond manners: relaying unread output makes the total work go up rather than down. The sender saves a few minutes and spends everybody else’s, because the recipient now has to read a long answer, work out which parts are relevant, and decide whether any of it is true — all without knowing what was asked or why this response was thought to be the right one. One person’s question becomes a reading job for two.

A note on the phrase itself. “Meat proxy” has been used before in a looser sense — a human doing manual work that a system should have automated — and it sits alongside older internet slang like “meat puppet” and “meatspace”. Gruhn’s contribution is the specific AI sense: the human as an unfiltered relay between a model and another person. That is the meaning that spread in August 2026, and the one used here.

Related terms:

  • ai slop
  • hallucination
  • prompt engineering
  • illusion of explanatory depth

Read more in:

  • V2-31 Don't be a meat proxy

    Why forwarding an AI's answer unread hands the next person more work than the original question did

The Signal Over Noise Take

Meta-prompting sounds clever — “ask the AI how to ask the AI.” But what it’s really doing is forcing you to define your requirements before you make the request. The people getting great results from meta-prompting didn’t discover a trick. They rediscovered something systematic: figure out what you actually want before you ask for it. Purpose, Audience, Scope, Tone. That’s all meta-prompting is, stripped of the mystique. It works because it surfaces your unstated assumptions before execution instead of during twenty correction loops.

Related terms:

  • prompt engineering
  • past framework

Read more in:

  • SoN-30 Four Questions That Fix Your Prompts

    Reframes meta-prompting as systematic requirements definition, not a clever technique

The Signal Over Noise Take

Metadata is the bit at the top of a note that tells a machine what it’s looking at before it reads a word of the content. Add a date and a tag and suddenly a folder of files is queryable. It matters more now than it did, because an AI agent pointed at a thousand documents needs some way to narrow down which ones are relevant, and consistent metadata is the cheapest way to give it one. The trap is over-engineering it: a schema so elaborate you stop capturing things because filling it in is a chore. Sparse and consistent beats rich and abandoned.

Related terms:

  • markdown
  • vault
  • ai agents
  • corpus

Read more in:

  • Essay Hubble, and the Assumption Baked Into a Notes App Now

    Consistent headers, predictable metadata, less ambiguity about what a block of text is for

The Signal Over Noise Take

“Improve efficiency” isn’t a goal. It’s a wish. Projects without clear metrics can’t fail — there’s no definition of failure — so they drift indefinitely, consuming budget while delivering “learnings” instead of results. The Metric Mandate is five questions: What number changes? What’s the baseline? What’s minimum success? When do we measure? What triggers stop? That last one is the hardest and most important — your kill criteria. If any field is blank or “TBD,” the project isn’t ready. AI gives you speed, and speed makes this more important, not less. Fast execution of unclear goals just gets you to “sort of done” faster.

Related terms:

  • orchestration
  • decomposition

Read more in:

  • V2-03 The Metric Mandate

    Introduces the five-question gate that every AI project must pass before moving past the idea stage

  • V2-04 The Orchestration Loop

    The Metric Mandate handles steps 1 and 5 of the loop — defining success and measuring results

The Signal Over Noise Take

Mixture of experts is the trick behind most of the enormous parameter counts you see quoted. Rather than running every one of a trillion parameters for every word, the model routes each token to a small subset — the “experts” most relevant to it — so the compute per token stays manageable even as total size balloons. The catch is that memory doesn’t get the same discount: all those experts still have to be loaded and available, even though only a fraction fire at any moment. That’s the gap that catches people out. A model can be cheap to run per token and still be impossible to fit on hardware you own.

Related terms:

  • parameters
  • inference
  • attention
  • frontier model

Read more in:

  • Essay Kimi K3 Is Open. I Still Can't Run It.

    LatentMoE, borrowed from Nemotron 3 Ultra, compressing the large linear layers

The Signal Over Noise Take

Most work sent to an expensive model doesn’t need one. Reformatting, extracting fields, classifying a pile of things into buckets you’ve already defined — that’s volume, not judgement, and a small local model will grind through it for nothing while the expensive one stays free for the decision that actually matters. The pattern that works: have the frontier model write the instructions and the checks, then hand execution down. It’s slower per item and the total is still cheaper, because you stop paying frontier prices for work that never required frontier intelligence. The skill is telling the two kinds of task apart.

Related terms:

  • local models
  • ollama
  • usage based pricing
  • orchestration
  • fine tuning

Read more in:

  • Essay The Donkey Work Doesn't Need a Genius

    Get the expensive model to write the instructions, hand execution to the local one

The Signal Over Noise Take

“Native” is the word to watch. A model trained on images and text together builds a shared understanding of both, and can reason about a screenshot the way it reasons about a paragraph. A model that pipes your image through a separate captioning step and reads the caption is doing something much weaker, and the difference shows up exactly when you need it — reading a messy invoice, interpreting a chart, working out what’s wrong in a photo of a wiring cabinet. The practical test is whether it can answer a question about a detail nobody would have thought to caption.

Related terms:

  • llm
  • generative ai
  • frontier model
  • tokens

Read more in:

  • Essay Kimi K3 Is Open. I Still Can't Run It.

    Native multimodal support built in from the start rather than bolted on

Visit n8n

The Signal Over Noise Take

I moved from Make.com to n8n not because n8n is technically superior in every way, but because the community-driven development model compounds faster than corporate feature release cycles. The innovations come from people actually using the tool to solve real problems. In my stack, n8n is the automation layer — it receives webhooks, orchestrates multi-step workflows, and connects services that don’t natively talk to each other. It’s one of those tools that keeps getting more useful the more you connect to it, which is exactly what “integration over capability” predicts.

Related terms:

  • webhook
  • api
  • automation
  • orchestration

Read more in:

  • V2-11 The Helpers

    n8n receives webhook alerts from Cloudflare Workers and routes them to Telegram

  • V2-08 The Co-Operating System

    n8n referenced as the automation platform running on the server being migrated

  • SoN-23 One Year of Writing About AI

    Switching from Make.com to n8n because community-driven development compounds faster

The Signal Over Noise Take

Neural networks are what make all of this work — and what make all of this unpredictable. Hinton’s claim, which contradicts a lot of casual AI skepticism, is that these systems genuinely understand. They’re not just “statistical autocomplete” doing pattern matching. They display real comprehension. That makes them more capable than critics acknowledge, and more unpredictable than enthusiasts want to admit. The inventor of these systems says he doesn’t have a recipe for how to stop them from taking over. That’s worth taking seriously, whatever side of the AI debate you’re on.

Related terms:

  • llm

Read more in:

  • SoN-29 The Godfather of AI's Warning

    Geoffrey Hinton won the Nobel Prize for inventing the neural networks that power modern AI

The Signal Over Noise Take

One line of HTML, and its absence is how “share this with one person” becomes “publish this to Google”. Two things are worth being clear about. It’s a request, not a control — well-behaved crawlers honour it, and anyone with the URL can still open the page regardless. And it only prevents future indexing: once a page is in an index and cached, adding the tag afterwards starts a slow removal process rather than an undo. If a page must not be seen by strangers, it needs authentication. noindex is tidiness, not security.

Related terms:

  • web crawler
  • canonical url
  • incident response
  • least privilege

Read more in:

  • Essay The Share Button Is a Publish Button

    600 Claude conversations indexed because the shared page shipped without the tag

Visit NotebookLM

The Signal Over Noise Take

NotebookLM does one thing really well: it takes your documents and makes them conversational. Upload research papers, meeting notes, or reference material, and it generates summaries and answers questions grounded in your sources. It’s a specialist tool, not a general-purpose assistant. Where it fits in the broader picture is as evidence that the reasoning layer is connecting to the memory layer across the whole industry — different tools, same insight that AI gets dramatically more useful when it has access to your actual context.

Related terms:

  • gemini
  • llm

Read more in:

  • V2-01 Stop Prompting Better. Start Programming Your Gaps.

    NotebookLM synthesises research as one of the ways the reasoning layer connects to the memory layer

Visit Noul

The Signal Over Noise Take

Noul is TypeSafe’s name for a yes-or-no question put to its decision model, Jev. TypeSafe’s documentation says a Noul “asks the TypeSafe model to evaluate a yes/no question and return the probability that the answer is yes.” Cloudflare says its Clef models take the same requests.

The number is the whole answer. Near 1 is a strong yes, near 0 is a strong no, and around 0.5 the model gives yes and no about the same chance. TypeSafe’s other question types, Choice and Score, also return a confidence value. A Noul doesn’t, because one number already describes both outcomes.

Your code decides what the number means. TypeSafe suggests 0.7 for yes and 0.3 for no as a starting point, and says values in between “can go to a person rather than either code path.” Its own cookbook calls that band “neither a calibrated guarantee nor an optimized threshold”, so test it on your own messages before you rely on it.

In TypeSafe’s example, the question is “Is the customer asking for a human agent?” The message “Are you a bot?” scores 0.40, and “I have asked three times now. Can I please just talk to a real person?” scores 0.99.

Related terms:

  • deterministic
  • llm
Visit Obsidian

The Signal Over Noise Take

Obsidian is the memory layer of my co-operating system, and I chose it for one reason: your files stay on your machine as plain markdown. No vendor lock-in, no proprietary format, no subscription required for your data to be accessible. When Claude Code reads my Obsidian vault, it accesses notes, projects, daily logs, and years of documented decisions — all as text files it can search and reference. The zeitgeist moment I wrote about in V2-01 was real: people independently discovered that connecting Claude to Obsidian created something neither tool does alone. The AI gets memory. Your notes get reasoning. Both get better over time.

Related terms:

  • co operating system
  • claude code
  • context compounding

Read more in:

  • V2-01 Stop Prompting Better. Start Programming Your Gaps.

    People connecting Claude Code to Obsidian vaults as a zeitgeist moment — the setup that 'changed everything'

  • SoN-26 Building Your AI Style Guide

    Style guide kept in Obsidian and referenced at the start of every writing session

Visit Ollama

The Signal Over Noise Take

Ollama makes running local models trivial. One command to download a model, one command to run it. It’s the CLI interface I use for local LLM routing — mechanical tasks like summarisation, classification, and text transformation get routed to a local qwen2.5-coder model instead of burning API credits on Claude. The setup takes minutes, and once running, it’s available to any tool that can make HTTP requests. If you care about data sovereignty or just want to reduce API costs on tasks that don’t need frontier intelligence, Ollama is where to start.

Related terms:

  • local models
  • llm
  • cli

Read more in:

  • V2-01 Stop Prompting Better. Start Programming Your Gaps.

    Listed as one of the options for running local models with full file system access

The Signal Over Noise Take

An open model is one you can actually get your hands on. Instead of living behind a company’s API where you rent access, its weights are published for anyone to download, run on their own hardware, and fine-tune. That matters for cost, privacy and independence — nobody can switch it off or change the price on you. One caveat worth knowing: “open weights” usually isn’t the same as fully open-source. You get the finished model, rarely the training data or the exact recipe that made it. Kimi K3 is the current headline example — a frontier-scale model released for anyone to download.

Related terms:

  • llm
  • local models
  • frontier model

Read more in:

  • V2-29 Would you let an AI use your passwords?

    Kimi K3 released as a frontier-scale open-weights model anyone can download

The Signal Over Noise Take

Open source means you can read the code, change it, and keep running your version even if the original project dies or the company behind it changes its mind. That last part is the practical benefit most people are actually buying. Worth keeping separate from “open weights” in AI, which is a much weaker claim: an open-weight model hands you the finished numbers, not the training data or the recipe, and calling it open source flatters it. Free-to-use isn’t open source either. The test is whether you could fork it and carry on alone.

Related terms:

  • open model
  • closed weights
  • vendor lock in
  • local models

Read more in:

  • Essay Hubble, and the Assumption Baked Into a Notes App Now

    Hubble is free, open source, and built on plain markdown and HTML

The Signal Over Noise Take

Orchestration is what happens after you stop optimizing prompts and start building systems. The shift isn’t subtle: instead of asking “how do I prompt better?” you ask “what friction in my life can I systematize?” The Orchestration Loop connects three ideas into a repeatable process — define metrics before you start, decompose the problem into skills and agents, integrate the pieces into your existing workflow, measure whether it worked, and repeat. The loop is the thing that turns good ideas into something you actually use. Most people skip straight to building without defining what success looks like. That’s how you end up with impressive demos and limited daily value.

Related terms:

  • co operating system
  • decomposition
  • skills
  • ai agents

Read more in:

  • V2-01 Stop Prompting Better. Start Programming Your Gaps.

    Frames the shift from prompting to orchestrating systems as the key AI skill for 2026

  • V2-04 The Orchestration Loop

    Presents a complete framework — metrics, decomposition, integration, measurement — as a repeatable loop

The Signal Over Noise Take

Parameter count is the number everyone quotes because it’s the only one that’s always public, but it measures size, not intelligence. Its most reliable use is arithmetic: parameters times the bytes each one occupies tells you roughly how much memory you need to run the thing, which is how you work out in about ten seconds whether a model will fit on your hardware. It’s a poor guide to capability. A 9-billion-parameter model tuned for one narrow job routinely beats a model hundreds of times its size on that job — bigger buys generality, not accuracy at the specific thing you need done.

Related terms:

  • open model
  • inference
  • gpu
  • mixture of experts
  • fine tuning

Read more in:

  • Essay Kimi K3 Is Open. I Still Can't Run It.

    Scaled from 48 billion parameters up to 2.8 trillion

  • Essay The Donkey Work Doesn't Need a Genius

    A 9-billion-parameter open model beating frontier models on a narrow task

The Signal Over Noise Take

PAST started as a way to fix prompts and turned into something bigger. Purpose: what specific outcome do I need? Audience: who receives this? Scope: what’s in, what’s out? Tone: how should this feel? Those four questions fix more prompts than any “advanced technique” because they force you to do the thinking AI can’t do for you. But the same questions work for team workflows, project planning, and organisational AI strategy. The reason it scales is that the questions never change — whether you’re writing a single prompt or defining a company-wide AI initiative, you still need to answer: what outcome, for whom, within what boundaries, in what style?

Related terms:

  • prompt engineering
  • meta prompting
  • shape framework

Read more in:

  • SoN-30 Four Questions That Fix Your Prompts

    Introduces PAST — Purpose, Audience, Scope, Tone — as the system behind effective meta-prompting

Visit Perplexity

The Signal Over Noise Take

Perplexity didn’t just search better — it brought search intelligence directly into workflows. With the Comet browser extension, that intelligence moves with you across the web without requiring you to context-switch between applications. That’s why it survived my stack audit as core infrastructure rather than a specialist tool. It reduces friction rather than adding another login. The pattern is consistent: the AI tools that stick in your workflow aren’t the most powerful, they’re the ones that fit naturally into how you already work.

Related terms:

  • llm

Read more in:

  • SoN-23 One Year of Writing About AI

    Perplexity brought search intelligence directly into workflows — with the Comet extension, it moves with you

  • SoN-24 The AI Stack Audit

    Categorised as core infrastructure alongside Claude and n8n

Visit PESOS (Publish Elsewhere, Syndicate to Own Site)

The Signal Over Noise Take

PESOS is what most people end up doing, because it’s the path of least resistance: write in the platform’s editor, hit publish, and sync a copy home later if you remember. It preserves the archive, which is most of the benefit, and it costs almost nothing to start. What it gives up is the claim that your site is the real one. The copy arrives second, usually stripped of formatting, sometimes never — and “sometimes never” is the failure mode, because the syndication step is the one that gets skipped when you’re behind. If you’re choosing, POSSE is stronger; PESOS is the version you’ll actually keep doing.

Related terms:

  • posse
  • canonical url
  • digital sharecropping

Read more in:

  • Essay Substack Writers, You Need a Website

    Less work up front, but it means your site is a backup instead of a source

Visit Pickaxe

The Signal Over Noise Take

Pickaxe became my agent platform because it orchestrates other tools — including n8n and Make.com — rather than trying to replace them. It’s a layer above the tools, not another tool competing for attention. That distinction matters: the best platform tools don’t do everything themselves, they connect what you already have. It’s integration over capability applied to the agent layer. I use it primarily for client-facing work, where I need structured AI assistants with specific knowledge bases and consistent behaviour.

Related terms:

  • ai agents
  • api
  • n8n

Read more in:

  • SoN-23 One Year of Writing About AI

    Pickaxe as the agent platform — it orchestrates other tools rather than trying to replace them

  • SoN-24 The AI Stack Audit

    Categorised as a specialist tool with clear client work dependency

The Signal Over Noise Take

Attention on its own is order-blind — it sees a bag of words, not a sentence — so something has to encode position. RoPE has been the standard answer for years and works well, but it’s also one of the things that makes very long contexts awkward, because a scheme tuned for one length degrades past it. NoPE is the surprising finding that if a model is trained the right way it can work out order from structure alone, no explicit signal required. It’s a genuinely architectural argument rather than a marketing one, and it matters mainly for how gracefully a model handles input far longer than anything it saw in training.

Related terms:

  • attention
  • context window
  • parameters
  • llm

Read more in:

  • Essay Kimi K3 Is Open. I Still Can't Run It.

    Every RoPE layer dropped in favour of NoPE throughout

Visit POSSE (Publish on Own Site, Syndicate Elsewhere)

The Signal Over Noise Take

POSSE settles the argument about platforms without requiring you to leave any of them. Your site holds the original; the platforms get copies, and keep doing the one thing they’re genuinely good at, which is putting your work in front of people who are already there. If a platform folds or pivots, you’ve lost a distribution channel rather than an archive. The cost is real and up front — you’re maintaining a site you’d otherwise not bother with, and publishing becomes two steps instead of one. Whether that’s worth it comes down to how much you’d mind losing everything you’ve written if a company changed its plans.

Related terms:

  • pesos
  • canonical url
  • digital sharecropping
  • data sovereignty

Read more in:

  • Essay Substack Writers, You Need a Website

    The canonical version sits on infrastructure you actually control

The Signal Over Noise Take

The threat is real but the timeline is long, and the reason to care now is “harvest now, decrypt later”: an adversary can copy encrypted traffic today and hold it until the hardware to break it exists. Anything that must stay secret for a decade is already exposed. NIST has been standardising replacement schemes for years, which is why candidates like HAWK get picked apart in public — that scrutiny is the process working, not a scandal. Two things follow for the rest of us. A scheme being “under consideration” means it is explicitly not yet trusted. And a new attack on a candidate is normally a sign the vetting is doing its job, not that encryption is broken.

Related terms:

  • block cipher
  • red teaming
  • ai safety
  • zero trust

Read more in:

  • Essay "AI Found a Security Bug" Is the Wrong Headline

    Claude found an improved attack on HAWK, a post-quantum scheme under NIST consideration

Visit Principle of Least Privilege

The Signal Over Noise Take

Least privilege is one of the plainest, most useful ideas in security: give something only the access it actually needs, and nothing spare. A person who only reads reports doesn’t get permission to delete them; an AI agent that files notes doesn’t get the keys to your bank. The payoff is blast radius — when something goes wrong, and eventually it does, the damage is capped at whatever that narrow access could touch. Almost everything I do to keep AI agents safe is a version of this: one vault, read-only where possible, one task at a time. If you take one habit from all of it, take this one.

Related terms:

  • zero trust
  • scoped token
  • service account

Read more in:

  • V2-29 Would you let an AI use your passwords?

    The four rules for scoping an AI agent's access are least privilege in practice

The Signal Over Noise Take

Prompt engineering was 2024’s skill. It still matters, but it’s table stakes now — not the thing that separates people getting real value from AI. The biggest insight I’ve had is that most prompt failures aren’t technique problems, they’re clarity problems. You haven’t figured out what you actually want. The PAST Framework — Purpose, Audience, Scope, Tone — fixes more prompts than any “advanced technique” because it forces you to think before you type. Also: your prompts don’t travel between models. Claude wants XML tags, ChatGPT wants role-based messages, Gemini wants instructions after context. Each vendor publishes a guide. Almost nobody reads them.

Related terms:

  • system prompt
  • llm
  • past framework
  • meta prompting

Read more in:

  • SoN-30 Four Questions That Fix Your Prompts

    Argues that most prompt failures come from unclear thinking, not bad technique

  • V2-10 Same Prompt, Different Model, Worse Results

    Links to each vendor's prompting guide and explains why prompts don't port between platforms

  • V2-01 Stop Prompting Better. Start Programming Your Gaps.

    Frames the move from better prompting to systems orchestration as the key skill shift

The Signal Over Noise Take

There is no such thing as prompt portability right now. If you change models, you need to re-evaluate and re-tune all your prompts. Claude prefers XML tags. ChatGPT emphasises message roles. Gemini wants instructions after context and can backfire on negative instructions. A paper at NAACL 2025 confirmed measurable performance brittleness across models when prompt formats change, even when the underlying instruction is identical. You’re speaking French to something that understands you better in Portuguese. Each vendor publishes their own best-practices guide. They’re free, they’re public, and almost nobody has read them.

Related terms:

  • prompt engineering
  • claude
  • chatgpt
  • gemini

Read more in:

  • V2-10 Same Prompt, Different Model, Worse Results

    There is no such thing as prompt portability — each model has its own dialect and preferences

The Signal Over Noise Take

Red-teaming is a borrowed military term: you put together a team whose whole job is to attack the thing you built and see what breaks. For AI, that means sitting down and trying to make the model do what it shouldn’t — leak a secret, follow a planted instruction, say the thing it was told never to say. It sounds adversarial because it is. The reason it matters to you as a reader is that the numbers red-teamers publish are your early warning. When a vendor admits its own agent followed a hidden instruction a third of the time before safeguards, that isn’t a scandal — it’s the honest baseline to factor in before you trust it with anything that bites.

Related terms:

  • ai safety
  • guardrails

Read more in:

  • V2-29 Would you let an AI use your passwords?

    Anthropic's own red-teamers found its browser agent followed planted instructions before safeguards

The Signal Over Noise Take

The safest way to let an AI agent use a credential is to make the credential small before you hand it over. A scoped token is exactly that — it opens one vault, or does one job, and nothing else. If it leaks, the damage stops at the edge of what it was allowed to touch. It’s the difference between handing someone a key to one room and handing them the master key to the whole building. When my own tooling reaches into a password manager, it gets a token scoped to a single vault I built just for it — never the account that holds the bank, the email and the family logins.

Related terms:

  • tokens
  • cli
  • service account
  • two factor authentication

Read more in:

  • V2-29 Would you let an AI use your passwords?

    The agent is handed one scoped token that unlocks a single vault, never the whole account

The Signal Over Noise Take

An SDK is the box of ready-made parts a company hands developers so they don’t have to reinvent the basics. If an API is the socket you plug into, the SDK is the set of adapters, cables and instructions that make plugging in painless. You don’t need one as a user, but the word is worth knowing: when a vendor ships an SDK for something, it usually means there’s a supported, tested way to build on it — as opposed to gluing things together yourself and hoping. The 1Password ones, for instance, let a program fetch a secret by reference, so the real value never gets printed into your code.

Related terms:

  • agent sdk
  • api
  • cli

Read more in:

  • V2-29 Would you let an AI use your passwords?

    1Password's SDKs pass an agent a secret by reference without ever printing it

The Signal Over Noise Take

A service account is a login for a machine, not a person. The reason it matters the moment you wire up an AI agent is that you can put a fence around it: point it at one vault, make it read-only, and it can fetch what it needs without being able to change or reach anything else. When people worry about handing an agent the keys, this is the quiet answer — the agent never gets your login, it gets a service account that was only ever allowed to do the one thing. Give it the narrowest account that still does the job, and start read-only until you have a reason to trust it with more.

Related terms:

  • scoped token
  • cli
  • api

Read more in:

  • V2-29 Would you let an AI use your passwords?

    A read-only service account scoped to one vault is what actually reads the secrets for the agent

The Signal Over Noise Take

PAST tells you what and why. SHAPE tells you how and when. Together they take AI initiatives from scattered experiments to systematic implementation. Situation: what’s actually happening right now? Hypothesis: what do we think will improve things? Action: what specific thing are we going to do? Process: how will we do it? Evaluation: did it work? The framework exists because I kept seeing the same pattern — teams with good intentions but no structured way to move from “we should use AI” to “here’s what we’re doing, here’s how we’ll know if it works.” Both frameworks are open-sourced under CC BY-SA 4.0.

Related terms:

  • past framework
  • orchestration

Read more in:

  • V2-08 The Co-Operating System

    SHAPE described alongside PAST — PAST tells you what and why, SHAPE tells you how and when

The Signal Over Noise Take

Silent drift is what happens when your AI setup is quietly pointing to things that have moved, changed, or disappeared — and nothing tells you. I renamed a skill and three days later discovered that separate components were silently failing, still referencing the old name, quietly returning nothing. Zero error messages. The output still looked plausible, which is the real problem. Traditional software crashes loudly. AI fails gracefully — and “gracefully” is worse, because you don’t know it’s happening. If you configured a custom GPT six months ago and haven’t reviewed it since, your setup has drifted. Guaranteed.

Related terms:

  • guardrails
  • system prompt
  • context compounding

Read more in:

  • V2-07 Silent Drift

    Introduces the concept — AI setups quietly degrading as referenced context becomes stale

  • V2-10 Same Prompt, Different Model, Worse Results

    95 minutes of maintenance revealed accumulated drift in a daily-use AI setup

The Signal Over Noise Take

Skills are underrated. A good skill saves you twenty minutes a week, every week, with zero maintenance. An agent that’s too ambitious becomes something you never quite finish building. The test is simple: if you can write it as a checklist, it’s a skill. Same inputs, same outputs, same steps every time. I have 96 of them — morning brief, invoice filing, slop detection, inbox classification. They’re not glamorous. They’re the things that actually get used. The trick is that skills also rot: I found two duplicates, eight that needed decomposing, and descriptions so stale the system was finding them by accident.

Related terms:

  • ai agents
  • orchestration
  • decomposition

Read more in:

  • V2-02 The Art of Breaking Things Down

    Defines skills as 'recipes' — repeatable task instructions with clear inputs and outputs

  • V2-10 Same Prompt, Different Model, Worse Results

    Describes auditing 96 skills and finding duplicates, bloated files, and descriptions that scored 0% accuracy

The Signal Over Noise Take

AI is making attackers faster, not smarter. Phishing emails that used to take hours to craft now take seconds. Voice cloning can fake a family member from seconds of audio. Personalised scam messages can be generated at scale. But the underlying playbook hasn’t changed — urgency, authority, fear, confusion during transitions. The same psychological levers con artists have pulled for centuries. That’s actually useful to know, because it means the defences that work against traditional social engineering still work against AI-powered attacks. The fundamentals — 2FA, separate recovery emails, verification code words, healthy skepticism — remain effective even as the attack tools get more sophisticated.

Related terms:

  • deepfakes
  • ai safety
  • two factor authentication

Read more in:

  • SoN-31 When They Take Your Email

    AI is making social engineering attacks faster and more personalised, but the underlying tactics haven't changed

The Signal Over Noise Take

Most people approach this wrong — they ask “am I getting my money’s worth?” The better question: does this tool make my systematic approach better, or does it distract from it? I use a four-category sort: core infrastructure you use daily that other tools depend on (keep), specialist tools solving specific high-value problems (keep but review quarterly), capability duplicators doing something your core tools already do (kill), and novelty subscriptions from hype cycles you forgot about (kill tonight). Expected outcome: 40-60% reduction in tool count, 30-50% cost reduction, zero reduction in actual capability. A tight stack of five integrated tools beats a scattered fifteen.

Related terms:

  • integration over capability

Read more in:

  • SoN-24 The AI Stack Audit

    Four-category framework for evaluating every AI tool: core infrastructure, specialist, duplicator, or novelty

  • SoN-23 One Year of Writing About AI

    The tools that survived the audit were the most integrated, not the most powerful

The Signal Over Noise Take

Your system prompt is the most valuable and most neglected part of your AI setup. It’s where you define who the AI is working with, what it should and shouldn’t do, and what context it needs. Mine is over 16,000 words and it runs behind everything I build. But here’s the thing nobody warns you about: system prompts rot. I ran an audit and found that skill descriptions inside mine scored 0% accuracy — the system was finding things by accident through keyword overlap, not through the descriptions I’d written. If you set up a custom GPT or Claude Project six months ago and haven’t reviewed the instructions since, the context has almost certainly drifted from reality.

Related terms:

  • prompt engineering
  • context window
  • llm

Read more in:

  • V2-10 Same Prompt, Different Model, Worse Results

    Describes a 16,000-word system prompt and how skill descriptions within it had drifted to 0% accuracy

  • V2-07 Silent Drift

    Custom GPT system prompts that reference outdated information create silent failures

The Signal Over Noise Take

“Tokenmaxxing” borrows the “-maxxing” suffix from internet slang (looksmaxxing, gymmaxxing): optimising one number to the exclusion of everything else. Here the number is tokens — how much context you can stuff into a prompt, or how few tokens you can get away with to shave the bill. A little of this is healthy; managing context is a real skill. But past a point you’re spending an hour saving pennies on a run, or overloading a prompt with so much “just in case” context that the model’s attention gets worse, not better. The token count was never the goal — the output was. Optimise the thing you actually needed, then stop.

Related terms:

  • allowancemaxxing
  • tokens

The Signal Over Noise Take

Tokens are the currency of AI interaction — every word you send costs tokens, every word you receive costs tokens, and your context window has a token budget. In practice, you rarely need to think about tokens directly unless you’re hitting limits or watching API costs. Where tokens matter most is in understanding why “just dump everything in the context” doesn’t scale — there’s a real ceiling, and what you choose to spend your token budget on determines how useful the AI is. Concise, well-structured context beats verbose dumps every time.

Related terms:

  • llm
  • context window

Read more in:

  • SoN-30 Four Questions That Fix Your Prompts

    References token limits as a constraint when iterating on prompts through correction loops

The Signal Over Noise Take

Everything a model does traces back to what it was trained on, which is why the composition of that data is one of the most consequential and least disclosed facts about any system you use. The practical consequence isn’t abstract: material that was easy to scrape is over-represented, material behind a paywall or a login is often absent entirely, and the model doesn’t tell you which is which. It answers with the same confidence either way. When a model is unexpectedly weak on something specialised, the usual explanation is that the good sources on that subject were never in the pile.

Related terms:

  • corpus
  • fine tuning
  • hallucination
  • open model
  • web crawler

Read more in:

  • Essay The ACM's Caution About LLMs Is Starting to Have a Cost

    If vetted scholarship stays out while lower-quality material gets ingested anyway

The Signal Over Noise Take

AI pricing is currently living in two worlds at once. Flat subscriptions are what most people buy, and metered API access is what the thing actually costs to run — and right now the gap between them is being absorbed by the vendor. That’s why heavy users on fixed plans are quietly running up many times their subscription in real consumption, and why those plans keep getting quietly re-specified. Two practical implications: if a fixed-price plan is central to how you work, assume its terms will change, and if you’re building on metered access, measure your token consumption early, because that’s the number that decides whether your margin survives contact with a real workload.

Related terms:

  • tokens
  • api
  • inference
  • hyperscaler
  • model routing

Read more in:

  • Essay Does the AI Capital Spend Actually Pencil Out?

    Users burning through 25 times their subscription cost, and $200 plans absorbing $14,000 of usage

The Signal Over Noise Take

A vault is just a folder. That’s the point. There’s no database to migrate, no export button to depend on, no account to lose access to — the notes are files, and they’re already on your disk. What turns a folder into a vault is the linking: notes that point at other notes, so the connections between ideas live in the files themselves rather than in your memory of where you put things. It’s also the shape that works best when you start pointing AI at your own material, because an agent can be given a directory and told to read it without anyone building an integration first.

Related terms:

  • obsidian
  • markdown
  • ai agents
  • data sovereignty

Read more in:

  • Essay Hubble, and the Assumption Baked Into a Notes App Now

    Whether agent-legible structure is worth the coupling for people with no legacy vault

The Signal Over Noise Take

Lock-in is rarely a decision anyone makes. It accumulates: a proprietary file format here, a workflow built around one product’s quirks there, and a year later the migration is a project nobody has time for. The AI version is arriving quickly — prompts tuned to one model’s behaviour, automations wired to one vendor’s API shape, notes structured for one app’s parser. The defence isn’t avoiding good tools, it’s checking the exit before you commit: can you get your data out in a format something else can read, and would your setup survive that vendor changing its pricing tomorrow?

Related terms:

  • data sovereignty
  • digital sharecropping
  • open source
  • markdown

Read more in:

  • Essay Hubble, and the Assumption Baked Into a Notes App Now

    The more a format is optimized for machine legibility, the more it risks depending on the tool that enforces it

The Signal Over Noise Take

Vibe coding makes building feel too good. You think it, you describe it, it exists. The friction is gone. Each completed project triggers a little hit of accomplishment — ship something, feel good, start the next thing. That loop produces real output, which is what makes it tricky to spot as a potential treadmill. I’ve shipped more in a month using this approach than in some entire quarters. But “shipped more” isn’t the same as “accomplished more.” AI gives you speed. It doesn’t give you permission to skip thinking about what “done” means. The discipline isn’t in the coding — it’s in knowing when to stop building and start deploying.

Related terms:

  • claude code
  • llm
  • prompt engineering
  • vibe sourcing

Read more in:

  • V2-06 The Talking Wrench

    Links to a full unedited vibe coding session building a website with Claude

  • SoN-32 The Productivity Treadmill

    AI makes building feel too easy — shipping code faster raises new questions about when to stop

The Signal Over Noise Take

Vibe coding gives you code nobody has read, because it didn’t exist until you asked for it. Vibe sourcing gives you code with a history — commits, issues, a licence, a maintainer, and any vulnerabilities somebody already found and filed.

In practice this looks like “I need a system or software that does x” but instead of telling your agent to produce a plan to make and maintain it, you tell it to “Help me define my requirements, then let’s look for open source projects that are suitable”.

On generated code, only you can review it. On sourced code you can look at the last commit date, how the maintainer answers issues, what the licence actually permits, and whether there’s a CVE against it.

Related terms:

  • vibe coding
  • open source
  • integration over capability
  • mcp

The Signal Over Noise Take

The VPS migration is my favourite example of context compounding. Saturday afternoon: I researched whether a VPS would be cheaper than my DigitalOcean server. Saturday evening: I hit an SSL certificate cost wall on a new domain. The AI connected the two — if I moved to a VPS, I could use Let’s Encrypt for free SSL on all twelve domains. Same migration, two problems solved. By Sunday evening, twelve sites were running on the new server. I spent most of Sunday at the beach. The plan was solid because AI had context from both conversations. That’s systems over sessions.

Related terms:

  • api
  • automation

Read more in:

  • V2-08 The Co-Operating System

    Migrating twelve domains to a VPS saved money and eliminated SSL certificate costs through Let's Encrypt

The Signal Over Noise Take

A crawler doesn’t know your link was meant for one person. It follows anything reachable, and “reachable” is a lower bar than most people assume — a URL pasted into a public forum, a sitemap you forgot about, a page nobody linked but a competitor’s crawler guessed at. Two things follow from that. First, unlisted is not private; only authentication is private. Second, crawlers now feed AI training as well as search, so the question “do I mind this being indexed?” has quietly become “do I mind this being learned?” robots.txt and noindex tags are requests, and well-behaved crawlers honour them. Not all crawlers are well behaved.

Related terms:

  • noindex
  • training data
  • corpus
  • canonical url

Read more in:

  • Essay The Share Button Is a Publish Button

    The moment a shared link touched anything crawlable, search engines picked it up

  • Essay The ACM's Caution About LLMs Is Starting to Have a Cost

    Not opening the archive to any crawler that asks

The Signal Over Noise Take

Webhooks are the most underappreciated connector in the AI integration stack. They flip the model from “go check if something happened” to “get told when something happens” — and that distinction matters more than it sounds. A webhook turns a passive tool into an active participant. Most of the services you already use can send them; most automation platforms can receive them. The gap is that almost nobody has wired them together, because until AI could write the glue code, there was no easy way to.

Related terms:

  • api
  • n8n

Read more in:

  • V2-11 The Helpers

    Webhooks are the connectors that let a health check Worker trigger an n8n automation

Visit World Model

The Signal Over Noise Take

Fei-Fei Li calls this “one of the most important and most overloaded terms in AI today,” and the overloading is the problem. Computer vision, robotics, reinforcement learning and generative AI all claim to be building world models and all mean something different by it.

The taxonomy she and the World Labs team published splits it into three, and the split is worth carrying because each is held to a different standard. A renderer outputs observations — pixels meant for human eyes — and is judged on visual fidelity. A simulator outputs state: geometry and physics faithful enough that a program can compute on it. A planner outputs actions: given an observation and a goal, what should the agent do next. Moving along that chain, evaluation gets more expensive and more safety-sensitive at every step.

The practical use of the distinction is that it tells you what a demo has and has not shown. A system can generate a convincing video without being a safe simulator of what a warehouse arm should do next. As Li puts it, the buildings in a generated drone shot may look flawless from above, and fall apart the moment you try to drive through the city below. When somebody offers you a “physics-aware” system, ask which of the three they built.

Related terms:

  • interface world model
  • ai agents
  • llm
  • multimodal
  • inference

The Signal Over Noise Take

Wrappers are how I turn browser-based services into things AI can actually use. I have CLI wrappers for my email marketing platform, financial tracker, automation tool, and note-taking vault. Each one takes a complex API and reduces it to a handful of typed commands. The wrapper handles authentication, pagination, error codes — all the plumbing you don’t want to think about. The result is that my AI assistant can check subscriber counts or log expenses with a single command instead of navigating a web UI. If APIs are the doors between services, wrappers are the handles that make them easy to open. They’re not glamorous, but they’re what makes a genuinely connected AI stack possible.

Related terms:

  • cli
  • api
  • mcp

Read more in:

  • V2-11 The Helpers

    CLI wrappers turn browser-based services into typed commands that AI can execute directly

Visit Zero Trust

The Signal Over Noise Take

Zero trust flips the old model on its head. The old way assumed that once you were “inside” — on the office network, already logged in — you could be trusted to move around freely. Zero trust assumes the opposite: check every request, every time, no matter where it comes from. For AI, the practical version is small but important — don’t let an agent do something irreversible just because it’s already running; make it check in first. The “human yes” I keep on money, email and anything I can’t undo is exactly that: never trust the session, verify the action. It’s the wider model that least privilege lives inside.

Related terms:

  • least privilege
  • two factor authentication
  • service account

Read more in:

  • V2-29 Would you let an AI use your passwords?

    Keeping a human yes on every sensitive action echoes zero trust's 'never trust, always verify'

No terms match your search. Try a different keyword.

Sign up for the newsletter

Signal Over Noise

Deconstructing tech – by Jim Christian

Read

  • All posts
  • Guides
  • Newsletter

Topics

  • Security & Risk
  • Agents & Tooling
  • Working with AI
  • Building
  • The Industry

Reference

  • Glossary
  • MCP Servers
  • Skills
  • Where to start
  • Search

Follow

  • jimchristian.net
  • X
  • LinkedIn
  • GitHub
  • RSS

Work with Jim

Book an AI discovery session ↗ (opens in new tab)

The Members Library

See the Members Library

© 2026 Signal Over Noise by Jim Christian — deconstructing tech. Site by sleightof.dev (opens in new tab)

About Contact Privacy