Starred

Anthropic says Claude now writes ~90% of Claude Code's own code, so they've shifted from "did a human read this?" to layered automated checks plus risk-tiered human review. The flow stacks self-checks, multi-agent bug review with voting, a security pass, CI, and a classifier that decides whether 0, 1, or 2 humans must approve. They keep the reviewer honest with daily evals built from real incident bugs, and cap review rounds after agent-vs-agent loops ran a PR through 50+ cycles. The video closes by poking at the headline stats: a 40% drop in revert rate alongside doubled PR volume still means roughly 20% more reverts overall.

Jake Van Clief argues that most people don't need to build custom AI agents — they need well-organized folders of markdown files describing who they are, how they like things built, and who their clients/investors are. He contrasts the old approach (databases behind APIs, custom Python connectors, per-task tools, one agent per output format) with giving a single model a minimal "harness" of read/write/search tools plus a readable folder tree, so adding a new capability means adding a folder instead of building a new agent. The second half of the video traces computing history — the Jacquard loom, Ada Lovelace, Descartes, Turing, Claude Shannon, Grace Hopper, compilers, C and Python — to argue that natural language is simply the latest layer of abstraction over machine code, and that structuring your intent in folders is the current step in that lineage.

Rob Walling's MicroConf Europe talk argues that AI isn't ending SaaS, but it is quietly dismantling most of the moats founders relied on. He lays out ten ways AI can attack a SaaS business — six supply-side (customers, competitors, open source, platforms, agencies, the models themselves) and four demand-side (customers going out of business, seat contraction, the managed workflow disappearing, humans being replaced by agents) — and estimates 10–20% of SaaS companies will decline or go to zero. He then names eight moats he thinks still hold, each with a big-name and a small bootstrapped example, plus the question you should ask to test whether you have it.

Ray Amjad walks through Felix's Anthropic essay "How to Be More Ambitious," which splits ambition with AI agents into four types: speed, altitude, depth, and range. He skips speed as the thing everyone already does, and spends the video showing concrete Claude Code and Slack-agent setups for the other three: prompting for outcomes instead of tasks, insisting the model use the actual tools an expert would use, and borrowing solutions from unrelated professions. The through-line is that the bottleneck is no longer the model but the ambition of the prompt and the tooling/access you give the agent.

Rob Shocks walks through Pstack, a skill/playbook bundle from Lauren Tan (React core team, ex-Netflix, SpaceX, now Cursor) that packages a senior engineer's workflow into 20+ agent skills routed by a "potato mode" dispatcher. He uses it to one-shot a skill manager app called Molten Base, then breaks down the standout skills (arena, swarm, why, recall, interrogate, create/maintain verification, onslaught, brawl) and the underlying principles. Verdict: it roughly doubled build time and burns far more tokens than a plain agent run, but produced a noticeably more hardened app, so it's worth using selectively rather than on every project.

Earl Brandt of Kira argues the industry's latest pitch — that the real value of AI coding lies in increasingly elaborate agent "harnesses" — doesn't hold up. He walks through a recent EPFL/Apple paper where a bare-bones agent with just a file system and three tools beat sophisticated multi-agent scaffolding across every frontier model tested, with delegation and sub-agent setups actually making results worse. The second half is an interview with a developer, Marcos, who uses Brooks' "No Silver Bullet," Gall's law and Jevons paradox to argue that AI shifts where engineers work rather than eliminating them.

Eric walks through an open-sourced "software factory" — a set of Claude-style agent skills that pull issues from telemetry tools (Sentry, PostHog), turn them into GitHub tickets, and run them through a builder → QA → reviewer loop that mimics a real dev team. Each specialist agent chains curated skills: Ponytail for complexity reduction, Context7 for library docs, MapPoke for implementation, plus dedicated QA and review flows, with every agent comment logged on the GitHub issue. The setup is meant to be model- and harness-agnostic (Claude Code, Codex, etc.) and installable in about three steps.

