John Lindquist demonstrates how to let visiting agents interact with a product through a limited front desk and typed tools, while keeping money and release decisions with people. The lesson covers safeguards, saved-record checks, repeatable tests, and deploying the service.
mega course, agent-to-agent commerce, agent permissions, agent evaluation, model context protocol, production deployment
videohq.mega.dev · 11/20/2026 · Queued for Ask
MEGA’s written, step-by-step companion to John Lindquist’s build for a self-improving engineering system. It demonstrates a safe front desk for visiting agents, hidden checks that run on changes, a bounded Trainer with human approval, and choosing the next agent to build from the team’s friction.
mega course, self-improving agents, agent permissions, agent evaluation, agent orchestration, agent skills
texthq.mega.dev · 11/20/2026 · Queued for Ask
MEGA’s lesson explores feedback, evaluation, distillation, optimization, and governance for self-improving autonomous systems. John Lindquist presents the build video, which is saved separately.
mega course, agent evaluation, agent reliability, durable execution, self-improving agents
texthq.mega.dev · 11/20/2026 · Queued for Ask

At CODE Summit 2026, Thariq Shihipar reflects on the Bitter Lesson and argues that AI can support both software industrialization and a creative renaissance. A live demo explores readable specifications and custom scripting languages as ways to preserve creative control when working with coding agents.
bitter lesson, coding agents, creative experiments, agent prompting
videowww.youtube.com · 11/19/2026 · Ready for Ask
John Lindquist presents ideas about building workspaces around agents, then answers questions with host Wojtek. They discuss agent coordination, custom models and evaluation workflows.
mega course, agent orchestration, agent evaluation, generative ui, multi-agent systems
videohq.mega.dev · 11/19/2026 · Ready for Ask

Ben Holmes explains how software engineering is shifting from writing code and prompts to designing systems of agents. He outlines software factory workflows, human review gates, and metrics for improving agent quality, cost, and performance.
software factories, agent evaluation, agent orchestration, agent reliability
textx.com · 11/19/2026 · Ready for Ask

PostHog’s Jina Yoon explains when to use decision models, how to set thresholds, and when to leave a task to an LLM. The article covers production examples including PII screening, model routing, search reranking, and chart selection.
decision models, probability calibration, model routing, llm inference
textx.com · 11/19/2026 · Ready for Ask

YK Sugi, a senior developer relations engineer at Google Cloud, explains five research-backed patterns for coordinating coding agents: separate builders and verifiers, divide work into independent lanes, generate and test multiple candidates, convene a council of models, and use reviewers with distinct roles. The article discusses when each pattern helps and when a single agent may work better.
agent orchestration, multi-agent systems, agent evaluation, agent reliability
textx.com · 11/19/2026 · Ready for Ask
MEGA’s step-by-step build guide, presented by John Lindquist, shows how to use background jobs to sort support tickets, draft replies, and read error reports. It covers event-driven watchers, human review, and durable execution.
mega course, durable execution, agent orchestration, automated ticket triage
texthq.mega.dev · 11/19/2026 · Ready for Ask
MEGA’s written, step-by-step guide to the build presented by John Lindquist in a lesson on orchestrating autonomous agent teams. It shows how to create read-only Domain Agents with owned code paths and cited memories, coordinate agents across domains, and define contracts between agents.
mega course, domain-specific agents, agent memory, agent orchestration, agent permissions
texthq.mega.dev · 11/19/2026 · Ready for Ask
MEGA’s written guide, presented by John Lindquist, builds workspace widgets for task status and suggested memories, an issues widget, and an issue-to-work flow that gathers context before sending work to an agent.
mega course, agent orchestration, agent memory, context engineering, agent observability
texthq.mega.dev · 11/19/2026 · Ready for Ask
MEGA’s step-by-step build guide, presented by John Lindquist, shows how to create a focused agent workspace with conversation splitting, a testing lab, and supporting agents. It uses Herdr and Pi as examples and covers the five pillars of agentic tooling.
mega course, coding agents, agent orchestration, agent evaluation, agent skills
texthq.mega.dev · 11/19/2026 · Ready for Ask
John Lindquist shows how to build agents that respond to events while a team is away, including a support-ticket sorter, customer-reply drafts, and a multi-step error hunter. The lesson covers durable execution, evaluating ticket classifiers with labeled examples and repeated trials, and routing uncertain results to a person.
mega course, agent orchestration, agent evaluation, agent reliability, durable execution
videohq.mega.dev · 11/19/2026 · Ready for Ask
MEGA’s lesson on using events, hooks, pipelines, and push systems to automate business processes with AI agents. Presented by John Lindquist, it covers examples such as pricing, payments, support, and sales while keeping consequential decisions with the team.
mega course, proactive agents, agent orchestration
texthq.mega.dev · 11/19/2026 · Ready for Ask

