September 2026

A walkthrough of four context-engineering techniques used inside a coding agent's harness — memory files, skills with progressive disclosure, LSP server feedback, and compaction — with implementation details from a from-scratch agent the presenter built. The argument is that degrading agent performance is usually caused by a bloated, noisy context window rather than the model, so swapping OpenAI for Anthropic won't help. Each technique is shown as both concept and code: how memory.md is appended and compressed, how skills load in three tiers, how an LSP server gives cheap syntax feedback, and how compaction and micro-compaction shrink the window at 80% and 60% thresholds.

Derek Comartin argues that multi-tenancy "best practices" (don't pass the tenant ID around, use ambient context, use global query filters) aren't wrong, but they're usually stated without their trade-offs. Every fix just relocates complexity: an ambient tenant context breaks when you cross from HTTP to a background message processor; automatic query filtering forces you to build a dangerous cross-tenant escape hatch; per-tenant feature flags eventually turn into modules and deployment complexity. The better question isn't "what's the right pattern" but "where does the tenant ID come from, and where should it be explicit vs. implicit?"

Owain Lewis walks through Jev, a "system one" model from Type AI that isn't an LLM: you send it a prompt and get back a typed, probability-scored answer instead of free text. He demos its three primitives (yes/no, choice, score) in Python, then shows real builds — support-ticket triage, an email classifier via Claude Code, a Codex model router, and a Bitcoin trading toy he admits is a bad fit. His verdict: at high volume it's dramatically cheaper and faster than an LLM (about $0.09 vs $14-29 to classify 5,000 emails), but not worth the added complexity for low-volume local work.

A walkthrough of seven free, low-star GitHub projects built around "Jev" (a non-language, decision-only AI model the creator says makes calls 40–200x faster than LLMs like GPT or Claude). The picks include a morphing UI text box (Shapeshift), a voice-controlled browser, a computer-use tool, an ad blocker, an MCP server that gives Claude Code judgment tools, a live "BS meter," and shipwithjev.com as an idea repository. The framing throughout: Jev is not a Claude replacement — keep Claude/Codex for planning and inference, and hand Jev the fast, binary, probability-scored decisions inside automated workflows.

A walkthrough of how to use Jev (a cheap, fast "decision model" sold by TypeSafe) rather than a chat LLM for the small fuzzy judgements inside software: routing tickets, classifying reviews, verifying claims. At roughly 4.2 cents per million input tokens and ~150ms latency, calls that were previously too slow or expensive become viable at scale. The video organises the space into five use-case categories, three decision types (null, choice, score), ten decision shapes, and four design patterns, then assembles them into a sample customer-support flow.

A former Google engineer argues the AI buildout has far outrun its revenue: roughly $725B in 2026 capex from five hyperscalers against about $25B in global AI services revenue last year. She stacks up the evidence of strain — collapsing free cash flow, power grid limits, failed enterprise pilots, rolled-back customer service agents, and legal liability from hallucinations (the Deloitte Australia report). Her conclusion is that the bubble is financial, not technological: AI survives like the internet did after dot-com, but the money will shift toward people who can verify and own AI output rather than just generate it.

Matthew Berman explains Jev, a newly released AI that isn't a text generator but a very fast, very cheap decision-maker: you give it structured JSON questions plus criteria, and it returns true/false-style judgments with confidence scores. He argues its edge is throughput and latency (4.2 cents per million input tokens, free output tokens), then walks through eight community-built demos: an AI-slop detector, an ad/slop blocker browser extension, Zapier automation steps, instant email prioritization, fuzzy find-in-page, dynamic UI assembly from a preset component library, 90-minute video clipping in under two seconds, and toy demos for color palettes and emoji matching.

A walkthrough of Anthropic's official prompting guide for Opus 5.5, condensed into 12 practical tips. The big changes: medium is now the recommended default effort level, switching effort mid-conversation no longer wipes your prompt cache, Claude Code now reads agents.md, and asking the model to show its reasoning can now be refused outright as "reasoning extraction." Several tips address new quirks in long-running agent work, like the model ending its turn before a task is actually finished.

A walkthrough of why Typesafe's new model "Jev" matters, framed as the history of classifiers \u2014 machines that sort things into piles rather than write answers. The speaker traces the line from Rosenblatt's 1958 perceptron through Paul Graham's 2002 spam filter and 2012 image recognition, all of which required custom training, to zero-shot LLM classification, which works but is slow and expensive. Jev is pitched as a fast, sub-cent, single-API-call classifier that returns a label plus a calibrated confidence number, and the speaker shows a small real example: a plain-English markdown "decision file" that Claude turned into a working script on the first try.

David Khourshid (creator of XState, founder of Stately.ai) argues that agent "slop" comes from unstructured delegation — handing an agent one mega-prompt and hoping for the best — and that modeling agent workflows as explicit state machines makes behavior inspectable and fixable. Using a small email-drafting agent as the example, he shows how the deterministic rules (you must draft before sending, only send approved emails, never invent a recipient) belong in the graph rather than in prompt text. His main new point versus his 2023 talk: the state machine isn't just guardrails, it's a durable artifact you can hand back to an agent along with traces and evals so the agent proposes an improved version of its own workflow, which you then A/B against the original.

A software developer who runs a few hundred coding agents across six machines (Mac minis plus VPSs, linked by Tailscale) walks through OpenRig, his "harness for the harnesses" that lets Claude and Codex sessions message each other directly and work as an organized fleet. He argues the viral Hugging Face story about ~1,000 agents "going rogue" is being misread: what looks like malice is really scope creep and coordination pathologies he's been cataloging for 18 months. He demos the abstractions (seats, pods, rigs, projects/missions/slices), the failure modes (bureaucracy, recursive proof loops, "just following orders," bad ideas spreading like viruses), and the fixes (refocus, an epidemiology rig, and agent productivity monitoring that watches ceremony vs. progress).

John, a senior staff engineer at Meta, argues that with AI-generated code volume exploding, the right answer to "do you still read your code?" is a gradient, not a yes/no. He proposes treating the codebase like a tree: review depth should scale with blast radius, so trunk/infrastructure changes get deep reading while gated leaf code gets a skim backed by agent-produced proof (tests, logs, screenshots, confidence levels). He also covers using a fresh adversarial review agent, PR templates, feature gating, and the claim that landing code only gets you 80% done s the final 20% of cleanup, auditing, and taste still takes as long and is still human work.

A review of "Jev," a new AI model from the co-inventor of ChatGPT that is claimed to be 20-200x faster and 40-400x cheaper than frontier models, with free output tokens. The key point: Jev isn't an LLM at all, it's a classifier that labels, routes and scores inputs with confidence probabilities, and it can't reply, write code, explain itself, see media, or do math. After walking through use cases (email sorting, YouTube comment tagging, a Skittles-sorting demo, model/skill routing, Smash Bros, a self-driving simulation), the verdict is that Jev is currently overhyped for most users, though real-time decision-making at scale looks genuinely promising.

Ben shows how to cut Claude token spend on the newest flagship model (transcribed as "Fable 5.1", i.e. the top Claude model) by telling it to run its sub-agents on a cheaper model like Sonnet. He claims the same customer-intelligence report that cost $350 by default cost $44 with one added line, with near-identical output. He then walks through five more habits: trimming the startup context window, pre-planning prompts instead of iterating, lowering effort level mid-chat, one chat per task, and avoiding three prompt phrasings that Anthropic says waste tokens.

Armin Ronacher (creator of Flask, whose company now stewards the Pi agent) argues that minimal, bash-first harnesses win because that's what models are actually trained on, and that the current chat-transcript agent interface is a temporary, DOS-like stage rather than the endgame. His own workflow is deliberately conservative — agents running locally on his Mac, a Linux box over SSH/Tailscale, very little cloud — and he's openly skeptical that enterprise AI coding rollouts have shown up in revenue rather than just in cost and commit counts. He also covers what's still unsolved (session portability, durability, agent-generated UI, database access instead of "memory"), why being in the training data is now a competitive moat, and why Europe's 27-country fragmentation holds it back.

Rob Shocks walks through Anthropic's newly released AI-native SDLC playbook, written by Claude Code's creator Boris Cherny. The core argument is that agents have collapsed the build step, so the bottleneck is now the rest of the process — planning, spec, test, deploy, maintenance. The playbook formalizes an artifact chain that starts with an intent.md file created by whoever originates an idea or bug, flows into spec.md and plan.md, and ends with maintenance where Claude can write its own intent.md from logs or alerts without a human starting it.

Nate Jones reports back from Dreamforce, where he asked Marc Benioff about AI adoption and then joined a panel on the cost of running agents at scale. His argument: agents got good enough that people use them for bigger jobs, which multiplies token spend (more runs times far more tokens per run), so the fix isn't just buying a cheaper model "" it's going back to a blank sheet and deleting handoffs that only existed because old systems couldn't talk to each other. He then layers on model routing via classifiers, matching harness thickness to model capability, and evals as the way to know any of it actually worked.

Dex Horthy (HumanLayer) walks through why he reversed his own advice on "review the plan, not the code." His team ran that experiment for four or five months, ended up with an unusable six-service codebase the model had architected, and rebuilt the product from scratch, with his co-founder hand-typing the new data architecture in VS Code. His current position: models have gotten much better at many things but not at writing maintainable code, because maintainability has no fast oracle to train against, so humans still need to read code while continuously investing in the skills, detectors and feedback loops that make the "factory" better.

Greg Isenberg and Ryan Vogel (founding team at OpenCode) break down "Jev," a new classifier-style AI that takes an input plus an output schema and returns probability-weighted decisions instead of generated text. The headline demo: classifying 1,700 emails by category, priority, spam score, and reply-worthiness for 18 cents, with roughly 200ms per query. They walk through where it fits (lead scoring, support routing, instant quotes, clip-finding, browser agents) and where it fails (a Bitcoin buy/hold/sell signal that performed badly), plus how to get access via the Vercel AI gateway while it's still waitlisted.

Nate Herk tests Jev, a new decision-only model from TypeSafe AI (trained with RLCD, reinforcement learning for calibrated decisions), across 12 use cases. Jev doesn't write text — it only outputs yes/no calls, category picks, and scores with confidence levels — which makes it dramatically faster and cheaper than chat models for classification work. In his benchmark, 1,000 emails across seven classification rules took Jev 6 seconds and 9 cents parallelized, versus 5 minutes and 62 cents for a frontier chat model. He argues the real play is using Jev as a cheap front-end filter in automations and then handing the narrowed-down data to a smarter model for actual analysis.

The video explains an MIT result on why making language models wider eventually stops helping. Because models pack far more concepts (~50,000+) than they have internal dimensions (~12,000 for GPT-3), concepts overlap in a phenomenon called superposition, and that overlap causes "interference" errors. Doubling a model's width halves that interference, but each doubling costs roughly six times more, the improvement rate is pinned in place by the statistics of human language (Zipf's law), and once width matches the number of genuinely independent concepts there is no interference left to remove — so extra width buys nothing.

