The Video Signal

Topic

AI Engineering

All digests tagged AI Engineering

AI Engineer Paris 2026 Opening Keynotes: Mistral, Langfuse & Sizzy | Day 1 thumbnail

· 1:14:46

AI Engineer Paris 2026 Opening Keynotes: Mistral, Langfuse & Sizzy | Day 1

The keynotes covered the profound economic impact of AI as a General Purpose Technology (GPT), detailing historical parallels with the Industrial Revolution. The technical discussion highlighted the evolution of AI development from simple prompting to complex, orchestrated 'software factories.' Speakers emphasized the shift toward robust, enterprise-grade solutions, focusing heavily on agentic safety, data sovereignty, and unified platforms that manage diverse tools and connectors.

Key takeaways

  1. AI as a General Purpose Technology (GPT)

    AI is positioned as a GPT, similar to electricity or the internet, capable of driving long-term economic growth. However, realizing this growth requires more than just invention; it demands diffusion, investment, and organizational change (the 'slow clock' of adoption).

  2. The Shift to Software Factories 20:00

    AI development is moving beyond simple 'vibe coding' and 'meat proxy' roles toward structured 'software factories.' This requires sophisticated orchestration to manage tasks, testing, and code generation in a controlled manner.

  3. Focus on Agentic Safety and Sovereignty 1:03:20

    Enterprise AI requires robust controls to manage risks. Key concepts include dynamic privilege access, runtime guardrails, and data sovereignty (knowing where data is stored and processed) to build trust and compliance.

  4. Advanced Orchestration Tools 41:40

    Modern tooling is moving toward unified, modular systems (e.g., using `Proxmox` or `Exeutor`) to manage multiple AI models and services from a single endpoint, ensuring portability and control.

Watch on YouTube Full article

The Dark Arts of Skill Engineering — Paul Bakaus, Renaissance Geek thumbnail

· 1:04:53

The Dark Arts of Skill Engineering — Paul Bakaus, Renaissance Geek

The talk, 'The Dark Arts of Skill Engineering,' argues that effective AI skill development moves beyond simple prompt engineering and into 'harness engineering.' The speaker details advanced techniques—such as using blind sub-agents, implementing anti-attractors, and utilizing mixture-of-experts architectures—to build robust, deterministic, and highly controllable skills. These techniques focus on exploiting the underlying capabilities of the AI model's execution environment (the 'harness') rather than just the input prompt, resulting in skills that are less susceptible to model drift and more reliable across different deployment environments.

Key takeaways

  1. Harness Engineering vs. Prompting 0:06

    Skills should be treated as extensions of the entire coding/AI harness, not just packaged prompts. This involves leveraging system capabilities like hooks, scripts, and standard output to enforce behavior, which is more reliable than prose instructions. (6:25)

  2. Adversarial Sub-Agents 0:08

    To achieve balanced critique or review, use two or more sub-agents that are blind to each other's output. This prevents a single model thread from anchoring on its own work or failing to detect obvious flaws. (7:55, 10:11)

  3. Anti-Attractors for Divergence 0:17

    To prevent model convergence on common or predictable outputs (the 'median'), implement anti-attractors. Techniques include shaving the next predicted token, generating random seeds (e.g., using celebrities for shaders), or running scripts that introduce unexpected input. (16:59)

  4. Passive Guardrails via Hooks 0:20

    Use hooks (e.g., pre-tool use hooks) to enforce design or code standards (like design linting) by actively preventing the model from writing non-compliant code, rather than relying on post-hoc corrections. (20:38)

  5. Compounding Context and Memory 0:30

    Skills can be made aware of prior sessions by saving intermediate results (e.g., critique files) in a dedicated folder. This allows subsequent runs to build context and track progress over time, enabling multi-session refactoring. (30:00)

Watch on YouTube Full article

Essential Skills for Becoming an AI Engineer: RAG, AI Agents, & More thumbnail

· 10:55

Essential Skills for Becoming an AI Engineer: RAG, AI Agents, & More

The video outlines the modern skill stack required for an AI Engineer, defining the role as building and deploying systems around existing Large Language Models (LLMs), rather than researching foundational models. The necessary skills are structured into three critical tiers: foundational engineering skills (Python, Git, APIs), specialized AI techniques (RAG, embeddings, agents), and deployment/operations expertise (Containerization, Observability). The speaker emphasizes that mastering this structured approach is crucial for building reliable, production-grade AI solutions.