code mode, claude code
videoyoutu.be · 11/19/2026 · Ready for Ask
Kent C. Dodds answers audience questions hosted by Wojtek, discussing architectural decision records, coding-agent context, software teams, and software factories.
mega course, context engineering, software factories, engineering teams, spec-driven development
videohq.mega.dev · 11/19/2026 · Ready for Ask
Angie Jones answers audience questions about building reliable agentic systems and introducing AI tools across engineering teams.
mega course, agent orchestration, agent evaluation, engineering teams, agent infrastructure
videohq.mega.dev · 11/19/2026 · Ready for Ask
Theo Browne answers audience questions about working with coding agents, finishing projects, and sharing agent rules and skills across teams. A MEGA.dev host moderates the session.
mega course, coding agents, agent skills, software maintainability, claude code
videohq.mega.dev · 11/19/2026 · Ready for Ask
Greg hosts the MEGA.dev kickoff, with Kent C. Dodds, John Lindquist, Theo Browne and Angie Jones presenting their weeks and answering questions. Kent demonstrates setting up an agent-driven autopilot workflow for his Media RSS project, covering verification, autonomy and product decisions.
mega course, coding agents, agent permissions, agent-generated pull requests, production deployment
videohq.mega.dev · 11/19/2026 · Ready for Ask
John Lindquist explains how to create read-only domain agents that preserve lessons from a codebase and advise a main coding agent when it enters their domain. Using booking and pricing in a rental project, he covers harvesting cited memories, automatic triggers, glossaries, scenario checks, and agent contracts.
mega course, domain-specific agents, agent memory, agent orchestration, agent skills
videohq.mega.dev · 11/19/2026 · Ready for Ask
MEGA’s written lesson, presented in its video by John Lindquist, explores how to organize, coordinate, route, and supervise autonomous agent teams. It discusses dynamic worker roles and spawning agents with task-specific tools, instructions, and environments.
mega course, agent orchestration, multi-agent systems, agent infrastructure
texthq.mega.dev · 11/19/2026 · Ready for Ask
John Lindquist explains how to build widgets that surface agent tasks and suggested memories, and triage issues from external services. He covers testing widget outputs in a lab, reducing overstatements, and choosing models based on quality, speed, and cost.
mega course, agent memory, agent observability, agent evaluation
videohq.mega.dev · 11/19/2026 · Ready for Ask
MEGA explains how to organize portable agent control planes across configurations, projects, services, and harnesses. The lesson connects these principles to a build by John Lindquist.
mega course, agent infrastructure, agent orchestration, agent permissions, company harness
texthq.mega.dev · 11/19/2026 · Ready for Ask
John Lindquist explains how to build a software factory by centering work on one focused conversation and surrounding it with supporting agents. He introduces five principles for agentic tooling and demonstrates branching conversations with Herdr and Pi.
mega course, software factories, agent orchestration, agent infrastructure, agent evaluation
videohq.mega.dev · 11/19/2026 · Ready for Ask
MEGA’s written lesson explores autonomy, runtime, state, control, observation, and recovery in autonomous systems. It uses Specter, a background research and knowledge-base agent, to illustrate the design principles; John Lindquist presents the lesson video.
mega course, agent infrastructure, always-on agents, agent memory, agent permissions
texthq.mega.dev · 11/19/2026 · Ready for Ask
Kent C. Dodds explains how agents can surface friction, fix recurring problems, and clean up obsolete code so a software product keeps improving after release. He describes friction logs, automated sweeps, and a weekly legacy reaper, and credits Joyce with the friction-log idea.
mega course, software factories, coding agents, agent-generated pull requests, software maintainability
videohq.mega.dev · 11/19/2026 · Ready for Ask
A MEGA lesson on using product signals and agent-driven feedback loops to improve features after release. The separately saved lesson video is presented by Kent C. Dodds.
mega course, product design, proactive agents, agent orchestration, agent-generated pull requests
texthq.mega.dev · 11/19/2026 · Ready for Ask
Kent C. Dodds explains how feature flags, deployment checks, and tested backups can limit the impact of mistakes made by coding agents. He covers rollout metrics, agent reports, and disaster recovery drills using examples from Kodi.
mega course, production deployment, agent permissions, feature flags, disaster recovery
videohq.mega.dev · 11/19/2026 · Ready for Ask
MEGA’s lesson explains how to verify agent-built product changes by matching acceptance criteria and captured evidence to the change’s risk. It covers agentic testing labs, system diffs, reviews, quality gates, and routines for improving verification tools.
mega course, agent evaluation, acceptance testing, agent observability, agent infrastructure
texthq.mega.dev · 11/19/2026 · Ready for Ask
Kent C. Dodds explains how AI agents can verify pull requests using screenshots, preview environments, system recaps, and multiple AI reviewers. He describes this as the second pillar in a workflow for agent-driven development, alongside reducing the blast radius of mistakes.
mega course, automated code review, pull requests, production deployment, agent reliability
videohq.mega.dev · 11/19/2026 · Ready for Ask
MEGA’s lesson on using agents to explore, plan, execute and gather feedback while developing AI-native products. It covers Feature Maps, background agents and workflows that maintain and improve a product’s context over time.
mega course, context engineering, agent orchestration, agent memory
texthq.mega.dev · 11/19/2026 · Ready for Ask
Kent C. Dodds explains how concise repository guidance, architectural decision records, principles, and documented code primitives help agents make better implementation choices without a massive specification.
mega course, context engineering, agent prompting, coding agents
videohq.mega.dev · 11/19/2026 · Ready for Ask
MEGA’s written lesson explains how to guide agents with intent, principles, product context, clear work agreements, and evaluation criteria. It discusses approaches from Kent C. Dodds, Matt Pocock, Lauren Tan, and Joel Hooks.
mega course, context engineering, agent prompting, evaluation design
texthq.mega.dev · 11/19/2026 · Ready for Ask
Kent C. Dodds explains how product engineers choose what to build, measure user outcomes rather than output, and use agents to free up attention. He illustrates the ideas with Gmail, Instagram, WhatsApp, and the web platform.
mega course, product engineering, coding agents, product design, ai developer productivity
videohq.mega.dev · 11/19/2026 · Ready for Ask
A written lesson by MEGA about how product engineering changes as AI automates more of software development. It focuses on shifting from output to outcomes through ownership, judgment, systems thinking, and leverage.
mega course, product engineering, ai developer productivity, agent orchestration
texthq.mega.dev · 11/19/2026 · Ready for Ask
Angie Jones demonstrates how to evaluate a retail agent, trace a failed run, and improve its behavior. She also shows input and output guardrails for blocking payment-card numbers and replacing private staff contact details.
mega course, agent reliability, agent evaluation, agent observability, agent permissions
videohq.mega.dev · 11/19/2026 · Ready for Ask
MEGA’s written lesson explains how guardrails, evaluations, and observability help manage the risks and variability of LLM agents. It covers deterministic checks, tracing context and tool use, and balancing agent flexibility with code-level control.
mega course, agent reliability, agent observability, evaluation design, agent permissions
texthq.mega.dev · 11/19/2026 · Ready for Ask
Angie Jones demonstrates how retail agents can discover and delegate work to external agents using AI Catalogs and A2A, and how to use subagents to assess product fit. The lesson compares agent delegation with MCP tools and discusses validating external results in application code.
mega course, multi-agent systems, agent orchestration, model context protocol, agent-to-agent commerce
videohq.mega.dev · 11/19/2026 · Ready for Ask
MEGA’s written lesson explains multi-agent architectures, Agent2Agent communication, delegation, and orchestration, including discovery, handoffs, shared resources, and coordination. It discusses how to manage permissions, reliability, errors, cost, and parallel work across agents.
mega course, multi-agent systems, agent orchestration, agent permissions, agent reliability
texthq.mega.dev · 11/19/2026 · Ready for Ask
Angie Jones demonstrates how an agent can use MCP tools and resources, read local files, and use code mode to coordinate tool calls and process results. The lesson uses a retail agent example to explain tool discovery, access boundaries, and retrieving context when needed.
mega course, model context protocol, code mode, context engineering, agent infrastructure
videohq.mega.dev · 11/19/2026 · Ready for Ask
MEGA’s lesson on personalizing agent harnesses with instructions, MCP servers, skills and tools. It covers balancing guidance with agent autonomy and regularly improving or removing harness rules.
mega course, context engineering, model context protocol, agent skills
texthq.mega.dev · 11/19/2026 · Ready for Ask
Angie Jones demonstrates how to build an exchange service agent with policy checks enforced in code, inventory tools, and JEFF decision models. She covers validating model responses, routing uncertain or defective cases, and evaluating decision thresholds.
mega course, decision models, agent evaluation, agent permissions, tool calling
videohq.mega.dev · 11/19/2026 · Ready for Ask
MEGA’s written lesson covers agent architecture, model and tool choices, context and memory, and workflows and controls. It describes shaping a durable, self-evolving agent’s environment with reusable primitives such as events, skills, documents, journals, channels, and schedules.
mega course, agent infrastructure, agent memory, proactive agents, agent skills
texthq.mega.dev · 11/19/2026 · Ready for Ask
Angie Jones explains how instructions, tools, memory, and model choices shape a customer service agent, then demonstrates tracing its agent loop in Mastra Studio. The lesson also covers limiting model steps and diagnosing mismatches between an agent’s instructions and capabilities.
mega course, agent infrastructure, agent memory, tracing, tool calling
videohq.mega.dev · 11/19/2026 · Ready for Ask
MEGA explains the mechanics and responsibilities of agent harnesses, covering agent loops, instructions, context and memory, tools, persistence, permissions, and configuration. The lesson video is presented by Angie Jones and saved separately.
mega course, agent orchestration, agent infrastructure, context engineering, agent permissions
texthq.mega.dev · 11/19/2026 · Ready for Ask
Theo Browne explains how he builds and revises agent workflows using prompts and skills, including Soul Loop for cross-model code review. He also demonstrates scheduled, multi-model triage of T3 Code pull requests and discusses making merges safer with verification and rollback practices.
mega course, agent skills, coding agents, pull requests, agent prompting
videohq.mega.dev · 11/19/2026 · Ready for Ask
MEGA’s written lesson explores using agents and reusable workflows to keep up with growing software complexity. It covers reliability, evaluation, remote and background agents, security, and business processes.
mega course, agent skills, agent reliability, agent evaluation, agent orchestration
texthq.mega.dev · 11/19/2026 · Ready for Ask
Theo Browne explains how to separate the interface and workflow from an AI coding harness so switching models or harnesses causes less disruption. He demonstrates organizing skills and configuration across tools and machines with his Fleet repository.
mega course, company harness, coding agents, agent skills, claude code
videohq.mega.dev · 11/19/2026 · Ready for Ask
MEGA's lesson on choosing and configuring AI coding-agent harnesses, including multiprovider setups, self-managing agents, and workflows for teams.
mega course, coding agents, agent infrastructure, agent orchestration, company harness
texthq.mega.dev · 11/19/2026 · Ready for Ask
Theo Browne explains how to help coding agents navigate a codebase by asking questions about where they struggle, then improving the skills and guidance that shape their behavior. Examples cover T3 Code, agent skills, tool selection, and preventing scope creep.
mega course, context engineering, agent skills, coding agents
videohq.mega.dev · 11/19/2026 · Ready for Ask
MEGA’s lesson explores knowledge bases designed for agents, including their formats, retrieval, context, and maintenance. It discusses ideas from Andrej Karpathy’s personal knowledge base and using components, artifacts, and skills to guide agent-generated content.
mega course, llm knowledge bases, context engineering, agent memory, agent skills
texthq.mega.dev · 11/19/2026 · Ready for Ask
Theo Browne explains how harnesses provide models with context, including system prompts, tools, skills, and project instructions. He demonstrates using a handoff file to carry work between sessions and discusses what belongs in shared agent guidance.
mega course, context engineering, agent prompting, coding agents
videohq.mega.dev · 11/19/2026 · Ready for Ask
MEGA’s written lesson on shaping agent behavior and reducing cognitive load through context, harness settings, memory, skills, tools, and subagents. The lesson video is presented by Theo Browne and saved separately.
mega course, context engineering, agent skills, agent orchestration, agent memory
texthq.mega.dev · 11/19/2026 · Ready for Ask
Theo Browne explains how language models generate text one token at a time, and how system messages and tools steer their behavior. The lesson demonstrates token probabilities, ChatML, and a model using Bash to inspect a project.
mega course, tokenization, llm inference, agent prompting, tool calling
videohq.mega.dev · 11/19/2026 · Ready for Ask
MEGA’s written lesson introduces how generative AI works, including tokenization, next-token prediction, non-determinism, confabulation, and reasoning. It also surveys model interactions and ways to steer outputs.
mega course, tokenization, llm reasoning, llm hallucinations, uncertainty calibration
texthq.mega.dev · 11/19/2026 · Ready for Ask