The argument: as AI lowers the cost per feature, companies don't save money — they build far more features (Jevons paradox applied to software), producing ever-larger, more complex codebases. Then the video walks through how LLMs actually read code (tokens, embeddings, causal attention) to show why those same models struggle to maintain what they build: context windows are finite, attention is O(n²), long contexts suffer from 'lost in the middle,' sparse attention can skip critical links, and retrieval fails when coupling isn't expressed in code. The result is a self-reinforcing loop where the tool generating the complexity is the tool least able to comprehend it.

A walkthrough of Jev, a new "system one" classification model from Typesafe (built by a co-inventor of ChatGPT) that only returns true/false answers, a pick from a menu, or a 0-10 score — which is why it's roughly 20-200x faster and 40-400x cheaper than general-purpose LLMs, with free output tokens and ~4 cents per million input tokens. The pitch is to pair it with a system-two model like Claude rather than replace one. Three concrete uses are demoed: automated model routing inside Claude Code (70% token savings across 12 test prompts), high-volume business classification like lead triage, and semantic search in apps.

Brett argues that calling AI "just a tool" is a thought-terminating phrase that lets people dodge responsibility for what LLM products actually are: subsidized commercial services from companies making reckless claims, built on massive data-center and training costs. He contrasts LLMs with genuine tools like a power drill, Emacs, or Vim — things that do one task, don't degrade your skills, don't "sometimes make mistakes" by design, and whose makers don't publicly speculate about wiping out humanity. His ask is simple: stop using the phrase, because it justifies nothing and normalizes an unstable technology.