Claude Code Projects is a beta feature (waitlist, now effectively open) that puts a Claude orchestrator in Anthropic's cloud, where it spawns and manages persistent full Claude sessions called threads. Unlike sub-agents, each thread keeps its own context window, opens its own pull requests, can be messaged directly, and keeps running when your machine is off — and it bills against your Max subscription usage rather than API credits. The video walks through the settings (coordinator vs thread models, memory, GitHub repo, cloud environments, secrets, local folder access) and a 25-minute demo where one prompt split into five parallel threads that built an "AI Creator Radar" dashboard.

Two bets on AI are running in opposite directions: that AI makes software worthless, and that AI companies won't earn enough to repay their debts. The first bet looks weak — the viral "free Photoshop" built with AI covers only about a third of professional work by its own roadmap, and Adobe just posted a record quarter even as its stock fell ~30%. The second bet has real evidence behind it: AI borrowing collapsed from a record $113B in June to $23B in September while the cost of insuring Oracle, CoreWeave and even Big Tech debt hit records. The video's conclusion is that AI can make code cheap to copy without making anyone rich — the value may be leaking out to users rather than landing with model makers or lenders.

A tour of the creator's complete daily terminal setup, layer by layer: Ghostty as the terminal emulator, tmux (with his own SessionX and Floats plugins) for multiplexing, Workmux for managing Git worktrees, and Pi as his coding agent. He also announces he has abandoned Nushell and returned to zsh/POSIX after a year of advocating for it. The rest covers zoxide, Atuin, fzf, Starship, Neovim, Superfile, Television and Mise, all of which live in his public dotfiles repo.

Bigger context windows don't make agents more reliable a study of 18 frontier models found all of them degraded as context grew, a phenomenon called "context rot." The video breaks down four ways an agent's context window goes bad (poisoning, distraction, confusion, clash) using a running example of an agent migrating a codebase to a new database driver. Each fix validate, compact, curate, prune works by deliberately throwing information away.

A walkthrough of P-Stack, an open-source repo of AI coding skills, workflows, and principles published by Lauren Tan (Cursor, ex-Meta/React team). The reviewer maps her skills onto a six-stage AI software development lifecycle — planning, design, building, testing, deployment, maintaining — and notes the defining difference from other skill sets he's reviewed: P-Stack fans work out across multiple models and agents instead of relying on a single model. He concludes that the planning skills are weak for greenfield solo building, but the design fan-out, the 'no comments' rule, 'attack the premise,' and the type-system principles are worth stealing.

Matt Pocock, a self-taught developer who says he stopped writing code by hand around the release of Opus 4.5 in December 2025, argues the highest-leverage skill in the AI era is communication: being able to surface your unknown unknowns and tell an agent exactly what you care about. He claims the environment agents work in (a clean, testable, verifiable code base) matters far more than which model or harness you pick, and tells the story of abandoning spec-driven development after months of watching his code quality degrade. His practical advice: climb a "trust ladder" slowly, give agents your boring work rather than your most ambitious tasks, and run models at lower effort levels than most people do.

IndyDevDan walks through Pi durable, a new release from the Pi coding agent maintainers that detaches agents from the client so they survive crashes, restarts and disconnects while keeping session, shared application state, tasks and tools. He demos a 'proactive' on-call agent that a Jev classifier triggers off a live event stream: it detects a production bug, investigates, writes a fix and waits for his approval, all for pennies. The rest of the video tours the durable feature set (background compaction, shared JSON app state across sessions, phased durable jobs, hot-swappable tools and extensions, forking) and argues that owning a controllable, extensible harness is the key move for agentic engineers.

A hands-on benchmark of the new hosted "system one" classification model (transcribed as "Jeff"/"Jev") against classic few-shot machine learning. On AG News, TREC, 20 Newsgroups and Clinc-150, it beats SetFit trained on eight examples per class by roughly 9 points and costs about a penny and a half per validation run, but open Qwen models wrapped in a "Decider"-style token-matching setup get competitive or better locally. The conclusion: don't think of it as a classification model — it's a classifier plus a little bit of quick reasoning, and its best use may be as a labeler that bootstraps or audits your own models.