Anthropic reports on Project Deal, a weeklong marketplace where Claude agents bought, sold, and negotiated real goods on behalf of 69 employees. The experiment found that Opus agents generally achieved better outcomes than Haiku agents, though participants did not notice their disadvantage.
agent-to-agent commerce, agent negotiation, claude
textwww.anthropic.com · 11/19/2026 · Ready for Ask

Josh Clemm describes how Figma trained a model to make precise edits to existing designs, combining supervised fine-tuning with reinforcement learning. The post covers its design-editing evaluations and how the model works alongside third-party models in the Figma agent.
design agents, ai-assisted design, agent evaluation, training objectives
textwww.figma.com · 11/19/2026 · Ready for Ask

Shopify describes post-training open models as task-specific agents for Sidekick, using a continual-learning loop to improve quality and reduce serving cost. The article focuses on its GraphQL subagent and NVIDIA hardware and software.
domain-specific agents, continual learning, llm inference, agent evaluation
textshopify.engineering · 11/19/2026 · Ready for Ask

Jediah Katz describes how Cursor optimized its agent harness, reducing token costs by 7% without lowering agent quality. The changes include trimming prompts, loading tools on demand, improving prompt-cache reuse, compressing file reads, and refining subagent use.
cursor, agent infrastructure, context engineering, prompt caching, agent memory
textcursor.com · 11/19/2026 · Ready for Ask

Thariq Shihipar explains how Claude Code’s agent harness uses prompt caching to reduce cost and latency, and shares design patterns for stable prompts, tools, models, and compaction.
prompt caching, claude code, agent infrastructure
textclaude.dev · 11/19/2026 · Ready for Ask

Cloudflare engineers explain how they optimize large language model inference on Workers AI, including Kimi K2.5. They cover hardware configuration, prefill-decode disaggregation, prompt and KV-cache management, speculative decoding, and Cloudflare’s Infire inference engine.
llm inference, cloudflare, gpu kernels, speculative decoding, prompt caching
textblog.cloudflare.com · 11/19/2026 · Ready for Ask
Andrej Karpathy guides readers through microgpt, a dependency-free Python script that implements and trains a GPT, from character tokenization and autograd to inference.
microgpt, autograd, llm inference, tokenization
textkarpathy.github.io · 11/19/2026 · Ready for Ask

Shopify describes Helix, a tool for using LLMs to migrate its React Native app to native Swift and Kotlin. It uses small checkpoints, tests, visual comparisons, adversarial code reviews, and engineer feedback to validate each step.
coding agents, automated code review, mobile app testing, agent memory
textshopify.engineering · 11/19/2026 · Ready for Ask

Gergely Orosz examines why Ramp built Inspect, its remote coding-agent platform, and how engineers use it for coding, debugging, verification, and internal agents. He speaks with CTO Rahul Sengottuvelu, Head of Engineering Hamid Dadkhah, and Inspect founding engineer Zach Bruggeman.
coding agents, cloud sandboxes, agent infrastructure, automated code review
textnewsletter.pragmaticengineer.com · 11/19/2026 · Ready for Ask