Key takeaways

  1. AI Engineer vs. ML Researcher

    An AI Engineer builds applications using existing models (e.g., Frontier, Open Source), connecting them to data and tools. An ML Researcher focuses on training foundational models from scratch and publishing new architectures.

  2. The Three-Tier Skill Stack 2:00

    The required skills are structured in three tiers: 1) Foundational skills (Python, Git, APIs); 2) AI-specific skills (Embeddings, RAG, Agents); and 3) Deployment/Ops skills (Containerization, Observability).

  3. The Importance of Grounding Data (RAG) 4:00

    Retrieval Augmented Generation (RAG) is critical for providing LLMs with accurate, company-specific information (e.g., policies, legal documents) to prevent hallucination. This involves chunking documents, embedding them into vectors, and feeding relevant context into the LLM's context window.

  4. AI Agents and Tool Use 5:20

    AI Agents represent a significant advancement, allowing systems to dynamically decide next steps, call external tools, observe results, and iterate in a loop, moving beyond simple predefined workflows.

Watch on YouTube Full article

How to set up Herdr for multi-agent coding (full guide) thumbnail

· 28:40

How to set up Herdr for multi-agent coding (full guide)

This guide details setting up Herder, a tool described as the 'meta' for multi-agent coding, allowing developers to manage and orchestrate multiple AI coding agents and projects within a persistent terminal environment. The setup emphasizes creating isolated 'spaces' for different projects, integrating various AI model harnesses (e.g., Grock, Codeex, Claude), and optimizing the workflow using advanced CLI tools like zoxide, Neovim, and Lazygit. The core benefit is achieving a single, persistent interface for complex, multi-agent development cycles, minimizing context switching and session loss.

Key takeaways

  1. Persistent Session Management

    Herder allows developers to maintain persistent terminal sessions (spaces) that survive terminal closures, similar to T-Mix, ensuring continuous work history and state for CLI-based coding tools.

  2. Agent Orchestration and Delegation

    The Herder skill enables agents to communicate and delegate tasks across different sessions and models (e.g., using Claude to review code started by Grock), providing full transparency into the multi-agent workflow.

  3. Customization via config.toml 20:32

    All aspects of Herder—including colors, spacing, and keyboard shortcuts—can be customized using the `config.toml` file, which can even be configured by an AI agent.

  4. Optimizing Navigation and Workflow

    Integrating tools like zoxide for faster folder navigation and Lazygit for Git status review allows the entire development process to be contained within a single, optimized terminal interface.

Watch on YouTube Full article

Google, McKinsey & Dave Farley on AI Code Review thumbnail

· 11:15

Google, McKinsey & Dave Farley on AI Code Review

The rapid acceleration of AI code generation creates a critical bottleneck in traditional software development processes, specifically the code review phase. Speakers discuss how the current ratio—where generating code is fast (seconds) but reviewing it remains slow (hours)—is breaking down established social contracts and trust within open-source collaboration. Solutions proposed include shifting focus from quality control to engaging with mental models, implementing advanced agent memory systems (like Tapes), and prioritizing precise, prescriptive language over vague natural language.

