October 2026

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.