Vercel CEO Guillermo Rauch walks through how he actually works with coding agents: a minimal CLI harness (FX) aliased into shell shortcuts, agents used for research and "agentic inquiry" rather than line-by-line code review, and a company policy of trying every model rather than standardizing on one. He argues the real differentiator is iteration velocity (speed in a direction) and latency from customer signal to shipped fix, not PR counts or token spend. A large chunk of the conversation is about security: he claims human-written code hides an immeasurable backlog of latent vulnerabilities that agents can now find cheaply, pushes memory-safe rewrites and cloud sandboxes, and criticizes OpenAI/Anthropic for not releasing full agent traces after the Hugging Face incident.

Dex (Human Layer) and Aaron (CTO of Boundary/BAML) walk through a pipeline that mines a team's coding-agent sessions and turns them into proposed CLAUDE.md entries, rules, and a report on what agents keep getting stuck on. The naive version (strip tool calls, dump user/assistant messages into one structured-output call) was directionally right but bad and expensive; the rebuilt BAML pipeline splits into three sub-flows — facts agents discovered, corrections humans made, and questions agents keep re-researching — with cheap classifier pre-screening and stronger models for judging, landing at roughly two cents per session. Most of the episode is process: build throwaway dashboards, cache and replay steps, read the actual prompts, and compare everything against a golden run made by Claude Code. They end on the unsolved part: how to tell when a memory has gone stale and how to feed human accept/reject decisions back into the pipeline.

Shapiro argues that recursive self-improvement is already happening, but not in the Skynet sense: it just means the share of AI progress (code, data, math) produced by AI itself is climbing fast — roughly 5% two years ago, ~30% now, and 50-80% expected next year. He points to OpenAI's and Google's recent batches of solutions to unsolved math problems (including Erdős problems) and rumors that Anthropic and Google are close to RSI as evidence. The second half argues the big downstream unlock is formal verification, which would let AI push into material science, medicine and other math-heavy fields, and that current capabilities are only at the 'sentences' stage of an emergence curve that goes much further.

A walkthrough of the full lifecycle of shipping a production AI agent: a website concierge chatbot for a hotel business (modeled on a ~$5,000 freelance job) built with Google's Agent Development Kit, FastAPI, Gemini Flash and Postgres, deployed on Google Cloud Run. The process goes requirements doc → architecture doc → Linear tickets written as mini-specs → coding agents (Claude Code, Codex) doing the implementation → adversarial browser testing and LLM-as-judge evals → production concerns like backups, logging and metrics. The closing argument is that planning and architecture matter more than code now, because code is cheap to change and infrastructure decisions are not. The video is an acknowledged partnership with Google Cloud.

A rundown of 23 habits that waste usage limits or degrade output quality on the newest Claude models, drawn from Anthropic's own guides, engineer comments, and power-user tips. The core themes: keep sessions scoped to one task, stop paying to re-read bloated conversations, stop defaulting to the biggest model and highest effort, and put guardrails around file edits, plugins, and MCP connectors. It ends with advanced fixes like cache-warming loops, session retention settings, manual compaction instructions, and automated model routing.

Rob Shocks breaks down Andrej Karpathy's post about a widening gap in how people use AI, which Karpathy frames as a four-layer funnel: ~6 billion people barely touched by AI, 1-2 billion casual chatbot users, ~20 million professionals using frontier models for coding and math, and ~5,000 people inside labs running agent swarms. The gap exists because of access, "jaggedness" (AI excels at verifiable digital tasks like code and math, lags at fuzzy ones like email), and the fact that impact scales with ambition. The host admits he thought he was in layer three but was mostly rebuilding existing SaaS apps faster, and argues most people — including experienced developers stuck in a 2024 mindset — are nowhere near ambitious enough with what they ask these models to do.