Key takeaways

  1. The Code Review Bottleneck 0:26

    Current processes assume a slow ratio: generating code takes 30 seconds, but reviewing it can take an hour. This mismatch strains maintainers, especially when agents generate multiple pull requests (PRs) rapidly, leading to 'trust breakdown' regarding who actually reviewed the code.

  2. Reviewing Mental Models 5:18

    Code review should not be viewed as quality control. Instead, it is a mechanism for engaging with and aligning multiple mental models (the developer’s model, the system’s model, and colleagues' models). Maladaptive creativity can cause these three models to diverge.

  3. Agent Hallucination & Memory 7:33

    AI agents can 'politely hallucinate,' reporting progress without actual learning or completion. To combat this, advanced systems must capture raw agent sessions and process them into structured 'observational memory' for continuous improvement.

  4. Precision over Natural Language 10:02

    Natural language is inherently vague and open to misinterpretation, making it insufficient as the sole programming language of the future. Precision requires prescriptive instructions that go beyond general conversational prompts.

Watch on YouTube Full article

Your Code Has Bugs. Lean4 Has Proofs: Formal Verification for Engineers — Varun Pant, AWS thumbnail

· 10:07

Your Code Has Bugs. Lean4 Has Proofs: Formal Verification for Engineers — Varun Pant, AWS

As AI coding agents generate massive amounts of code, traditional checks (probabilistic model grading, input-limited tests, human review) are insufficient to guarantee correctness for all inputs. Formal verification provides mathematical proof that code satisfies a precise specification. The methodology involves humans owning the specification and machines handling both the implementation and the formal proof. Tools like Lean allow the same language for defining code and proofs, enabling robust systems where production code (e.g., Rust) is reconciled against specifications written in Lean, often through differential random testing.

Key takeaways

  1. Limitations of Current Code Checks

    None of the usual checks—AI model grading (probabilistic), unit tests (limited inputs), or human review (non-scalable)—can guarantee that code is correct for every possible input. Formal verification provides mathematical proof of correctness for all inputs.

  2. The Specification Hierarchy 2:00

    In formal verification, humans own the specification (what 'correct' means). This specification must be validated first because it is the upstream artifact; everything else (code and proof) is downstream from it. The AI coding agent then implements code based on this spec.

  3. Lean as a Unified Language 4:00

    Lean functions as both a programming language and a proof assistant, eliminating translation layers. It allows the same language to define definitions (code) and proofs (theorems).

Watch on YouTube Full article

From AI-Assisted to AI-Native: Building a Frontier Development Team — Clare Liguori, AWS thumbnail

· 20:57

From AI-Assisted to AI-Native: Building a Frontier Development Team — Clare Liguori, AWS

Frontier development represents a step-function improvement in productivity using AI agents, moving beyond simple coding assistance. The core finding is that success is not dependent on the tools themselves, but rather on intentionally changing engineering workflows and building new habits. Key practices include investing heavily in agent context, slowing down to refactor codebases (e.g., migrating from untyped languages like Python/JavaScript to TypeScript or Rust), implementing parallel agent execution, making intent explicit via documentation, and shifting testing left using local deterministic mocks.

Key takeaways

  1. Frontier Development Definition

    Productivity gains are characterized by engineers writing only 1-2% of the code; agents running for hours without interruption; and multiple agents operating in parallel. This represents a median productivity improvement of 4.5x to over 10x compared to previous AI phases (0:00, 7:04).

  2. The Importance of Process Over Tools 11:44

    A pilot study involving 50 teams on existing codebases found that the difference between <3x and >4.5x productivity gains was determined by how the team worked, not the AI tools used (9:21).

  3. New Bottleneck Identification 18:58

    As coding speed increases dramatically, the bottleneck shifts from writing code to decision-making speed and organizational review processes. Fast decisions, especially reversible ones, are critical for scaling (11:38).

Watch on YouTube Full article

Knowledge Systems: The New GTM Stack — Jeffrey Wang, Exa thumbnail

· 18:49

Knowledge Systems: The New GTM Stack — Jeffrey Wang, Exa

Jeffrey Wang argues that Go-To-Market (GTM) strategy must be treated as an AI engineering problem. The core thesis is that GTM is fundamentally a data problem, requiring the creation of a 'live model of your world' that autonomous agents can act upon. He details systems like Exa (a search engine for agents), the ICP dashboard for classifying the Total Addressable Market (TAM), and Request Lens for real-time customer signal detection. Key architectural principles include making the system API-first, recognizing that consistent UIs still complement flexible chatbots, and prioritizing arbitrary customizability over rigid build vs. buy decisions.

Key takeaways

  1. GTM as a Data Problem 4:56

    The goal is to build a live model of the world—combining internal data (customer usage) with external data (web activity, company information)—that agents can programmatically act on. This shifts GTM from a purely sales function to an engineering challenge.

  2. Agent-First Requires API-First 16:59

    For any agent system (whether it's a GUI or a chatbot) to access data, the underlying systems must expose robust programmatic interfaces (APIs). This is critical for enabling agents to function.

  3. System Components: ICP Dashboard & Request Lens 8:38

    The ICP dashboard uses Exa's embeddings over the internet to classify every company in the TAM and estimate anticipated spend. Request Lens provides real-time alerts when significant customer signals occur (e.g., signups, search surges).

  4. The Value of AI Cloning (Jeffbot) 13:42

    An agent can be trained on historical data to mimic a user's professional style and decision-making. Jeffbot was built by analyzing 760 emails and hundreds of past decisions, creating 'evals' to calibrate its judgment against the founder’s own behavior.

Watch on YouTube Full article

The Last Human Code Review: Building Trust in AI-Generated Code — Itamar Friedman, Qodo thumbnail

· 18:54

The Last Human Code Review: Building Trust in AI-Generated Code — Itamar Friedman, Qodo

The bottleneck in modern software development is shifting from writing code to managing governance and context within the Software Development Life Cycle (SDLC). The speaker argues that AI models are no longer the primary constraint; instead, the critical challenge is codifying 'tribal knowledge'—the undocumented best practices, architectural contracts, and historical failure data held by senior developers. Future code review must transition from line-by-line diff checking to reviewing a comprehensive software graph that tracks inter-service dependencies and potential contract breaks across multiple concurrent Pull Requests (PRs).

Key takeaways

  1. The Bottleneck Shift

    The primary bottleneck is no longer writing code, but rather the governance layer within the SDLC. Organizations must address how to automate or enhance code review processes that validate architectural standards and business intent.

  2. Two Competing Philosophies 5:38

    Engineering leaders are split into two camps: those who insist every line of code requires human trust/review, and those who prioritize velocity by shipping bugs quickly and fixing them post-deployment. The chosen philosophy dictates the necessary tooling and governance strategy.

  3. Context is the Constraint 8:39

    The limitation is not model reasoning ability; it is the scattered nature of context—which resides across competing instruction files, internal team standards, and undocumented knowledge held in developers' heads or Slack threads. Codifying this context is paramount.

Watch on YouTube Full article

Velocity Sickness: What Happens When Your Whole Team Gets 10x Faster — Matt Dailey, Ref. thumbnail

· 20:37

Velocity Sickness: What Happens When Your Whole Team Gets 10x Faster — Matt Dailey, Ref.

The video addresses 'velocity sickness'—the stress of sudden, unimpactful increases in AI-driven output that do not translate into meaningful product progress. The speaker argues that current engineering workflows are flawed because they treat all work as implementation (code) and fail to properly manage the critical decision layer. To solve this, engineers must separate the durable state/decisions from the ephemeral actions/implementations. This is achieved by shifting focus from using chat interfaces for planning to utilizing dedicated, shared document structures that capture system state.

Key takeaways

  1. Understanding Velocity Sickness 2:00

    Velocity sickness is defined as the stress caused by sudden output increases due to AI, resulting in high output without corresponding impact. This manifests as too many PRs to merge, working across too many directions simultaneously, or 'declaring agent bankruptcy' (doing work that isn't retained).

  2. The Critical Failure Point: Decision Ownership 5:45

    The most critical risk is allowing agents to make key decisions. If an engineer delegates decision-making, they lose ownership of the code and, by extension, the product.

  3. Shifting Focus from Code Velocity to Idea Velocity 10:30

    To combat velocity sickness, teams must shift focus from merely shipping code (code velocity) to prioritizing and exploring ideas (idea velocity). This means focusing on planning and understanding the system's contours before implementation.

  4. The Solution: Docs for Decisions, Not Chats 13:25

    The core fix is separating the decision layer from the implementation layer. While chats are isolated, ephemeral, and built for action, durable shared documents (docs) should be used to hold the state and key decisions, keeping agents effectively stateless.

Watch on YouTube Full article

The Dirty Secret of Forward Deployed Engineering — Natalie Meurer, Sierra thumbnail

· 16:49

The Dirty Secret of Forward Deployed Engineering — Natalie Meurer, Sierra

Forward Deployed Engineering (FDE) is not a single discipline but an outcome-focused role that has evolved significantly from initial platform stability work (DevOps) to complex data integration and customer enablement. The core thesis is that as coding becomes cheap due to AI agents, the value of engineering shifts entirely to understanding the customer's problem, integrating disparate data sources, and being accountable for measurable business outcomes.

Key takeaways

  1. FDE is an outcome-based role, not a code-writing one. 0:12

    The durable part of FDE involves integrating data, understanding the customer context, and maintaining accountability to a specific result, rather than merely writing software code.

  2. FDE's evolution tracks platform maturity. 0:06

    Early FDE focused heavily on DevOps and ensuring platform stability (e.g., deploying on an EC2 instance). This evolved into data integration using concepts like the Ontology, leading to modern platforms like Foundry that focus on 'data to decision-making.'

  3. Pricing models reflect accountability. 0:13

    The shift from seat-based pricing (assuming a tool) toward usage or outcome-based pricing confirms that the value lies in guaranteeing results, which is the hallmark of FDE.

  4. AI agents are simply FDE reborn. 0:15

    Agent engineering is viewed as a subset and manifestation of FDE principles, where engineers use LLMs to enable outcomes for customers. The role requires combining product knowledge with customer-facing solutioning.

Watch on YouTube Full article

Build a Document Review App in 3 Hours (Python, React, Azure) thumbnail

· 2:37:48

Build a Document Review App in 3 Hours (Python, React, Azure)

This video provides an end-to-end guide for building a sophisticated document review application designed for invoice and receipt processing. The solution utilizes a modern monorepo architecture, integrating Python (FastAPI) for the backend logic, React for the frontend UI, and Microsoft Azure services (Document Intelligence and Azure OpenAI) for core AI capabilities. The process demonstrates creating a robust, multi-stage pipeline that handles document classification, data extraction, business rule validation, and general ledger account suggestion.

Key takeaways

  1. Hybrid Document Processing Pipeline

    The application uses a hybrid approach by combining specialized pre-trained models (Azure Document Intelligence) for high accuracy/low cost extraction with general LLMs (Azure OpenAI) for complex tasks like classification and suggesting General Ledger accounts. This ensures robustness against edge cases.

  2. Structured Data Modeling

    Pydantic is used extensively to enforce strict schemas on extracted data, transforming raw JSON output into predictable Python objects for reliable business logic application.

  3. Modular Pipeline Design Pattern

    The backend implements a chainable pipeline pattern (Classification -> Extraction -> Validation -> GL Suggestion). This modular design allows individual steps to be easily added, swapped, or removed without breaking the overall workflow.

  4. Enterprise Cloud Setup

    The entire system is designed for enterprise readiness by utilizing Azure services and demonstrating deployment via Azure Container Apps (ACA), emphasizing best practices for production environments.

Watch on YouTube Full article

Harness Engineering is not Enough: Why Software Factories Fail — Dex Horthy, HumanLayer thumbnail

· 19:18

Harness Engineering is not Enough: Why Software Factories Fail — Dex Horthy, HumanLayer

The video argues that current efforts in 'harness engineering' and increasing tokens are insufficient for building reliable AI software factories because they fail to address fundamental model training shortcomings. The core problem is maintaining codebase quality over time (maintainability), which current reward functions do not penalize. To move forward safely, the speaker advocates returning to rigorous human-led upfront planning: Product Review $\rightarrow$ System Architecture $\rightarrow$ Program Design (down to types and call graphs) $\rightarrow$ Vertical Slices.

Key takeaways

  1. The Failure of 'Lights Off' Factories 12:10

    Attempting to run a software factory with no human code review ('lights off') leads to failures, even for advanced agents. The issue is not scale or prompting, but a fundamental model training limitation.

  2. Model Training Flaw (The Maintainability Gap) 17:12

    Current coding models are primarily trained on passing tests and solving one-off problems. Their reward signal does not penalize poor program design or the erosion of codebase maintainability, meaning they get better at passing tests but worse at keeping large systems stable.

  3. The Path Forward: Structured Planning

    To move faster safely, engineers must re-emphasize upfront planning steps: Product Review (desired behavior/mockups), System Architecture (component contracts/data models), Program Design (types and call graphs), and Vertical Slices (implementation order).

Watch on YouTube Full article

2026 State of AI Engineering — Barr Yaron, Amplify Partners thumbnail

· 19:47

2026 State of AI Engineering — Barr Yaron, Amplify Partners

The state of AI engineering is characterized by rapid maturity and increased complexity. Survey data from 1,048 respondents indicates that while open-weight models augment closed systems, the primary drivers for model choice are quality, agentic capabilities (like tool calling), and cost. Cost has become a 'first-class engineering constraint,' forcing teams to manage usage carefully. Furthermore, agents are rapidly evolving from summarization tools to systems with write access, necessitating robust control layers and sophisticated evaluation (eval) processes.

Key takeaways

  1. AI Experience is Democratizing 0:03

    The AI engineering workforce is maturing quickly; the median new engineer has nearly as much AI experience as a 10-year software veteran, indicating that AI skills are becoming foundational to modern development.

  2. Cost is a Primary Constraint 0:08

    Three out of four respondents report adjusting their AI usage based on cost, establishing 'cost' as a first-class engineering constraint alongside quality and capability.

  3. Agents are Taking Action 0:11

    Agentic workflows have shifted significantly: they are no longer limited to reading or summarizing, but are increasingly taking actions inside systems. Write access for agents has increased dramatically (from 52% to 89%).

  4. Evaluation Remains the Biggest Challenge 0:12

    Across all layers of the stack, 'eval' (evaluation) remains the number one biggest challenge reported by engineers.

Watch on YouTube Full article

Katie Roberts - Stop Maintaining, Start Evolving: Applying AI-Native Practices to Brownfield Codebas thumbnail

· 28:43

Katie Roberts - Stop Maintaining, Start Evolving: Applying AI-Native Practices to Brownfield Codebas

This talk addresses the challenge of modernizing complex, legacy 'brownfield' codebases—systems that are highly successful but burdened by accumulated technical debt and tribal knowledge. The speaker outlines how to apply AI-Native Engineering practices not for adding new features, but for architectural reclamation. Key strategies include using established patterns like the Strangler Fig Pattern and Branch by Extraction, coupled with structured processes (e.g., creating a 'plan skill') to systematically pay down technical debt while maintaining continuous function.

Key takeaways

  1. AI should be used for paying down technical debt, not adding to it. 17:33

    Autonomous agents deployed without strict guardrails can cause havoc through over-optimization or generating 'dark code,' undermining implicit architectural constraints and creating new hidden technical debt. Safety and bounded scopes are paramount.

  2. Adopt a structured approach to brownfield modernization. 20:05

    Instead of starting with the code, begin by conducting forensic investigations using developer input (eyewitness accounts) and creating objective data visualizations (e.g., value vs. complexity graphs) to identify high-priority areas for improvement.

  3. Prioritize planning over immediate migration. 25:32

    In brownfield environments, the planning phase is critical. Focus on creating a structured roadmap and defining clear contracts (specs) before writing code to ensure the right thing is built.

  4. Use AI-assisted skills for process automation. 26:30

    Implement multi-agent flows ('skills') that automate tasks like generating PRDs from documentation, creating Jira tickets, and performing detailed code mapping. This accelerates development cycles (e.g., reducing 6 months of work to 8 weeks).

Watch on YouTube Full article

Podcast Crossover: AIE, AGI, frontier lab strategy with ​ ⁨@matthew_berman⁩ and @swyxtv thumbnail

· 28:03

Podcast Crossover: AIE, AGI, frontier lab strategy with ​ ⁨@matthew_berman⁩ and @swyxtv

The discussion explores the current state and future architectural challenges of frontier AI models. Key technical points covered include specialized hardware (e.g., Etched) optimizing for post-transformer workloads, the limitations of Large Language Models (LLMs) in achieving true recursive self-improvement (RSI), and the necessity for 'Agent Labs' to build model-agnostic applications that solve complex, last-mile problems.

Key takeaways

  1. The Value Proposition of AI Engineering Conferences 5:20

    AI conferences are becoming crucial neutral grounds where multiple frontier labs (like OpenAI) can compete on an even playing field, which is highly beneficial for engineers and competitive for the labs themselves. This contrasts with single-vendor events.

  2. Hardware Specialization vs. General Purpose AI 10:20

    New generation chips (like Etched) are optimizing specifically for post-transformer workloads and architectures (post RGBT), moving beyond the general focus of older specialized hardware like Cerebras.

  3. Architectural Limitations of LLMs 22:30

    LLMs are limited in their recursion because they tend to explore variations within known data distributions. True innovation and discovering 'unknown unknowns' still require dedicated research, suggesting a need for new architectural paradigms beyond current transformer models.

  4. The Future of Application Development 25:20

    Founders should focus on building 'Agent Labs'—being the AI layer for specific industries (e.g., lawyers, dentists). This strategy is resilient to model generalization and capability overhangs because it solves persistent, last-mile problems.

Watch on YouTube Full article

How to Go From Data Scientist to AI Engineer (I Did This) thumbnail

· 30:13

How to Go From Data Scientist to AI Engineer (I Did This)

This roadmap guides individuals transitioning from Data Science or Machine Learning into AI Engineering. The core message is that the role shifts focus from statistical modeling in notebooks to becoming a full-stack software engineer capable of building reliable, production-grade AI systems. Key areas covered include closing the software engineering gap (OOP, structured Python projects), mastering LLM backends (FastAPI, Pydantic, Docker), and implementing advanced techniques like Retrieval Augmented Generation (RAG), evaluation (Evals), and guardrails.

Key takeaways

  1. The AI Engineer Shift 0:59

    AI Engineering requires moving beyond Jupyter notebooks to structured Python projects using OOP principles, Git, testing, debugging, logging, and environment management. The focus shifts from pure research to building reliable systems around pre-trained models.

  2. Data Science Advantage 2:00

    Individuals with a DS/ML background have an advantage because they are trained in statistical thinking (distributions, error analysis) which is critical for making non-deterministic LLM outputs reliable in production.

  3. The Importance of Production Backends 5:29

    To build deployable systems, learn to use FastAPI and Pydantic for API creation. Containerization using Docker and persistent data storage with PostgreSQL are essential steps.

  4. Advanced AI Techniques 7:30

    Mastering RAG (Retrieval Augmented Generation) requires understanding vector databases (e.g., using the PGvector extension in PostgreSQL). Furthermore, implementing Evals and Guardrails is crucial for quantifying performance and preventing issues like prompt injection.

Watch on YouTube Full article

The Best AI Automation Stack to Learn in 2026 thumbnail

· 16:33

The Best AI Automation Stack to Learn in 2026

The video outlines a comprehensive five-layer stack for building production-ready AI automation and engineering solutions. The recommended architecture emphasizes foundational software engineering principles—backend, database, frontend, AI models, and infrastructure—rather than relying solely on high-level no-code tools. Core technologies include Python/FastAPI/Celery for the backend, Postgres/Supabase for data storage, React/Vite/ShadCN UI for the frontend, and cloud providers (AWS, Azure, GCP) or specialized services for model integration and deployment.

Key takeaways

  1. Focus on Foundational Layers

    To build a career in AI engineering, understanding how to integrate core components—backend, database, frontend, AI layer, and infrastructure—is more valuable than mastering specific high-level tools.

  2. Backend Core Stack

    Python is the recommended language. FastAPI serves as the API entry point (handling GET/POST/PUT/DELETE webhooks), while Celery manages background workers and scheduled cron jobs, ensuring robustness and scalability.

  3. Database Recommendation 7:15

    Postgres is recommended as the primary database layer. Supabase is suggested as a wrapper around Postgres that simplifies authentication and provides an out-of-the-box admin GUI.

  4. Frontend Stack 12:00

    The recommended frontend stack is React (industry standard UI library), Vite (development server/bundler), and ShadCN UI (a component library for rapid, customizable development).

  5. Deployment Strategy

    For custom deployments, the industry standard is using Docker. For ease of use, platforms like Railway are recommended to simplify deployment setup (e.g., deploying FastAPI/Celery and React code). Advanced options include container services from major cloud providers or dedicated VPS hosting.

Watch on YouTube Full article

Build a Full-Stack GenAI Project in 4 Hours (FastAPI, React, Supabase) thumbnail

· 3:51:50

Build a Full-Stack GenAI Project in 4 Hours (FastAPI, React, Supabase)

This tutorial provides an end-to-end guide for building a production-grade Retrieval Augmented Generation (RAG) application—a Document Copilot. The project uses SEC filings data and demonstrates the complete AI engineering workflow: from initial client brief analysis to setting up the full stack (FastAPI, React/TypeScript, Supabase Postgres with pgvector). Key phases covered include database schema design using SQLAlchemy/Alembic, implementing user authentication via Supabase Auth, building a front-end chat interface, and establishing a robust document ingestion pipeline that converts messy HTM files into structured Markdown chunks for vector embedding.

Key takeaways

  1. Full Stack GenAI Architecture 30:45

    The system is designed as a mono repo using FastAPI (backend) and React/TypeScript (frontend), connected via Supabase Postgres, which utilizes the pgvector extension for efficient vector storage and retrieval.

  2. Data Ingestion Pipeline 3:44:09

    Raw SEC filings (HTM format) are processed using Dockling to convert them into clean Markdown. This structured data is then chunked, embedded via OpenAI, and stored in the database for RAG retrieval.

  3. Database Management

    The project utilizes SQLAlchemy and Alembic for defining models (Users, Documents, Chunks, Messages) and managing schema migrations, ensuring a structured development process.

Watch on YouTube Full article