Tom Weightman reports on Figma’s evaluation of how Code Connect affects coding agents using Figma’s MCP server, finding improvements in code quality, token usage, and task duration.
model context protocol, design agents, ai-assisted design
textwww.figma.com · 11/19/2026 · Ready for Ask

Expo explains how to build a lightweight mobile QA agent using EAS Workflows and agent-device. It automates UI verification for iOS and Android pull requests without a large test framework.
agent evaluation, mobile app testing, ui testing, eas workflows
textexpo.dev · 11/19/2026 · Ready for Ask
Simon Willison explains how coding agents can manually test code beyond automated tests, using command-line experiments, browser automation, and documented demonstrations. He covers Playwright, Vercel’s agent-browser, Rodney, and Showboat.
coding agents, agent evaluation, cli design, agent-generated pull requests
textsimonwillison.net · 11/19/2026 · Ready for Ask

Jude Gao reports that an 8KB documentation index in AGENTS.md achieved a 100% pass rate on Next.js 16 API evals, while skills reached 79% even with explicit instructions. The article compares the approaches and explains how to set up version-matched documentation for coding agents.
next.js, agent skills, agent evaluation, context engineering
textvercel.com · 11/19/2026 · Ready for Ask

Pranay Prakash introduces durable-harness, a set of adapters that lets Pi, OpenCode, Claude Code, and Codex resume agent sessions after crashes or timeouts on Vercel, Postgres, or a local machine. The article explains its durable logs, tool replay policies, workspace options, and session documents.
agent infrastructure, production deployment, coding agents, agent memory
textvercel.com · 11/19/2026 · Ready for Ask

David Dunne, Xenofon Vourliotis, and Sai Samant describe Stripe’s agentic workflow for building and migrating payment method integrations. It combines reusable prompts, agent observation and prompt maintenance, human-guided orchestration, and automated integration testing.
software factories, coding agents, agent skills, agent evaluation, expect tests
textstripe.dev · 11/19/2026 · Ready for Ask

Uber explains how it measures and controls the costs of AI coding and managed agents as usage grows. The post covers model selection, prompt caching, reducing tool-related context, and other optimization levers.
software factories, model routing, agent infrastructure, context engineering
textwww.uber.com · 11/19/2026 · Ready for Ask
agent evaluation, evaluation design
textcareersatdoordash.com · 11/19/2026 · Ready for Ask

Cloudflare explains how its Code Mode MCP server exposes the Cloudflare API through two tools, reducing context use while letting agents discover and execute API operations in a sandbox. The post also introduces an open-source Code Mode SDK for the Cloudflare Agents SDK.
code mode, model context protocol, tokenization, cloudflare
textblog.cloudflare.com · 11/19/2026 · Ready for Ask

Plawan Rath, Akhil Jindal, and Ashwini Verma describe Meta’s thin-orchestrator architecture for data pipeline agents: a deterministic router delegates domain work to specialized agents with isolated context. They explain how workflow templates, runtime-loaded knowledge, and reliability checks support production workflows.
agent infrastructure, context engineering, agent evaluation
textengineering.fb.com · 11/19/2026 · Ready for Ask

Linear’s product and engineering team explains how they designed Linear Agent to handle complex tasks while limiting unpredictable behavior. They cover its system prompt, constrained tools, product-specific skills, run scope, approval checks, and custom execution harness.
agent infrastructure, agent skills, agent permissions, company harness
textlinear.app · 11/19/2026 · Ready for Ask

Andrew Qu describes how Vercel rebuilt d0, its Slack-based text-to-SQL agent, around Claude browsing the semantic layer’s files and using shell commands. In tests, the simpler file-system agent was faster, used fewer tokens, and succeeded on all five queries.
agent infrastructure, agent prompting, context engineering
textvercel.com · 11/19/2026 · Ready for Ask

Wilson Lin describes Cursor’s experiments coordinating hundreds of coding agents on large projects, including a browser built from scratch and a Solid-to-React migration. The post compares coordination designs and discusses how role separation, model choice, and prompting affect long-running work.
coding agents, agent infrastructure, always-on agents, agent prompting
textcursor.com · 11/19/2026 · Ready for Ask

Anthropic explains how to design and use evaluations for AI agents, including coding, conversational, research, and computer-use agents. The guidance covers evaluation structure, graders, capability and regression tests, and examples from Claude Code, Descript, and Bolt AI.
agent evaluation, evaluation design
textwww.anthropic.com · 11/19/2026 · Ready for Ask
OpenAI explains how the Codex agent loop works, including how the model interacts with tools over repeated turns.
coding agents, agent infrastructure
textopenai.com · 11/19/2026 · Ready for Ask

Uber’s Authoring and Enablement team describes the gateway architecture for discovering, governing, and routing MCP tools across the company. The article covers its registry and proxy layers, automated discovery, security controls, and ways to reduce context bloat when agents use hundreds of servers.
model context protocol, agent infrastructure, agent permissions
textwww.uber.com · 11/19/2026 · Ready for Ask

Uber describes a defense-in-depth framework for governing AI agent behavior across provisioning, runtime enforcement, and continuous assurance. It covers behavioral policies, tool and MCP validation, and production tradeoffs such as latency, cost, and false positives.
agent permissions, agent infrastructure, production access, model routing
textwww.uber.com · 11/19/2026 · Ready for Ask

Uber describes how it measures and controls the cost of AI coding agents as usage grows, breaking spend into measurable factors and optimizing model choice, token use, caching, and tool access. The post covers managed agents and interactive sessions across Uber’s software factory.
software factories, model routing, agent infrastructure, context engineering
textwww.uber.com · 11/19/2026 · Ready for Ask

agent evaluation, coding agents
videoyoutu.be · 11/17/2026 · Ready for Ask
Diane Sarkis explains when enterprise teams should replace subagents with a single agent loop using skills and tools, and how to evaluate and migrate the architecture.
agent infrastructure, agent evaluation, agent skills
textclaude.com · 11/17/2026 · Ready for Ask

Uber Engineering describes how its managed agents support software development and how the company measures and reduces agent costs. The article covers benchmark-driven model selection, prompt caching, MCP tool access, and code-mode workflows.
software factories, model routing, model context protocol, agent infrastructure
textx.com · 11/17/2026 · Ready for Ask

Tim Qi, Lukas Eipert, Maciek Pękala, and Dima Zaytsev describe how Linear shifted to agent-first code review, with human review reserved for changes where it matters most. They also discuss fast feedback, reversible changes, using working code to explore options, and asking agents to provide evidence that changes work.
automated code review, agent-generated pull requests, engineering teams, production deployment
textlinear.app · 11/17/2026 · Ready for Ask