Philipp Lackner shows a ~20,000-line Kotlin cloud file manager app built almost entirely by AI agents in two or three working days, then argues the only reason it works is that he has hand-written every one of those patterns hundreds of times before. His point: AI agents are now mandatory for a coding career, but reading AI-generated code teaches you almost nothing, so you should only delegate concepts you already understand deeply. His test is whether you could pass a spontaneous coding interview on a topic; if not, write that code yourself first.

The video argues that a year of Claude Code advice is now outdated because the newer models (Opus 5/5.5) handle planning, self-checking and delegation on their own. Boris Cherny, who built plan mode, reportedly said on Hacker News that it's no longer useful; the replacement is a short brief with task, guardrails and a definition of done, then checking the output afterwards. The rest is a cleanup list: drop 'think hard' prompts for effort levels, turn done-criteria into runnable checks plus /goal loops, shrink CLAUDE.md to an index of pointers, build skills only from observed failures, replace shouty rules with hooks, and let Claude spin up its own subagents within caps.

A developer named Brandon Thomas rebuilt seven Adobe Creative Cloud apps in Rust under the name Artcraft, open-sourced them, and made them run on Linux too. Fireship tried the Premiere clone (FilmCraft) to edit this very video and found it laggy and visually inferior, but says the real story is a separate viral tool, Reverse Engineer Anything (REA), which wraps Ghidra and AI agents to decompile stripped binaries, JVM bytecode, .NET assemblies, firmware, and container layers into readable pseudocode. The practical workflow is: decompile the one feature you want, hand the garbage pseudocode to a coding agent, and have it reimplement the feature in Rust so you can build a stripped-down clone of any paid app.

OpenAI dumped 372 claimed math results on GitHub, many machine-verifiable in Lean but unexplained even by OpenAI's own mathematicians, while the company declined to publish the prompts its own advisory group asked for. The video ties that missing-receipts pattern to the AI debt market, where lenders are demanding to see books and OpenAI's annualized revenue just came in near $50 billion rather than the widely repeated $70 billion. It then covers an AI-assisted attack on at least nine South Korean banks by one person using an open-source tool, and proposes a three-layer accountability system modeled on anti-money-laundering rules.

Docker Agent is an open-source Docker tool that lets you define an AI agent in a YAML file — model, instructions, tools — and run it with a single command, with Docker handling the agent loop (call model, run tools, feed results back). The video walks through a minimal agent, then a two-agent incident-debugging setup where one agent holds the logs and another queries it over the A2A protocol, and finishes with three agents playing a full battleship match. The pitch is that agents become versionable config you can push to a registry and expose as HTTP, MCP, or A2A services instead of hand-written Python boilerplate.

REA ("reverse engineer anything") is a fast-rising GitHub repo — roughly 7–8k stars in a day — that packages an MCP server and CLI around existing reverse-engineering tools like Ghidra, Hopper and IDA Pro so a coding agent (Claude Code, Cursor, Codex) can investigate compiled binaries it has no source for. It doesn't recover original source code; it returns pseudo code, assembly, module maps, call paths and network activity with confidence levels and evidence. Rob demos it on a deliberately stripped and optimized "vault" app he built, and the agent finds the unlock logic among 242+ unnamed functions and writes a working code generator. His conclusion: reverse engineering was always possible, REA just removes the friction that acted as de facto protection, so code was never really the moat.

Mario Zechner and Armin Ronacher talk through Pi Durable, a new release of the Pi agent harness that lets an agent survive a process crash and pick up exactly where it left off. Mario explains the design in detail: instead of event sourcing, everything in the harness is an "effect sandwich" (record intent → run the effect, ideally idempotently → persist the result), paired with a small versioned document store for application state that can be rewound alongside the conversation. The rest of the conversation covers where coding models have genuinely gotten better (anything with an oracle: tests, fuzzing, emulators, reverse engineering) versus where they haven't (architecture, because the act of designing software was never written down to train on), plus Earendil's plans to build non-coding-agent products and the unsolved security problems of extensible web UIs for agents.