A walkthrough of "system one" classification models — fast, structured-decision models that output choices and probabilities instead of text. The host shows Jev (a closed, API-hosted model from TypeSafe AI, now open to everyone with no waitlist) alongside Leia, an open-weight local alternative released days later that runs on Apple Silicon. He demos Leia driving a browser agent to search Google Flights, plays Snake at ~30 decisions/second locally, and walks through Jev's playground where you define states, questions and criteria in JSON.

Cal Newport talks with author Brad Stulberg, who spent months genuinely trying ChatGPT and Claude as writing tools and then quit almost entirely. Stulberg lays out a three-plank case for a "humanist resistance": AI removes the effort and struggle that make work meaningful, it homogenizes output toward a soulless average, and it quietly crowds out the human connection and learning that come from doing things the hard way. Both argue the AI conversation should shift from existential risk and productivity hype to a simpler question — does this make your individual life deeper and better? — and that it's fine to wait until a tool is obviously, easily useful before adopting it.

Owain Lewis walks through a Pragmatic Engineer article describing how OpenAI runs an agent-driven "software factory" — Codex writing code, CI looping until it passes, multiple specialist review agents, a risk classifier that decides what can auto-merge and auto-deploy, and a severity bot that triages production incidents. He then builds two live demos of his own: a Codex automation that labels open pull requests by risk and auto-merges the safe ones, and a Google ADK agent that consumes production alerts via pub/sub, investigates logs and metrics, and recommends a fix. His conclusion is that risk classification and automated on-call triage are the two ideas most worth copying today.

