Skip to main content
AmigoFish

AI Engineer

AI EngineerVideoLast show:

Not rated yet

About this show

We turn high signal in-person events for the top AI engineers, founders, leaders, and researchers in the world into the best free learning opportunities for millions around the world here on YouTube. Your subscribes, likes, comments, speaking, attendance, or sponsorships goes a long way toward making our biz model sustainable indefinitely.

We strongly believe this industry deserves a better class of community and that we know how to do this well; we just need your support.

Videos come from the channel's public YouTube feed. The artwork is the newest video thumbnail. Last updated . Names, artwork and text belong to their publishers.

Cosmos

Similar by topic and creator

See the full Cosmos

Videos

  • Let's Open Source the World — Brandon Thomas, ArtCraft

    · 19 min

    ArtCraft’s first Photoshop approximation took about 24 hours to build, Brandon Thomas says. At CODE Summit 2026, he explains how Rust and AI coding agents power open source alternatives to Adobe’s creative tools, Microsoft Office and Figma. MCP and CLI automation, Linux support, reusable UI components and CI bottlenecks lead into Autocraft, a forthcoming software factory for issue triage, agentic development, evaluations and post training. Speaker info: - https://github.com/echelon - https://x.com/echelon - https://getartcraft.com/apps Timestamps: 0:00 - Open sourcing the world 2:30 - The open web before closed platforms 4:29 - Subscriptions, gatekeepers and lost ownership 6:47 - ArtCraft and artists coding their workflows 9:17 - A Photoshop approximation in 24 hours 11:10 - Viral growth and artists embracing AI 12:13 - Beyond Adobe: office, CAD and collaboration 14:17 - Linux, localization and programmable apps 16:11 - Why Rust, native GUIs and CI 17:35 - Human review and the Autocraft software factory

    Not rated yet
  • I love you so jevving much — Diogo Almeida, TypeSafe AI

    · 23 min

    Being Einstein 95% of the time and Mr. Bean 5% is Diogo Almeida's analogy for unreliable LLM automation. At CODE Summit 2026, the TypeSafe AI cofounder argues that RLHF optimizes models for human assistance and makes the case for machine native AI with Jev. Reliable agents, KV cache limits, shared memory, semantic types and real time security point toward what software engineers could build beyond chatbots. Speaker info: - https://www.linkedin.com/in/diogomda - https://x.com/CompleteSkeptic - https://docs.typesafe.ai/introduction Timestamps: 0:00 - Where is all the automation? 1:34 - The two cults and jagged AI 3:31 - Human assistance versus machine automation 5:53 - Jev and choosing the right training task 9:27 - Reliable intelligence beyond benchmarks 10:56 - Smart software versus generated software 12:20 - The blue LED and a fourth logic gate 15:22 - Decomposition, verification and state management 16:15 - Agent memory and the tyranny of the KV cache 17:32 - Encoding intent, security and semantic types 19:41 - Stopping slop and playful software 21:22 - What could software engineers automate next?

    Not rated yet
  • All Code Is Slop (Except Mine) — Lauren Tan, SpaceXSI

    · 17 min

    11,000 pull requests in one month, with a revert rate around 0.5%. Lauren Tan (poteto) shares how the Grok Bot team at SpaceXSI scales AI coding agents through software architecture, lint rules, automated testing, runtime verification and formal verification with TLA+ and Lean. See how Cursor agents and pstack turn these software engineering foundations into reliable software factories. Speaker info: - https://x.com/poteto - https://github.com/poteto - https://github.com/cursor/plugins/tree/main/pstack Timestamps: 0:00 - Turning slop into gold 2:03 - The trust pyramid and codebase quality 5:00 - Dune and enforceable architecture 6:56 - Replacing comments with lint rules 9:40 - Runtime verification and feature maps 10:50 - Formal verification and UI testing 11:51 - Spending tokens on verification 13:32 - 11,000 PRs and a 0.5% revert rate 15:11 - Foundations before software factories

    Not rated yet
  • AIE CODE: Google DeepMind, OpenAI, ArtCraft, Cognition, Exa, Anthropic, Amp, et al

    · 9 hr 5 min

    Live from San Francisco, AI Engineer Code Summit 2026 brings together engineers and technical leaders building with AI. Session Day 2: Thursday, November 12, 2026 Livestream: 9:00 AM–6:00 PM Pacific (PST) Venue: Hilton San Francisco Union Square Explore the conference and agenda: https://ai.engineer/code Subscribe for more AI Engineer talks, livestreams, and event coverage: https://www.youtube.com/@aiDotEngineer

    Not rated yet
  • Rethinking Claude Code Best Practices — Lydia Hallie, Anthropic

    · 17 min

    The models have gotten really good, and most of what we've added to our Claude Code setups over the past year is now holding them back. In this talk I'll go through what Claude Code best practices look like for the Claude 5.5 models, what's still worth keeping, and what you no longer need to think about. Speaker info: Lydia Hallie Member of Technical Staff, Anthropic Lydia Hallie is a Member of Technical Staff at Anthropic, working on developer relations for Claude Code. She creates technical content, talks, and workshops that help developers understand how Claude Code works and how to use it effectively.

    Not rated yet
  • AIE CODE: Google DeepMind, Anthropic, SpaceXSI, TypeSafe, Lovable, Ramp, etc (System One theme)

    · 8 hr 58 min

    Live from San Francisco, AI Engineer Code Summit 2026 brings together engineers and technical leaders building with AI. Session Day 1: Wednesday, November 11, 2026 Livestream: 9:00 AM–6:00 PM Pacific (PST) Venue: Hilton San Francisco Union Square Explore the conference and agenda: https://ai.engineer/code Subscribe for more AI Engineer talks, livestreams, and event coverage: https://www.youtube.com/@aiDotEngineer

    Not rated yet
  • Stop Shipping LLM Settings That Only Win on Paper - Rohan Pandey & Balaji Varadarajan, DigitalOcean

    · 5 min

    Most LLM serving "wins" come from turning up a single setting, and on production hardware that setting often has little to do with what your users actually get. Rohan Pandey and Balaji Varadarajan walk through the optimization agent DigitalOcean runs on its AMD MI355 inference servers: it proposes a vLLM and Kubernetes configuration, rolls it out, measures throughput under real latency targets, and either keeps the winner or safely restores the old setup. They share what four studies revealed, including a +4% "winner" that turned out to be run-to-run noise, and how they're extending the same agent to disaggregated prefill and decode serving. Rohan Pandey, DigitalOcean: https://x.com/RohanPandey7821 | https://www.digitalocean.com Balaji Varadarajan, DigitalOcean: https://www.digitalocean.com

    Not rated yet
  • Your SKILL.md Is 70% Stuff the Model Already Knows - Nikolay Petrov, Intel

    · 14 min

    Adding a line to a skill takes seconds, but removing one is scary, so skills only grow. Nikolay Petrov shows how to see inside a skill: split it into small checkable claims, test the model with and without each one, and get a line-by-line map of what the skill actually teaches, what the model already knew, and what makes it worse. The first skill they tested was 70% things the model already knew. The value was in the other 30%, the exact details a naive shortener would cut first. Nikolay Petrov, Intel: https://www.intel.com

    Not rated yet
  • Your Spec Has Bugs. Catch Them Before Your Agent Codes. - Rajath Mahendrappa Kotyal, AWS

    · 7 min

    Spec-driven development only works if the spec is right, and specs are full of quiet bugs: rules that can't both hold, missing failure cases, sentences with two meanings. Your coding agent will faithfully build every one of them. Rajath Mahendrappa Kotyal shows how Kiro catches these before any design or code is generated by pairing LLMs with SMT solvers, turning the model's own disagreement into a signal that a requirement is ambiguous. You'll also see where solvers beat LLM-as-judge, and where they don't. Rajath Mahendrappa Kotyal, AWS: https://aws.amazon.com

    Not rated yet
  • 225,000 Lines of Tests, Written and Merged by Agents - Kush Agrawal, Duolingo

    · 12 min

    Duolingo's iOS app has nearly 2 million lines of code, and its unit test coverage lagged far behind. Kush Agrawal walks through the autonomous pipeline that fixed it: scheduled workflows pick untested code, coding agents open pull requests, and a lifecycle manager monitors CI, fixes failures, runs AI review and merges, with engineers as the final reviewers. Since March it has merged more than 700 PRs and 225,000 lines of tests, raising overall app coverage from 11% to 24%. He covers the architecture, the guardrails, the failure modes, and how they're reusing the same loop for other migrations. Kush Agrawal, Duolingo: https://www.duolingo.com

    Not rated yet
  • Agents Made Code Free. Maintaining It Didn't Get Cheaper. - Dmitry Buykin, Maersk

    · 18 min

    Coding agents made writing code almost free, but maintaining it didn't get any cheaper. Dmitry Buykin shares what happens months in, once agents write most of a large production codebase: tests that pass while production breaks, work nobody asked for, rules that contradict each other, and sprawl no one can review. He covers the patterns that actually help, from replaying real tasks and expert-owned evals to runtime guardrails and weekly pruning, and closes with an 18-question checklist for auditing your own AI-coded repo. Dmitry Buykin, Maersk: https://x.com/tzakus | https://linkedin.com/in/buykin/

    Not rated yet
  • Pick Problems That Survive When AI Solves Coding - Ara Khan, Cline

    · 26 min

    What will you work on once frontier labs solve coding? Ara Khan traces the rise of coding agents and where recursive self-improvement takes them next, connecting the feedback loops across evals, agent harnesses, inference and training. He separates measured progress from hype to help you find the real bottlenecks and choose problems that will last. Ara Khan, Cline: https://x.com/arafatkatze | https://cline.bot

    Not rated yet
  • Your Agent Doesn't Need an LLM for Every Decision - Raymond Weitekamp, OpenProse

    · 51 min

    Recursive language models have become a powerful harness pattern for LLMs. Raymond Weitekamp shows how the same idea applies to decision models, the fast classifiers also called System One models, to build far more efficient workflows for coding agents, information retrieval and computer use. He introduces Recursive Decision Models, shares a vision for real-time interfaces he calls Operating System One, and previews oSo, a new computer use decision agent. Raymond Weitekamp, OpenProse: https://x.com/raw_works | https://openprose.ai More: https://recursivedecisionmodels.com | https://github.com/rawwerks/rdm | https://oSo.computer

    Not rated yet
  • Your Sub-Agents Are a Distributed System. Treat Them Like One. - Girish Konda, Microsoft

    · 23 min

    When an orchestrator hands work to sub-agents, you've built a distributed system, and you inherit its classic failures: half-finished work reported as success, guesses read back as facts, rate limits the orchestrator never sees, and retries that run side effects twice. Girish Konda maps each failure to the distributed-systems idea that already explains it, with examples from his open-source MCP Pacemaker and the MCP and A2A specs. He then lays out SAFE hand-offs, the consistency model he uses for sub-agents that touch real systems, including what it costs and where it doesn't fit. Girish Konda, Microsoft: https://www.microsoft.com

    Not rated yet
  • Your Team's Agents Are All Shipping to the Same Code at Once - Patrick Debois, Tessl

    · 22 min

    Your whole team runs coding agents now, and all of them land on the same main branch. Continuous delivery wasn't built for that. Patrick Debois maps what breaks when a software factory goes multiplayer, and the patterns that fix it: one main for the agents, one board for the people. Patrick Debois, Tessl: https://x.com/patrickdebois | https://tessl.io

    Not rated yet
  • Every Company Is Building Agents That Can't Work Together - Justin Schroeder, Standard Agents

    · 34 min

    Skills and MCP gave agents a standard way to get context, but the agents themselves are still one-offs: every team builds its own, and none of them can be shared or combined. Justin Schroeder argues that agents won't reach their potential without portability and composition, and walks through a concrete agent runtime standard that lets anyone build an agent, distribute it, and compose it with others. Justin Schroeder, Standard Agents: https://x.com/jpschroeder | https://standardagents.ai

    Not rated yet
  • Your PR Says the Tests Passed. Prove It. - Stephen Chin & Cassandra Chin

    · 23 min

    A pull request can claim that checks passed even when the recorded commands do not establish that the submitted change was tested. Cassandra Chin built Tracetoon to recover the context behind a branch, write a better pull request description and optionally explain it with a comic. Together with Stephen Chin, she follows one troublesome review through repeated revisions, missing evidence and rising token costs. The problem is more specific than producing fluent prose: the writer needs to connect a change to its rationale, the commands that ran, their timing and the version of the code they actually checked. Their next iteration uses Relate, an embedded graph database written in Rust, to assemble that evidence before the writing begins. A connected brief gives the writer and reviewers the same sources, reducing repeated searches through session logs. The speakers explain why they kept a stronger writer while using less expensive reviewers to check claims against the brief, and show results from their own PR Bench development comparisons. Those reported results combine improved description quality with roughly half the token usage; they describe this project's evaluation, not a guarantee for other codebases. The practical pattern is to preserve provenance and relationships outside the model's conversation, make uncertainty visible, and give reviewers evidence tied to the submitted content. The comic provides the story, but the useful engineering artifact is the reviewable chain behind each claim. Speaker info: Stephen Chin, Neo4j - https://github.com/steveonjava Cassandra Chin, Tracetoon creator - https://www.linkedin.com/in/cassandra-chin-developer Project: - https://tracetoon.com/ Timestamps: 0:00 - Why Cassandra built Tracetoon 1:40 - A pull request enters the token factory 4:35 - Recovering evidence across agent sessions 7:35 - The original Tracetoon research and review loop 9:10 - When a passing check claim lacks evidence 10:25 - Why cheaper writers did not solve the problem 11:15 - Introducing the Relate evidence graph 13:28 - Connected briefs and focused reviewers 15:24 - Tying claims to the submitted change 16:26 - PR Bench results and token usage 19:46 - Lessons, project links and closing remarks

    Not rated yet
  • Give Your On-Call Its Own AI Teammate - Swaapnika Motapothula, Chinmay Gandhi & Vlad Tsvang, Meta

    · 15 min

    Twelve alerts fire at 2 a.m., and a useful assistant can still leave the engineer coordinating every step. Meta's on call team uses that illustrative scenario to explain a different design: one AI teammate per rotation, with shared context, its own identity, persistent memory and explicit limits on what it can do. Swaapnika Motapothula, Chinmay Gandhi and Vlad Tsvang describe a system that connects alerts, tickets, incident history and code changes instead of leaving each automation with its own isolated view. The goal is to bring a human a decision with supporting evidence and a proposed action. Their autonomy ladder starts with investigation, advances to drafting fixes for approval, and permits selected lower criticality work only when mistakes are cheap to detect and the agent has earned trust on that action. Critical production decisions stay with people, and code changes still go through normal review and continuous integration. The team explains the automation loops for triage, recovery from stuck runs, and shift handoffs, plus how team specific skills and memory carry expertise between engineers. Corrections reopen work and become new evidence, while memory entries can be promoted or retired. The examples show the intended experience rather than a measured time savings result: the speakers explicitly reserve that claim for a rigorous study. Their next steps focus on accepted mitigations, better feedback and earning further autonomy. Speaker info: Swaapnika Motapothula, Meta - https://www.linkedin.com/in/swaapnika-motapothula Chinmay Gandhi, Meta - https://www.linkedin.com/in/cvgandhi Vlad Tsvang, Meta - https://tsvang.com/ Timestamps: 0:00 - From faster coding to production operations 1:21 - An illustrative 2 a.m. incident 3:18 - One AI teammate per rotation 5:08 - The three levels of autonomy 7:15 - A smaller human decision queue 9:31 - Triage, recovery and handoff automation 11:44 - Shared identity and memory across shifts 13:24 - Feedback, customization and team adoption 14:11 - What changed and what still needs measurement

    Not rated yet
  • You Can't Tell What an Agent Skill Will Do by Reading It - Roey Ben Chaim, Zenity

    · 14 min

    An official diagnostic skill can read cloud credentials, contact identity services and probe an instance metadata endpoint. Those same actions can resemble an information stealer. Roey Ben Chaim of Zenity and the MATS Fellowship uses that ambiguity to explain why reading a SKILL.md file cannot establish what an agent will actually do. Instructions can fetch more instructions, installation scripts can pull in packages, and those packages can create processes whose effects never appear in the agent's own trace. The missing evidence is runtime behavior, collected inside a controlled environment. Roey walks through the evolution of an agent detonation chamber: a sandbox, a world builder that supplies the services a skill expects, an operator that exercises different paths, and instrumentation for processes, filesystem activity and network traffic. He then follows concrete cases involving chained skill installation, a misleading package name, persistence, hooks and remotely fetched prompts. One investigation traces a lookalike project through a downloaded payload to credential harvesting, showing why the complete chain matters more than the entry file. The examples illustrate both malicious behavior and legitimate activity that can trigger suspicion; they are not a claim that one scanner can classify every skill correctly. The engineering takeaway is to treat skills as software dependencies, inspect what they load, restrict their access, and preserve evidence of what executes beyond the model's visible conversation. Speaker info: Roey Ben Chaim, Zenity and MATS Fellowship - https://www.roeybc.com/about - https://www.linkedin.com/in/roeybc - https://labs.zenity.io/ Timestamps: 0:00 - When legitimate diagnostics resemble an attack 1:37 - Why scanning SKILL.md is insufficient 2:48 - Building the agent detonation chamber 3:48 - Environments, task coverage and execution 6:03 - Capturing processes, files and network activity 7:08 - Chained skills and misleading packages 8:48 - Persistence, remote prompts and hook abuse 10:35 - Investigating a credential harvesting campaign 13:33 - Treat skills as supply chain dependencies

    Not rated yet
  • Merge Is the Bottleneck - Prasanna Sankar, Vorflux

    · 20 min

    A customer call ended with a bug, and an agent found the unfinished task in the transcript and screen recording. In Prasanna Sankar's account, it asked for permission to investigate, involved the responsible engineer, produced a pull request and drafted the customer followup after the fix shipped. That example captures where Vorflux's engineering work led: once agents can complete longer tasks, coordinating and starting the right work becomes its own bottleneck. Prasanna traces the progression from cloud coding sessions to persistent bots with a goal, an owner and a shared channel. The foundation is six practical problems: reproducing a working development environment, investing more effort in planning, dividing tasks with dependencies, testing without returning to a laptop, reviewing from multiple angles, and keeping changes mergeable as the base branch moves. Browser tests, recordings and staging links give people something concrete to inspect. The second half shifts from those coding workflows to on call, CI and project management bots that respond to signals already present in the company. Prasanna also describes the failure mode of indiscriminate automation: noisy alerts, unwanted pull requests and growing token bills. His proposed controls are budgets, visible work, named ownership and increasing responsibility as results justify it. These are lessons and examples from building Vorflux, with a clear acknowledgment that the bots remain fallible and some responsibilities still belong with people. Speaker info: Prasanna Sankar, Vorflux - https://www.linkedin.com/in/myprasanna/ - https://vorflux.com/ Timestamps: 0:00 - Prasanna's background and the move to longer agent tasks 3:46 - Reproducing the development environment in the cloud 5:10 - Planning effort and dependency aware orchestration 6:41 - Browser tests, recordings and staging links 7:44 - Independent reviews and the merge queue 8:48 - The bottleneck moves to project management 10:39 - Starting work from existing signals 12:58 - Why indiscriminate automation fails 14:17 - Autobots, ownership and a customer support example 16:56 - Orchestration, operating limits and the next bottleneck

    Not rated yet