Justin Schroeder of Standard Agents discusses why domain-specific agents are the future. The video was published by the Agentic AI Foundation.
coding agents, agent infrastructure, domain-specific agents
videoyoutu.be · 11/17/2026 · Ready for Ask

Addy Osmani describes how the Claude Code team uses end-to-end, property-based, and differential tests, along with review gates and evaluations, to help coding agents verify changes reliably.
agent evaluation, agent skills, code review, property-based testing
textclaude.dev · 11/17/2026 · Ready for Ask

Lauren Tan explains how the Grok Bot team at SpaceXSI uses architecture, lint rules, testing, and runtime and formal verification to scale AI coding agents while maintaining code quality.
coding agents, software factories, automated code review, software maintainability
videowww.youtube.com · 11/16/2026 · Ready for Ask
William Hu explains the architecture behind always-on agents, which wake for events, work across sessions, and act without constant supervision. The guide covers event inboxes, timers, memory, permissions, and outboxes.
always-on agents, proactive agents, agent memory, agent permissions
textclaude.com · 11/14/2026 · Ready for Ask

ForrestKnight discusses GitHub’s AI-assisted migration of the Copilot runtime from TypeScript to Rust, revisiting the claim that Rust’s compiler is the main reason agents work well with the language. The video covers the rewrite’s incremental workflow, compiler feedback, production rollout, and performance results.
rust, coding agents, agent-generated pull requests, production deployment
videowww.youtube.com · 11/13/2026 · Ready for Ask

ForrestKnight investigates why AI coding tools produce sharply different productivity gains across developers and teams. Drawing on examples and reports from Amazon, Anthropic, and others, the video argues that expertise, task preparation, and engineering workflows matter alongside the tools themselves.
coding agents, ai developer productivity, engineering teams
videowww.youtube.com · 11/13/2026 · Ready for Ask

Boris Tane explains how agents can call tools through code, keeping intermediate results out of the model’s context. He covers isolated execution, tool discovery, and how code mode relates to MCP.
agent infrastructure, context engineering, model context protocol, code mode
textpolylane.com · 11/10/2026 · Ready for Ask

Vi Tran and Boris Tane explain why Polylane adds narrated video walkthroughs to agent-generated pull requests, helping reviewers understand the cause, the change, and its validation. They describe building the videos with an agent, Gemini text-to-speech, speech recognition, and Manim, and report higher merge rates for pull requests with walkthroughs.
automated code review, proactive agents, agent-generated pull requests, manim
textpolylane.com · 11/10/2026 · Ready for Ask

Boris Tane explains how Polylane builds and updates a context graph of an application’s infrastructure, repositories, telemetry, and resource relationships. The graph gives agents context to investigate production, assess resource health, find relevant code, and support detection and autofixes.
context engineering, agent infrastructure, production deployment, agent memory
textpolylane.com · 11/10/2026 · Ready for Ask

Vi Tran and Boris Tane explain how Polylane replaced LLM calls with TypeSafe AI’s Jev decision model for agent routing, incident and pull-request classification, and cloud-resource ranking. They report Jev was faster across the evaluated tasks and reduced overall P90 latency by 89.3% and cost per 1,000 calls by 39.1%.
decision models, always-on agents, agent infrastructure, production deployment
textpolylane.com · 11/10/2026 · Ready for Ask

Vi Tran and Boris Tane explain Polylane’s pull-request check for assessing whether code changes could harm production. It uses a cloud-resource context graph, production telemetry, and forecasts to identify failure risks and return a go/no-go verdict.
production deployment, automated code review, agent infrastructure
textpolylane.com · 11/10/2026 · Ready for Ask

Aleksandr Diamond and Boris Tane explain why Polylane replaced its multi-agent workflow for investigating production issues and opening pull requests with a single agent. They report improvements in turnaround time, pull-request rate, and cost, while noting that architecture was not the only factor in the results.
coding agents, agent infrastructure, pull requests, agent evaluation
textpolylane.com · 11/10/2026 · Ready for Ask

Boris Tane explains how Polylane uses a shared Git repository of Markdown files to carry findings, team preferences, and recent events between agent runs. A nightly “dreaming” process checks memories against current evidence, learns from pull-request outcomes, and reorganizes the repository.
agent memory, proactive agents, git, context engineering
textpolylane.com · 11/10/2026 · Ready for Ask

Jina Yoon of PostHog explains when to use decision models, how to set thresholds, and when to leave a task to an LLM. Examples include filtering personal information, routing models, reranking search results, and choosing charts.
decision models, probability calibration, model routing, llm inference
textx.com · 11/10/2026 · Ready for Ask

Divya Santhanam explains how to improve AI agents by defining desired behavior, writing evaluations before building, and comparing experiments to catch regressions and overfitting.
agent evaluation, evaluation design, overfitting, tracing
textwww.langchain.com · 11/10/2026 · Ready for Ask

Mastra’s Alex Booker leads a hands-on workshop building and deploying a TypeScript AI teammate, then connecting it to Slack and Notion. The workshop covers observational memory, tracing agent runs, and using evaluation datasets to compare models.
agent infrastructure, production deployment, tracing, agent evaluation, agent memory
videowww.youtube.com · 11/9/2026 · Ready for Ask

Alex Booker and Yujohn Nattrass demonstrate how to use Mastra traces, datasets, scorers, and experiments to investigate agent failures and compare changes. They cover error analysis, judge calibration, multi-turn evaluation, and catching regressions in CI.
tracing, agent evaluation, evaluation design
videowww.youtube.com · 11/9/2026 · Ready for Ask

OpenCode’s Browse lets OpenCode and other MCP clients control tabs in your real browser, using your existing logins and extensions. It supports screenshots, screen recordings, HAR capture, site allowlists, and handoffs for steps such as login and 2FA.
computer-use agents, model context protocol, agent permissions
softwareopencode.ai · 11/7/2026 · Ready for Ask
Vercel Labs’ framework generates dynamic UIs from natural-language prompts, constrained to predefined components and actions for predictable output. It supports rendering across web and mobile frameworks, as well as formats including video, PDF, email, and terminal interfaces.
generative ui, design agents, cross-platform rendering
softwaregithub.com · 11/7/2026 · Ready for Ask

Anthropic researchers explain how Claude uses persistent memory notes and “dreaming” to learn from experience, judge what is worth remembering, and correct errors. They evaluate these ideas on CL-Bench and Pokémon Red.
agent memory, context engineering, agent evaluation, continual learning
textwww.anthropic.com · 11/6/2026 · Ready for Ask

Vercel’s manual for designing command-line capabilities, commands, interaction, output, recovery, and compatibility for people and agents.
cli design, command-line interfaces, agent permissions
textvercel.com · 11/6/2026 · Ready for Ask

Ben Holmes explains how agent workflows can shorten human code reviews with adversarial review loops, end-to-end verification in simulated environments, and merge-risk scoring. He argues these steps improve trust and focus without removing human oversight.
code review, agent evaluation, computer-use agents
textx.com · 11/5/2026 · Ready for Ask