Ray Amjad walks through Jev, a new "System 1" model from TypeSafeAI that doesn't generate text at all \u2014 you give it a prompt, some data, and a fixed set of answers, and it returns probabilities in roughly 100ms for a fraction of a cent. He explains its three primitives (bool, score, choice), shows it playing Minecraft under GPT-5.6's strategic direction, then argues the real payoff is pairing it with slow agents like Claude Code: cheap screening across a whole codebase, with only the high-probability hits escalated to an expensive model. Demos include analyzing 150 code comments in 9.3 seconds for about a cent, and a full-codebase code-smell pass estimated at 28 million input tokens for $1.19.

Cole Medin walks through how he's evolving his personal AI second brain into a shared "team brain." The key architectural decision: keep the personal agent (personality, custom memory, interface) on each individual's machine, and centralize only the knowledge base in a database that every agent queries through a single MCP server. The rest of the video covers how to normalize every source into one documents table, label documents by domain at ingestion, enforce row-level permissions in the database using tokens, and use hybrid keyword + semantic search for retrieval. The demo is built on the Oracle AI database (a disclosed partnership) with LangChain, but he stresses the strategies apply regardless of tooling.

Lars Faye argues the industry is sending contradictory signals about agentic coding: one camp says coding is solved and you can be vague with prompts, while anyone who gets bad results is told it's a skill issue. His counterpoint is that the elaborate specs, verification loops, and pipelines needed to make agents work well are themselves proof that deep domain expertise still matters — which contradicts the 'coding is solved' claim. He positions himself as a delegator rather than a full agentic workflow adopter, still reading and writing code because that's how he figures out what to build.

Dex Horthy argues that the "lights-out software factory" — where agents write code and humans stop reading it — fails, and that no amount of harness engineering can fix it because the problem lives in how coding models are trained. RL for coding agents rewards "tests pass, nothing broke," which gives no signal for program design or long-term maintainability, so agents reliably erode codebase quality. His prescription is to put code review back and use AI heavily in upfront planning — product review, system architecture, program design, vertical slices — so that reviews get fast enough that reading every line stays feasible.

The argument: architect isn't a promotion for writing better code, it's a different job with a different output. Three skills mark the shift — systemic thinking (pricing trade-offs across the whole system, not just the local fix), organizational influence (framing technical direction in cost, risk, and value for non-engineers), and structural design (changing the conditions that create coupling rather than fixing the coupling). Technical vision means answering where you are, where you need to be in 2-3 years, and how to get there without stopping the business, with the migration path built in. The catch: your primary artifact becomes decisions, documents, and alignment, which many developers experience as a loss.

Nate B Jones uses Omarchy, DHH's Linux desktop, as a preview of what happens when an AI agent can actually reach into your operating system and change its defaults. The real argument isn't "install Linux" — it's that agents make personal, audience-of-one customization possible, and you can start on the Mac or Windows machine you already own using tools with readable configs and documented commands. He also spends a chunk of the video on the permission and trust problems that come with letting an agent edit your OS.