Lars Faye explains why he deliberately rejects the "AI-native, agents-first" workflow and instead treats models as a delegation layer rather than an abstraction layer: he states the intent, the model handles the how, and he still reads and owns the code. He delegates along four buckets — rote work, refactors, research, and reinforcement (self-taught tutorials) — and demos each with Zed as his editor and OpenCode's cheap open-weight models (GLM, Kimi, MiMo) on a $10/month plan. Examples include pulling formulas out of an Excel spreadsheet into PHP, swapping a browser alert for a custom modal in a years-old codebase, and using a model as an interactive Laravel tutor. His closing point: code generation solved the typing problem, not the thinking problem.

Dexter Horthy (CEO of Human Layer) argues that although coding agents got much better at solving problems in 2026, they did not get better at keeping codebases maintainable, so the "lights-off" software factory where nobody reads the code doesn't work yet. He backs this with SlopCodeBench, a University of Wisconsin benchmark that reveals models' code degrades as features accumulate (GPT-5.5 scored 14.8%), plus industry data showing code review quality down and incidents/bugs per PR up. He then lays out ~9 practices for an agentic "software factory" — plan before building, align visually, give agents back pressure, feed user feedback and pager alerts straight into PRs — and sketches the buy-or-build layers (compute, dev environment, harness, control plane) that Human Layer is targeting.

Turbopuffer, the vector search vendor behind Cursor, Notion, and Anthropic, is demoting the vector index in its v3 engine from the center of the system to just one index among keyword search and filters. The video walks through the three alternatives competing for that center slot s agentic search loops, live MCP connectors, and pre-compiled knowledge files s with benchmark numbers and costs for each. The conclusion: vector DBs aren't dead, just demoted, and for most new builds the default should be an agent with cheap search tools, keyword search first.

Fireship recaps a chaotic week in the open-weight model race: Mistral released Mistral Large 4, a trillion-parameter mixture-of-experts model with a million-token context window, one day after US startup Reflection AI finally shipped Beam, a 501B-parameter model trained on $6.3 billion worth of GPUs that Mistral promptly out-benchmarked. Meanwhile Moonshot AI closed a round at a $50 billion valuation while its Kimi K3 model already does what both Western labs are chasing. The underlying argument: privacy, surveillance, and sovereignty are why every government wants an open model of its own.

A rant against what the host calls the "Markdown Industrial Complex" influencers packaging prompt files, "skills," and agent stacks as proprietary AI-coding methodology. His claim: there is no special skill in AI coding beyond picking a reasonable effort level and putting in long hours, and the people shipping huge volumes of PRs are just working 10-12 hour days. He argues the tricks people distribute are usually AI-generated themselves, address problems newer models already solved, and that real capability gains come from labs post-training the models, not from your prompt folder.

The creator uses an anecdote from Bill Bryson's A Short History of Nearly Everything — about an amateur astronomer who hunts supernovas by eye rather than by computer — as an analogy for developers who still write code by hand in the AI era. His point: AI is a tool that can be used in different doses, and if you genuinely enjoy writing code, there's no obligation to hand it over to Copilot. He also notes the astronomer's line that he 'still beats them sometimes,' suggesting manual work occasionally catches what automation misses.

Anthropic shipped "mods" for Claude Code (released Oct 1), small add-ons that change how Claude Code itself looks and works by listening to events and watching, modifying, or handling them. The video walks through nine mods worth trying — Savvy Progress, Claude Skins, You Should Know, File Tree, Cache Tax, Blast Radius, Reflect, Terminal Browser and Replay Theater — and explains how mods differ from skills and MCP connectors. Building one is just a matter of describing it to Claude, which has a built-in "plugin authoring" skill; mods are temporary by default until you ask Claude to save them as an installed plugin.