Gumloop describes its Factory, a system that uses agents to find product and infrastructure problems, investigate them, and prepare evidence-backed pull requests for engineers to review. It explains how the system is organized into work lines, how engineers guide judgment calls, and why Gumloop can coordinate multiple coding agents.
software factories, agent infrastructure, pull requests, production deployment
textwww.gumloop.com · 11/5/2026 · Ready for Ask

Anthropic’s cookbook shows how to use Claude Managed Agents to distill finished session transcripts into a linked wiki-style memory store that future sessions can mount read-only. A lead agent runs transcript analyzers and an organizer, with options to update the store nightly.
llm knowledge bases, agent infrastructure, context engineering
textplatform.claude.com · 11/5/2026 · Ready for Ask

Miguel Ríos Berríos explains how his team grew Recall from a Claude Code and Codex session-search prompt into a shared, permission-aware system for retrieving and analyzing company knowledge. He describes its architecture, retrieval and evaluation improvements, and how the team uses it for handoffs, onboarding, and coding-agent analytics.
agent skills, llm knowledge bases, retrieval augmented generation, model context protocol, agent evaluation
textx.com · 11/4/2026 · Ready for Ask

Sydney Runkle explains how the Deep Agents team evaluated and optimized browser tools, choosing Stagehand and improving context use, speed, and cost. The post covers browser-agent benchmarks, trace analysis, and changes to page snapshots and wait behavior.
computer-use agents, agent evaluation, context engineering
textx.com · 11/4/2026 · Ready for Ask
Vercel Labs’ CLI and C library let AI agents inspect and operate desktop apps through the operating system accessibility tree, without screenshots or pixel matching. It supports macOS, Windows, and Linux, and can expose its commands as MCP tools.
computer-use agents, agent infrastructure, model context protocol, accessibility
softwaregithub.com · 11/4/2026 · Ready for Ask

Rico explains how to make a design system that guides Claude Code: document design tokens, semantic foundations, components, reusable blocks, rules, and task-specific skills. The goal is to help an agent build product screens consistently without guessing at design decisions.
design agents, agent skills, design systems, claude code
textx.com · 11/4/2026 · Ready for Ask

Rudraj Mehta of Mem0 explains how to configure memory extraction policies so an app stores useful user facts while refusing sensitive or irrelevant information. The article covers plain-language instructions, examples from a running coach app, and Mem0 setup options.
llm knowledge bases, personal knowledge management, structured information extraction, secrets management
textx.com · 11/4/2026 · Ready for Ask

Sergii Makarevych surveys 63 AI code-review products, comparing what they read, how they filter findings, what actions they can take, whether they learn, and how they bill. The article argues that AI reviewers cannot replace the broader purposes of human review, including maintainability, shared understanding, and agreement on what is being built.
automated code review, code review, pull requests, coding agents
textx.com · 11/4/2026 · Ready for Ask

Hamel Husain compares decision models for automated evaluations, showing how to tune classification thresholds, weigh cost against performance, and calibrate probability scores. The comparison uses 100 labeled traces from an apartment leasing agent.
agent evaluation, evaluation design, decision models, probability calibration
texthamel.dev · 11/3/2026 · Ready for Ask
Louis Claxton presents Anthropic’s Applied AI team’s playbook for integrating Claude across planning, design, building, testing, deployment, and maintenance. It describes replacing human-speed handoffs with an artifact-driven loop while keeping humans accountable for decisions that require judgment.
agent infrastructure, spec-driven development, production deployment, claude
textclaude.com · 11/2/2026 · Ready for Ask

Andrej Karpathy describes an LLM-maintained wiki that incrementally connects and synthesizes information from a curated collection of sources, rather than retrieving from raw documents anew for each question. The idea covers ingestion, querying, maintenance, and tools such as Obsidian and qmd.
llm knowledge bases, personal knowledge management, obsidian, retrieval augmented generation
textgist.github.com · 10/30/2026 · Ready for Ask

John Kim, a Meta senior staff engineer, shares a risk-based workflow for reviewing AI-generated code. He recommends matching review depth to a change’s blast radius, requiring evidence in pull requests, and using feature gates, experiments, canaries, and rollback to manage releases.
code review, coding agents, pull requests, production deployment
videoyoutu.be · 10/30/2026 · Ready for Ask

Theo explains how they use T3 Code, a project they still contribute to.
t3 code, coding agents
videoyoutu.be · 10/29/2026 · Ready for Ask

Sam McVeety and Amir Hormati explain how Open Knowledge Format v0.2 adds optional provenance, trust, freshness, lifecycle, and attestation fields for agent-generated knowledge. They show how these signals work in an example retail analytics bundle using BigQuery.
open knowledge format, source grounding, agent infrastructure
textcloud.google.com · 10/29/2026 · Ready for Ask

Sam McVeety and Amir Hormati introduce Open Knowledge Format (OKF), an open specification for portable, interoperable knowledge bundles that AI agents and people can use. They describe its Markdown and YAML structure, design principles, and reference tools.
llm knowledge bases, open knowledge format, agent infrastructure
textcloud.google.com · 10/29/2026 · Ready for Ask

Max Kanat-Alexander explains why code quality matters less for disposable software but more than ever for durable systems. He discusses making software easier to replace and lowering the cost of rigor through standards, in-workflow tools and easy testing.
code quality, disposable software, durable software, software maintainability
videoyoutube.com · 10/29/2026 · Ready for Ask

Uber’s Soumya Gupta and Jai Chopra discuss how they evaluated a food-photo enhancement agent, balancing fidelity to dishes and merchant brands with creativity and safety. They explain their offline and online feedback loop and approaches to reward hacking.
evaluation design, multimodal agents, reward hacking, food image editing
videoyoutube.com · 10/28/2026 · Ready for Ask

Lydia Hallie explains how the browser event loop, Web APIs, task queue, and microtask queue work together to run asynchronous JavaScript without blocking.
javascript event loop, web apis, microtask queue, asynchronous javascript
videoyoutube.com · 10/28/2026 · Ready for Ask
Matt Pocock's composable, model-agnostic agent skills for engineering work. They focus on aligning with agents, building shared project language, improving feedback loops, and maintaining codebase design.
agent skills, software fundamentals, context engineering
softwaregithub.com · 10/28/2026 · Ready for Ask
Poteto’s pstack is a set of agent skills and playbooks for producing less, higher-quality code with rigorous verification and parallel workflows. It supports Cursor and Claude Code and can route work across different models.
pstack, coding agents, agent skills, agent evaluation
softwaregithub.com · 10/28/2026 · Ready for Ask

Serhii explains how they built an AI code review system for 200 engineers, including its context retrieval, feedback loop, and autonomous PR approval workflow.
automated code review, context engineering, pull requests
videoyoutube.com · 10/28/2026 · Ready for Ask