Cory Doctorow argues that today's AI boom rests on a category error: LLMs find statistical correlations but don't understand anything, so they hit hard limits and steep diminishing returns. The money behind it is worse — roughly a trillion dollars spent this year against about $50 billion in revenue, with Nvidia lending its customers the money they spend at Nvidia, and OpenAI apparently booking giveaway inference as 'marketing.' He expects the bubble to pop from some brittle link (a margin call, a data center financing tranche walking away, Gulf money redirected to rebuilding oil infrastructure) and wants it popped sooner rather than later, because every skilled worker replaced by a chatbot destroys 'process knowledge' that takes a generation to rebuild.

Bilawal Sidhu follows up on the viral open-source release of God's Eye View (a browser-based "spy satellite simulator" that layers live flight, vessel, traffic, CCTV and other data over 3D map tiles) with two things: how to install it without being a coder, and a full feature walkthrough. Installation is either a one-click Pinocchio installer or dropping the GitHub repo into a local AI coding agent like Claude Code or Cursor. The rest is a tour of flights and cockpit mode, voice control via an OpenAI key, CCTV and traffic layers, vessel/AIS coverage gaps, earthquakes, fires, data centers and submarine cables, ending with how to use the tool as a base for disaster reconstructions and custom layers.

A solo beach rant about prominent developers reversing their stance on AI-assisted coding. The host points to DHH and now ThePrimeagen (and TJ DeVries, who joked about vibe-coding a Neovim GUI plugin without knowing how it works) as evidence that public resistance to "AI slop" has collapsed. His objection isn't productivity but dependence: slop-filled codebases become unmaintainable by hand, which locks developers into renting their skills from AI companies, contradicting the independence ethos of the FOSS/Linux community. He argues local models won't save you and that hallucinations are inherent to LLMs, so he'll stay a self-described Luddite.

A hands-on review of the Oh My Pi coding harness, tested against a local llama.cpp server through a logging proxy and compared to Pi and Open Code. The reviewer's main complaint is weight: a single "hello" burns roughly 19,000 of 128,000 context tokens (4.5k system prompt, 11k tool descriptions), the built-in system prompt is long and highly opinionated, and defaults like 32 concurrent sub-agent workers and OS-level notifications are wrong for local hardware. He likes the built-in sub-agent scouts and the UI, and notes most of the bloat can be trimmed via config, but would personally pick Pi (and Open Code above that) because he'd rather build up a minimal tool than strip down a heavy one.

Felienne Hermans, creator of the Hedy programming language, uses her own disillusionment with computer science to argue that the field systematically values difficulty over usefulness. She traces this from dismissals of spreadsheets as "not real programming," to Python and nine other top languages rejecting Arabic-Indic numerals as invalid characters, to a feminist-epistemology reading (via the "Glaciers, Gender and Science" paper) that hard-to-reach problems get studied because they make the researcher a hero. She then connects this to the field's unexamined history (von Neumann and the atom bomb, IBM's punch cards for Nazi Germany) and to the LLM hype, arguing that AI inherited its benchmark-everything methodology from decades of chess research. Her closing point: chess computers exist but are barred from human competition, and we could choose the same for programming, writing and art.

The video explains why coding agents like Claude Code and Codex burn tokens: before making any change they have to grep and read their way to the right file, and every tool result gets resent to the model, bloating context and slowing things down. It then covers Graft, a free open-source CLI trending on GitHub, which builds a knowledge graph (nodes and edges) of your codebase so the agent knows which files and lines to open before it calls a single tool. Graft's own benchmark across 162 runs claims 60% less time, 46% fewer tool calls, 42% fewer tokens and 32% lower cost, and the presenter's own test showed a modest gain on the first build but much faster edits afterward.

Nate Jones argues that OpenAI's release of GPT-6 "Astra" marks the practical arrival of AGI — not by benchmark, but because you can now hand a model an open-ended problem with no method and it will pick tools, build its own working environment, and stay in the job for days. He points to Ethan Mollick leaving Astra alone for five days with emails, calendar, contacts and writing until it produced a personal knowledge system, plus enterprise examples from Logora, Playco and Vercel. His core claim: the bottleneck is no longer intelligence but trust, and the last 1-2% of trustworthiness is where trillions in value sits. The rest of the video is about how work, management, and junior careers change when everyone runs persistent agents.

Austin Marchese reframes prompt engineering as "graph engineering" — designing the shape of the workflow you hand to Claude — based on a course by Andrew Ng. He covers four graph shapes that matter (chain, diamond/fan-out, branch, loop), the "wait test" for finding steps that don't actually need the previous step's output, and the specific failure mode of each shape. The closing argument is that the real transferable skill here is problem solving, not any particular tool.