Rob compares three popular Claude/agent skill packs: Addy Osmani's newly open-sourced set (25 skills plus four reviewer personas, built around a six-stage define/plan/build/verify/review/ship lifecycle), Matt Pocock's small composable skills focused on upfront alignment, and Lauren Tan's PStack focused on verification and evidence. His conclusion: Osmani's pack is the most team- and enterprise-friendly because it follows the conventional SDLC with no new metaphors to learn, Pocock's is best for fuzzy design problems, and PStack is best for gnarly bugs, migrations and long autonomous runs. The bigger argument is that you shouldn't install everything everywhere — ceremony should match the stakes, and extra skills bloat context and auto-trigger when you don't want them.

Kyle Cook argues that developers are wrapping deterministic logic in English prompts and AI "skills" when they should just write a program. He uses Gary Tan's G stack skills as an example: a markdown-to-PDF skill that is essentially code and if-statements written out in prose, fed into a non-deterministic machine. His fix is to generate a CLI tool or small scripts once, let the AI call them, and isolate AI to the genuinely ambiguous step "- like transcription in his own video editor "- so one hallucination doesn't break an entire chain.

Kent Beck argues that the claim "AI is better at coding than humans" is nonsense: LLMs (which he calls "the genie") produce plausible code that often doesn't actually work, so programmers and buyers now need an adversarial posture toward AI-generated software. His central model is a tradeoff between features (visible progress) and futures (optionality to change), and he says the real skill is pausing between features to restore optionality rather than racing to the zero-option mess that AI now lets you reach in a week instead of a decade. He dismisses spec-driven development as rebranded waterfall, explains why formal methods still leave a gap, and closes by warning that lines of code and PR counts measure effort and output, never mission.

Syntax Weekly covers a dense week of releases: prolific open-source maintainers (Sindre Sorhus, SWC, Hono, Ladybird) are turning off external pull requests because AI-generated "slop" PRs have made free code worthless and review expensive. Pi shipped 1.0 with built-in MCP and code mode, plus a separate Pi Durable harness for resumable, long-running agents, and Turso is joining Supabase. The rest is a whirlwind: SvelteKit 3, Effect 4.0, Alchemy infrastructure-as-code, Cloudflare's new config.ts and its own decision model, OpenAI DevDay announcements, NVIDIA's Lyra 2.0 world model, game decompilation/recompilation, a TC39 composites proposal, and a pigeon-delivered IP packet up for auction at Christie's.

Owain Lewis walks through an autonomous "AI SRE" agent he built with the Claude Agents SDK: production alerts flow into a queue, the agent investigates logs, metrics and deployment history, writes its findings to a database, and surfaces them in a custom web console where an operator can approve actions like a rollback. He demos it detecting a deliberately broken deploy (payment config error causing 500s), recommending and executing a rollback, then a second case of a slow-but-working deployment diagnosed via chat. His main caveat: these agents are superhuman at digging through data but routinely over-index on single signals and jump to conclusions, so critical actions should stay human-in-the-loop.

Iconographer Jonathan Pageau uses the Grail legend to argue that our culture celebrates technological discovery while skipping the question that actually matters: whom does the technology serve? He frames the AI race as a modern Moloch trap, where competitive fear (losing to China, losing market position) drives us to sacrifice jobs, energy, children's minds and our grip on reality. Since no system-level fix exists, he argues the only real answer is personal: cultivate memory, skill, virtue and faith inside yourself so you stay master of the machine rather than its vassal.