Daksh Gupta, co-founder of Greptile, explains how to build a code review agent, from a basic sandbox-and-webhook setup to better prompts, historical PR data, model inversion, codebase context, autonomous testing, and model routing.
automated code review, pull requests, coding agents
videoyoutube.com · 10/28/2026 · Ready for Ask

Delta is a shared workspace for developers and coding agents, where teammates can review conversations and code changes together. DeltaDB keeps each thread connected to its edits across the Delta app, Claude Code, and different models or runtimes.
coding agents, agent infrastructure
softwaredelta.dev · 10/28/2026 · Ready for Ask

Mr. Buzzoni describes a $20 Claude Pro setup using Opus 5.5 as a librarian, based on two papers, and outlines four ways to monetize it.
personal knowledge management, obsidian, claude
textx.com · 10/28/2026 · Ready for Ask
Google’s Python library uses LLMs to extract structured information from unstructured text, grounding each extraction in its exact source location. It supports models including Gemini, OpenAI models, and local LLMs through Ollama, and can generate interactive visualizations of results.
structured information extraction, source grounding, llm knowledge bases
softwaregithub.com · 10/28/2026 · Ready for Ask
Uncle Bob’s agent skill applies disciplined engineering practices to code changes, from making changes work to verifying and improving them. It pairs TDD and behavior-focused testing with deterministic quality gates for complexity, duplication, and mutation testing.
agent skills, software fundamentals, expect tests, code review
softwaregithub.com · 10/28/2026 · Ready for Ask

T3 Code is an open-source control plane for orchestrating coding agents such as Claude Code, Codex, OpenCode, Cursor, and Grok. It connects to subscriptions and credentials users already have and supports branch-based work and GitHub pull requests.
coding agents, agent infrastructure, pull requests
softwaret3.codes · 10/28/2026 · Ready for Ask

Pi is a minimal, extensible terminal-based coding agent. It supports interactive, print/JSON, RPC, and SDK modes, and lets users customize workflows with extensions, skills, prompts, and themes.
coding agents, agent infrastructure, context engineering, agent skills
softwarepi.dev · 10/28/2026 · Ready for Ask

OpenCode helps you write and run code with AI models in a terminal, desktop app, or IDE extension. It supports multiple model providers and local models, and says it does not store code or context data.
coding agents, agent infrastructure
softwareopencode.ai · 10/28/2026 · Ready for Ask

fx is a minimal coding-agent harness and CLI written in Zig, designed for research and embedding in larger systems. It supports local and cloud inference, WebAssembly, and extensions through custom tools, skills, and MCP servers.
coding agents, agent infrastructure, model context protocol
softwarefx.sh · 10/28/2026 · Ready for Ask
UIGraph connects engineering artifacts into a shared view that engineers can browse and AI agents can query through MCP. It supports syncing context from a YAML file via CLI or CI/CD, and can be self-hosted.
context engineering, model context protocol, agent infrastructure
softwareuigraph.app · 10/28/2026 · Ready for Ask

ASCII offers persistent Ubuntu VMs for AI agents, with SSH, Docker, a virtual desktop, and fast snapshot-based forking. The CLI, API, and SDKs let users launch and manage sandboxes, which are billed per second while running.
agent infrastructure, coding agents, cloud sandboxes
softwareboat.dev · 10/28/2026 · Ready for Ask

Will Binns-Smith explains how the next-bundle-optimizer agent skill uses Turbopack’s module graph to find and fix bundle-size issues, and covers new tools in the Next.js Bundle Analyzer.
agent skills, next.js, bundle analysis, javascript bundles
textnextjs.org · 10/28/2026 · Ready for Ask

Eugene Liu of LangChain describes testing OpenWiki, a source-linked wiki compiler, as persistent memory for agents answering questions across insurance documents. The post reports that an evidence graph improved accuracy and citation consistency beyond the wiki alone.
llm knowledge bases, agent evaluation, evidence graphs, retrieval augmented generation
textwww.langchain.com · 10/28/2026 · Ready for Ask
LangChain’s open-source CLI creates and maintains Markdown wikis about codebases or personal knowledge, giving coding agents durable context. It supports code and personal wiki modes, plus search and links between wikis.
llm knowledge bases, coding agents, agent infrastructure, personal knowledge management
softwaredocs.langchain.com · 10/28/2026 · Ready for Ask

Anomaly shares experiments, experiences, and ambitious ideas.
creative experiments, experience design
textanoma.ly · 10/28/2026 · Ready for Ask

Tony Cueva explains why AI teams need an evaluation harness to catch regressions when they change models, tools, or prompts. This is part two of a guide to evals and tracing for engineers, QA, and PMs.
agent evaluation, evaluation design, tracing
textx.com · 10/28/2026 · Ready for Ask

Tony Cueva’s plain guide for engineers, QA specialists, and PMs on testing AI systems with evaluations and tracing. It includes real code and results.
agent evaluation, evaluation design, tracing
textx.com · 10/28/2026 · Ready for Ask
Andrej Karpathy describes using LLMs to build personal knowledge bases for topics of research interest, shifting some of his token use from manipulating code to working with research knowledge.
llm knowledge bases, personal knowledge management, research workflows
textx.com · 10/28/2026 · Ready for Ask

Harrison Chase describes LangChain’s internal agents for marketing, sales, and engineering, which changed how those teams work, and asks how to build a company harness.
agent infrastructure, company harness
textx.com · 10/28/2026 · Ready for Ask

Vojta Holik’s collection of practical CSS recommendations covers resets, logical properties, OKLCH colors, light and dark themes, and fluid sizing.
css reset, css logical properties, oklch color, fluid typography
textgood-css.com · 10/28/2026 · Ready for Ask

The Model Context Protocol is an open-source standard for connecting AI applications to external data sources, tools, and workflows. The page explains how MCP can help developers integrate AI applications and enable assistants such as Claude and ChatGPT to access information and perform tasks.
agent infrastructure, model context protocol
textmodelcontextprotocol.io · 10/28/2026 · Ready for Ask
Agent Skills is an open format, originally developed by Anthropic, for packaging specialized knowledge and workflows in portable folders. Compatible agents discover skills from their metadata, load full instructions when relevant, and can use bundled scripts and resources.
agent skills, context engineering, agent infrastructure
textagentskills.io · 10/28/2026 · Ready for Ask
videoyoutube.com · 10/28/2026 · Ready for Ask

leerob explains the product, infrastructure, and harness behind Grok Bot, an always-on and proactive agent.
always-on agents, agent infrastructure, grok
videoyoutube.com · 10/28/2026 · Ready for Ask

Infisical is a platform for managing identities, secrets, certificates, and access. It supports centralized secret management, sharing secrets across environments, and self-hosting.
secrets management, identity security, credential management, certificate management
softwareinfisical.com · 10/28/2026 · Ready for Ask

Emil’s course teaches designers and engineers to use AI to build polished interfaces, encode design taste into rules and skills, and review and test AI-generated work.
ai-assisted design, product design, design agents
textaiforui.dev · 10/27/2026 · Ready for Ask