Cory Doctorow argues that both AI boosters and many AI critics are making the same mistake: repeating tech companies' grandest claims about their products, which he says helps sell those products to credulous bosses. He lays out why he thinks AI is a financial bubble with terrible unit economics (every new user and every new model loses more money), why the underlying "theory-free inference" can't become understanding, and why the real danger isn't rogue AI but a market crash plus decades of rotten cybersecurity practice. Host Michael Walker pushes back hard throughout, defending the view that LLMs are genuinely improving and that agentic behaviour like the Hugging Face incident is a real new threat. The conversation ends with Doctorow rejecting fully automated luxury communism as a near-term prospect: climate adaptation will require full employment for 500 years.

Dylan explains why the old advice to "start fresh chats often" has partly changed: compaction (auto-summarizing long chats) and native memory in Claude and ChatGPT now make long conversations viable, but mainly in desktop agents like Claude Cowork and Codex rather than in the browser. He lays out two setups: Setup A, fresh chats in a task-dedicated folder with an instructions file (claude.md / agents.md) plus an externalized memory file, which covers ~95% of use cases; and Setup B, a pinned thread that runs for weeks or months, only for tasks with no finish line where yesterday's context helps today's work (inbox assistant, long-running project monitoring). Both setups rely on keeping memory files short (150-200 lines), pruning them periodically with approval, and, for pinned threads, generating a one-to-two-page handoff document when intelligence degrades and it's time to start a new thread.

A rundown of 19 Claude Code habits that are now outdated or costly, most of them sourced from Anthropic's own docs and recent product changes. The big themes: persona prompts don't help (drop them for location, done-criteria and self-check instructions), context is cheaper to manage than you think if you configure connectors, auto-compact and CLAUDE.md correctly, and several "savings" moves like switching to a cheaper model mid-conversation or leaning on sub-agents actually cost more. It closes with a set of little-used slash commands: /doctor, /insights, /btw and /branch.

A head-to-head of OpenAI's "GPT-6 Astra" (run through Codex) against Anthropic's "Claude Fable 5.1" across benchmarks and four one-shot practical tests: a browser Fortnite clone, an AI travel landing page, a 15-second motion-graphics explainer, and a 3D globe flight dashboard. Astra won three of the four and tied on motion graphics, while also being roughly half the token cost for similar benchmark scores. The conclusion isn't that Fable 5.1 is bad, but that Anthropic's usage-limit practices plus Astra's edge make splitting subscriptions between both worth considering.

Nate runs Anthropic's newest model (referred to throughout as "Fable 5.1") through real knowledge-work assignments instead of benchmarks: a GoPro/Starman acquisition DCF plus executive deck, a 100-word writing test, and a 37-second architectural walkthrough built from scratch in Blender using only a Seattle property address. The headline finding is that the model's low effort setting already produces genuinely usable work — a seven-sheet workbook and 13-slide deck with working formulas — while higher effort buys better reasoning hygiene rather than just more pages. He argues the real story is token efficiency and effort-tiering, not a model ranking, and recommends mixing models across passes.

Scott Tolinski surveyed nearly 1,300 developers and interviewed a psychologist, a burnout researcher, and several veteran programmers about what heavy AI prompting is doing to people. The pattern in the responses: 46% regularly prompt past when they meant to stop, 65% feel pressure to produce more because AI makes it possible, 59% think their skills are diminishing, and 54% enjoy coding less than before. The explanation offered is that agent prompting works like a variable reward system — slot-machine dopamine — and that the time AI saves comes back as more review, more decisions, and a higher baseline expectation rather than rest. The video argues fixes like hard stop times and offline rituals only work if your job actually lets you stop.

Anthropic shipped "function hooks" for Claude Code, which the presenter calls the best feature yet. Unlike the older shell hooks, function hooks act like Express.js middleware: they can rewrite prompts and tool inputs, short-circuit calls with a cached store, override built-in tools, ask the user questions, add UI rows and panels, and call models or HTTP endpoints. You turn them on with CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1 claude, which unlocks a built-in plugin-authoring skill that writes the hooks for you from a plain-English description. Demos include automatic secret redaction, a live Vercel deploy status bar, an Exa search override, and a text-to-speech turn summary.