Matt Pocock interviews Poteto, creator of the pstack skill library and an engineer at Cursor (now SpaceX AI, previously Meta's React team), about how he shipped ~2,500 PRs to production in a month. His argument: the agent isn't the bottleneck anymore — your environment and your ability to transfer intent are. The practical core is verification (giving agents hands and eyes so they can close their own loop), heavily constrained codebases where bad code is hard to write, and connecting an "outer loop" of external context (Slack, X, email, Linear) to an "inner loop" of coordinator agents that spawn sub-agents. He now lets agents merge their own PRs overnight and reviews by sampling commit history in the morning.

Jo Van Eyck walks through a working "software factory" he built: GitHub issues feed a chief-of-staff agent that spawns a fleet of workers and reviewers, which plan, code, self-review, and open a PR with evidence attached. His main argument is that the factory tooling itself is the easy part — the real prerequisites are a codebase that can run in a container, a type system, a fast hexagonally-designed test suite, custom lint rules, and static analysis. He advocates a "dim factory" rather than a fully dark one: skip most PR reviews, but periodically sweep the code manually to check that core primitives haven't been corrupted.

Matt Pocock walks through version 1.3 of his skills repo, which adds three skills: /implement-spec, /pr, and /retro. implement-spec orchestrates a whole spec's tickets through sub-agents (a middle ground between manually babysitting each ticket and writing a deterministic script loop), /pr enforces a PR body template with a visual summary, before/after evidence, merge danger and blast radius, and /retro reads your actual past agent sessions and suggests repo and agent improvements. He also notes a breaking rename: domain modeling now writes to glossary.md instead of context.md, which many other skills depend on.

Nate Jones argues that as agents take over the "information processing" part of jobs, the software application interface stops being where value lives — and that breaks how companies buy and sell SaaS. He walks through how Meta (Muse), Salesforce (COA + agent control plane), Microsoft (Autopilot/Copilot), the labs, DoorDash (text ordering + MCP), Crust Data and Workday are each positioning across three layers: data, application/workflow, and agentic. His practical advice: individuals should stop hoarding their personal AI tricks and talk openly about how they work, because leadership will swap vendors without knowing what productivity they're destroying.

Laurie Voss argues that AI agents have made code generation cheap while human review has stayed the same speed, creating the real bottleneck: one study of 100,000+ GitHub developers found agent users wrote 741% more code but shipped only 30% more software. He walks through the evidence on whether automated review can replace humans — METR's maintainer study, Cognition's Frontier Code benchmark, GitHub/Cursor's production reviewers, and the Bun and OpenAI no-human experiments — and concludes review hasn't died, it's been relocated. His practical advice: stop reviewing individual PRs and spend your human judgment building the review harness, rubrics, and evals that review for you.

Microsoft is shipping Autopilot (earlier called Scout), an agent built on OpenClaw's open-source tech — the same agent Satya Nadella compared to a virus back in February — now packaged with an auditable identity, admin controls and a support contract. Nate Jones argues this matters less because the model is smart and more because of distribution and data: Microsoft has 450M+ paid M365 commercial seats and 30M+ paid Copilot seats, so for a lot of workers Autopilot will simply be the AI they're allowed to use. The bulk of the video is five habits for getting value out of any agent — define what good looks like, supply and verify context, make good assignments recur, match reasoning to difficulty, and close the learning loop.

The host reports that Claude Opus 5.5 running at "Ultra Code" effort level implemented a 2,700-line spec for his app "Enjoy" end to end in roughly seven hours, something that failed catastrophically when he tried similar work in March. He argues the model's self-spawned adversarial reviewers, heavy test coverage, and honest self-reporting mean agentic code is now trustworthy without line-by-line human review. He concludes that CI, not code review, is the real bottleneck, and warns engineers who insist on manual review that they may be hurting their careers.

Anthropic updated its skills best-practice guide, and the new rules largely contradict how people built skills earlier this year. The biggest one: Claude previews long reference files with `head -100`, so anything important below line 100 in a file without a contents list may never be read. The other changes cover matching instruction detail to how fragile a task is, testing skills on every model you'll run them with, keeping references one level deep, adding checklists and self-validation loops, and spelling out dependencies so skills work on someone else's machine.

Matt Pocock argues that AI agents have turned the PR review queue into a firehose, and the fix is three layered "brakes": cheap deterministic checks, an automated reviewer running in its own sub-agent, and a much lighter human review. His core unintuitive advice is to keep coding standards out of the implementer agent (which is already overloaded with exploring, editing, and debugging) and put them in a coding-standards.md file that only a review agent reads, and to have that reviewer commit fixes rather than leave comments for humans. He also introduces new skills: a PR skill that labels every PR as a one-way or two-way door with a blast radius, and a "retro" skill that mines past sessions and reviews to generate new checks and standards so each cycle compounds.

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.