Laurie Voss of Arize AI examines how autonomous coding agents are increasing code volume while human review limits how much software gets shipped. Voss discusses review benchmarks, automated review systems, prompt injection, and why production may remain the last checkpoint.
automated code review, agent evaluation, pull requests, agent permissions
videoyoutube.com · 10/27/2026 · Ready for Ask

Mikyo King of Arize AI explains how code-mode agents use a sandbox to find and compose tools, and discusses implementation tradeoffs and evaluation results.
coding agents, context engineering, agent permissions, agent evaluation
videoyoutube.com · 10/27/2026 · Ready for Ask

LangChain explains how it built Content Studio, an open-source Slack design agent that creates on-brand videos, graphics, and decks, and the harness behind it.
product design, ai-assisted design, design agents, slack
textx.com · 10/27/2026 · Ready for Ask

Matt Dailey shares more advice for engineers improving their design work with AI, continuing his discussion of designing individual surfaces. He says agents can introduce “slop” into designs and notes that teams are building complex features.
ai-assisted design, product design
textx.com · 10/27/2026 · Ready for Ask

Matt Dailey shares advice for engineers who want to improve their product design. They explain how they try to avoid generic, hard-to-understand designs.
product design, ai-assisted design
textx.com · 10/27/2026 · Ready for Ask
Franciska Dethlefsen explains how Delta lets teammates join a shared Claude Code session, see its conversation and unfinished code changes, and collaborate across machines. The beta uses the Delta CLI and Claude Code plugin, with support for Pi planned.
claude code, coding agents, context engineering, pull requests
textdelta.dev · 10/27/2026 · Ready for Ask

Daksh Gupta, co-founder of Greptile, explains how to build a code review agent, from a basic sandbox-and-webhook setup to targeted prompts, historical incident data, model inversion, codebase context, autonomous testing, and model routing.
automated code review, pull requests, coding agents, agent prompting
videoyoutube.com · 10/27/2026 · Ready for Ask
Xinyun Chen, Ryan A. Chi, Xuezhi Wang, and Denny Zhou study how premise order affects large language model reasoning. They report accuracy drops of over 30% when premises are permuted in deductive reasoning tasks, and introduce R-GSM to examine ordering effects in mathematical problem-solving.
llm reasoning, premise ordering, deductive reasoning, gsm8k
textarxiv.org · 10/26/2026 · Ready for Ask

Lance Martin walks through a reference implementation for a scheduled agent that gathers updates from Slack and GitHub and posts a daily brief. The article covers source bookmarks, memory, credentials, permissions, failure handling, and deployment with Claude Managed Agents.
coding agents, agent permissions, context engineering, claude code
textclaude.dev · 10/26/2026 · Ready for Ask
OpenAI explains why language models produce hallucinations and how training and evaluation can reward guessing instead of expressing uncertainty.
llm hallucinations, evaluation design, uncertainty calibration, training objectives
textopenai.com · 10/26/2026 · Ready for Ask
t3dotgg’s collection of agent skills for reviewing, filing, managing, and merging pull requests. Some skills use multiple models to review changes until they agree.
coding agents, claude code, pull requests, automated code review
softwaregithub.com · 10/26/2026 · Ready for Ask

Thinking Machines Lab explains why LLM inference can produce different results despite deterministic GPU kernels, and how to make inference reproducible. The post examines floating-point non-associativity, atomic operations, and GPU kernel implementations.
llm inference, floating-point arithmetic, gpu kernels, reproducibility
textthinkingmachines.ai · 10/26/2026 · Ready for Ask

Andrej Karpathy builds a GPT tokenizer from scratch, explaining Byte Pair Encoding, Unicode, and how tokenization can contribute to quirks in language models.
tokenization, byte pair encoding, tiktoken
videoyoutu.be · 10/26/2026 · Ready for Ask

TanStack presents its headless, type-safe tools for building web applications. The site lists Tanner Linsley among its core maintainers.
tanstack, typescript, framework-agnostic libraries, web application stack
softwaretanstack.com · 10/26/2026 · Ready for Ask

Ron Minsky of Jane Street discusses how the company uses AI agents across its software development lifecycle while keeping people effective and informed. He explains the continuing role of type systems, expect tests, code review, and formal verification.
coding agents, type systems, expect tests, code review, formal verification
videoyoutube.com · 10/26/2026 · Ready for Ask

Lance Martin explains how to design reliable evaluations and improve applications against them without overfitting. The article shows how Claude Code’s claude-api skill uses the build-eval and hillclimb commands to create, validate, and iteratively improve evaluations.
agent evaluation, claude code, evaluation design, overfitting
textclaude.dev · 10/26/2026 · Ready for Ask

Thariq shares what the Claude Code team learned about writing system prompts, skills, and CLAUDE.md files after removing about 80% of the system prompt for its newest models.
context engineering, claude code, agent prompting
textx.com · 10/26/2026 · Ready for Ask
Lauren explains how they shipped 2,500 PRs to production in a month. The talk was originally planned for Cursor Compile in London.
pull requests, production deployment
videox.com · 10/26/2026 · Ready for Ask

Tom Dale explains how Vercel Agent investigates production issues, proposes plans that connect tasks to scoped permissions, and requests approval before taking actions that need elevated access. He also describes credential enforcement and the limits of approval as a security control.
coding agents, agent permissions, production access, vercel agent
textvercel.com · 10/26/2026 · Ready for Ask

Addy Osmani describes how the Claude Code team uses automated reviews, risk-based human approvals, and fast rollback to handle a high volume of agent-written code. The article explains how Anthropic evaluates reviewer accuracy and aims to reduce human review time without increasing reverts or incidents.
coding agents, automated code review, claude code, agent evaluation
textclaude.dev · 10/26/2026 · Ready for Ask

Matt Pocock talks with Robert C. Martin (Uncle Bob) about why software fundamentals still matter when working with coding agents, including where they agree and disagree.
coding agents, software fundamentals
videoyoutube.com · 10/26/2026 · Ready for Ask

Matt Pocock talks with Lauren Tan (poteto), creator of pstack, about using agents to ship high-quality work at scale.
coding agents, software factories, pstack
videoyoutube.com · 10/26/2026 · Ready for Ask

Matt Pocock talks with Nate Herk about working with coding agents, shaping their environment, and why spec-driven development made his code worse for months. They also discuss opportunities for non-technical people, standing out, and how to get started.
coding agents, spec-driven development, agent prompting, agent evaluation
videoyoutube.com · 10/25/2026 · Ready for Ask

Matt Pocock and Joel Hooks discuss building trust in coding agents, from proving code works and automated review to keeping humans in the loop. They also cover agent workflows, Effect, and why human judgment still matters.
coding agents, agent evaluation, effect, software factories
videoyoutube.com · 10/25/2026 · Ready for Ask