Learn More: https://bit.ly/4pCoIqu Learn how to make AI code review effective and build your own review agent in this short course, "AI Code Review," built in collaboration with Qodo and taught by Nnenna Ndukwe. The quality of an AI code review depends more on the context the reviewer has than on the model behind it. As AI writes a bigger share of your team's code, that context is what keeps reviews reliable: a pull request can look reasonable while missing a requirement or hiding a security issue, and there's often too much of it to check by hand. You'll start with practical techniques for getting more out of AI review, like reviewing before you open a pull request, giving the reviewer task and repository context, and triaging findings by risk. Then you'll build a context-aware review system of your own, beginning with a context engine that retrieves the most relevant code and extending it into an ensemble of specialized agents. In detail, you'll: - Understand what makes a good code review, and how AI review differs from human review. - Apply the practices that make AI review more effective: run it before you open a pull request, use a reviewer that didn't write the code, and give it the task and repository context it needs. - Triage findings by risk, and turn good feedback into reusable standards so each review sharpens the next. - See why context-aware review catches what a diff-only review misses, then build a context engine with chunking, embeddings, and vector search. - Combine specialized agents, like a security expert and a codebase-pattern expert, into an ensemble that outperforms a single general reviewer. By the end, you'll be able to catch the security holes, missed requirements, and pattern violations that slip through today, and build a reviewer that keeps finding them. Enroll now: https://bit.ly/4pCoIqu

Learn more: https://bit.ly/3Tg20Zd When an LLM generates text, much of the time goes to moving the model's weights from memory to the compute units, not to the math itself. On a GPU those weights sit off-chip, and a large model may be split across several chips, so data travels back and forth before computation can even start. That delay compounds. An agentic workflow might generate hundreds of thousands of tokens before it returns anything to the user. In our new short course, Fast LLM Inference with Cerebras, built in partnership with Cerebras and taught by Zhenwei Gao, Sebastian Duerr, and Sarah Chieng, you'll build applications on hardware designed to remove that bottleneck. Cerebras' Wafer-Scale Engine (WSE-3) is a single chip about the size of a large dining plate, big enough to hold a model's weights on-chip, right next to the compute units. Tokens come out several times faster than on a typical GPU setup, and that changes both what you can build and how you build it. What you can build: real-time, latency-sensitive applications that were impractical when every response carried a delay, like live translation and voice agents. How you build it: once a response lands before the user notices the wait, you can drop the loading spinners, async queues, and precomputed results, and just call the model directly. In this course, you'll learn how to: - Compare how GPUs, TPUs, and the Wafer-Scale Engine handle the memory-to-compute bottleneck, and why keeping weights on-chip minimizes data movement. - Build a live personalization use case that adapts a webpage to users as they interact with it. - Assemble a real-time, multi-tool workflow that runs live analysis of market signals in one fast response. - Adopt concrete habits for multi-agent coding with Codex, validating between tasks to catch issues early and ship cleaner code. Enroll now: https://bit.ly/3Tg20Zd

Don’t miss a night out because you’re watching your terminal. Have your coding agent call you instead! Join the 7-Day Voice AI Builder Challenge here: https://hubs.la/Q04mvXBZ0 Hurry—challenge ends June 30!

Learn more: https://bit.ly/4vPQ3HE Voice is one of the most natural human interfaces, but adding it to AI applications has historically forced a tradeoff: fast voice-to-voice models that sacrifice reliability, or accurate speech-to-text-to-LLM-to-speech pipelines that add latency. This course teaches you how to get both, using Vocal Bridge's architecture that pairs a real-time foreground agent with a reasoning background agent. Taught by Ashwyn Sharma, CEO and Co-Founder of Vocal Bridge (an AI Fund portfolio company), this course covers three practical integration patterns that meet you where you are: voice embedded in an application, voice layered onto an existing agent without touching its logic, and voice as a tool your LLM can call when it decides a conversation is the right modality. In detail, you'll survey the traditional voice stack and its tradeoffs, then explore three live integration patterns to understand when each one applies. Build a voice-interactive tic-tac-toe game where voice commands and mouse clicks work together over a single synchronized channel, then add a voice layer to an existing agent with minimal code, leaving your prompts, RAG pipeline, and tools untouched. Give your agent a make_phone_call tool so it can dial a real number, hold a conversation with a demo agent, and stream the transcript back live. Set up evaluation-driven development using Vocal Bridge's multimodal evaluator to score calls, catch regressions, and refine prompts before issues reach users. Hear from Scott Johnston, former CEO of Docker and Vocal Bridge board member, on what it actually takes to move voice agents from demos to production. By the end of this course, you’ll have implemented three hands-on voice AI patterns: adding voice to an interactive app, layering voice onto a text-based agent, and giving an agent the ability to place outbound calls. You’ll also know how to evaluate and improve voice interactions. Enroll here: https://bit.ly/4vPQ3HE

Learn more: https://bit.ly/3RtV5Lk Introducing Fast & Efficient LLM Inference with vLLM, a short course built in partnership with Red Hat and taught by Cedric Clyburn, Senior Developer Advocate at Red Hat. Serving open-source LLMs efficiently, for many users at low latency and reasonable cost, comes down mostly to memory management. Two things compete for that memory: the model weights and the KV cache. A 70-billion-parameter model takes around 140 GB of memory just for the weights, while the KV cache grows with every request you serve. In this course, you'll learn to shrink the weights through quantization, and serve the model with vLLM, the widely adopted open-source serving system, taking advantage of the memory management techniques it provides like PagedAttention and prefix caching. You'll run the full optimize-deploy-benchmark workflow on a real model: compressing an open-source Qwen model with LLM Compressor, serving it with vLLM, and benchmarking your deployment under realistic traffic using GuideLLM and lm-eval. By the end, you'll have run the full optimize-deploy-benchmark workflow on a real model and built the intuition to navigate the tradeoffs between accuracy, speed, and cost. Enroll now: https://bit.ly/3RtV5Lk

Earn your certificate here: https://bit.ly/4ejb47H If you’ve never written code before, this course is for you. In less than 30 minutes, you’ll learn to describe an idea in words and let AI transform it into an app for you. You’ll build a working web application in minutes: A funny interactive birthday message generator that runs in your browser and can be shared with friends. Then you’ll customize it by telling AI how you want it changed, tweaking it until it works exactly how you want. You’ll learn about best practices for building with AI, such as how to improve your app step-by-step and fix problems when they come up. In this course, you’ll learn to: - Build web applications through prompting: Build interactive tools by describing what you want and collaborating with AI to create working applications—no coding experience required. - Customize and troubleshoot AI-generated apps: Customize features like input fields, buttons, and color schemes through hands-on collaboration with AI, learning to troubleshoot and improve as you go. - Learn a repeatable framework you can apply to any app idea by practicing with different examples—from fun projects like a ping pong game to practical tools like time-off request forms. This course assumes no prior knowledge of AI or coding. You’ll build a birthday card app, customize it with additional features, then use the same framework to build a table tennis game. By the end, you’ll be an AI builder with a framework for building any application you can imagine. If you’re already comfortable with AI or coding, you may recognize how powerful this shift is. And you might know people who don’t yet realize they can build things themselves, like your friends, parents, coworkers, or roommates who have ideas but think “building apps is too hard.” This course is for them. Feel free to share it!

Humans can keep a few ideas in working memory at once. Modern AI models can process the equivalent of multiple Harry Potter books in a single conversation. Understanding context windows changes how you prompt, write, research, and work with AI systems. Learn more in AI Prompting for Everyone with Andrew Ng: https://www.deeplearning.ai/courses/ai-prompting-for-everyone

This talk by Cline's Ara Khan explains why they went from "evals are useless" to using them as a core part of my agent improvement loop. I share practical heuristics for interpreting, running, and creating evals, and why doing them anyway is better than pure "vibes".

“Budget” and “financials” are different words, but embeddings understand they’re related. That’s the foundation behind semantic search and one of the core building blocks of modern multimodal systems. Learn how embeddings power retrieval across text, audio, images, and video in Building Multimodal Data Pipelines: https://hubs.la/Q04hJ9w10

AI agents fail in unpredictable ways that traditional testing can't catch — hallucinations, wrong tool calls, policy violations, and more. Teams only discover these failures after users hit them in production. A simulation sandbox gives you a controlled environment with realistic users, tools, and workflows where you can run hundreds of scenarios against your agent before it ships, catching edge cases and adversarial inputs that would be impossible to test manually. This talk by Veris AI's Andi Partovi covers why simulation-driven development is becoming essential infrastructure for any team building production AI agents, and how it closes the gap between "works in demos" and "works at scale."

Modern enterprises don't struggle to experiment with AI — they struggle to operationalize it reliably. In this talk, CrewAI's CEO outlines how leading organizations are moving beyond one-off automations to build recurring, governed, and deeply embedded workflows that drive real business outcomes. Drawing on lessons from production deployments, João explores how to design systems that are auditable, scalable, and aligned with enterprise controls — without sacrificing speed.

From centralized to distributed: In the old world, organizations relied on one centralized data and AI platform. In the new world of AI agents, every agent needs its own sandboxed, secure, and modern data stack. In this 20-minute talk with live demo by Spice AI's Luke Kim, he explores why this architectural shift is critical and the key patterns required to give agents reliable, real-time data.

The next major shift in enterprise AI is underway; enterprises are moving from generic AI they rent to specialized AI they own. The benefits are clear: higher quality, dramatically lower costs, full control, and a quality improvement flywheel while in production. But building specialized AI models has been prohibitively hard; each use case requires months of effort and deep AI expertise. Well, it used to. VibeML is enabling engineers to build specialized AI models automatically from a prompt, in minutes. An AI agent builds your AI model end-to-end; evaluation, data synthesis, training and repeat. This talk by OUMI's Manos Koukoumidis & Stefan Webb demonstrates how VibeML can give deep AI experts superpowers while enabling non-experts as well.

At AI Dev 26 x San Francisco, Flower Lab's Daniel Beutel talked about Flower SuperGrid, the industry standard for Federated AI. With SuperGrid Agents, you can now build and run context-rich agents that learn from interactions, access sensitive data and (soon) collaborate with other SuperGrid Agents.

Most agentic systems rely on hardcoded heuristics to navigate execution decisions (e.g. which models, tools, and test-time compute scaling approaches to use) leading to efficiency leakage across cost, latency and accuracy. AI21 Maestro optimizes agents by learning to predict success, cost and latency probabilities across diverse actions and contexts, and driving runtime orchestration that intelligently navigates the full agentic action space. In this session, AI21's Or Dagan demonstrated how this approach yields state-of-the-art results and Pareto frontier on challenging agentic benchmarks, as well as the process required to optimize production agents.

In this talk by Zencoder's Andrew Filev, attendees learned how decomposing tasks into pipelines and dynamically routing them across models improves quality, reduces cost, and makes AI systems more reliable.

Building your first agent is exciting. Building a platform that can evolve into an office where dozens of teams can safely deploy their own agents is a different beast entirely. In this talk, Diamond Bishop from Datadog shared lessons learned building production agents, then turning this into an agent office/platform made to power the next-gen enterprise with diverse agent workloads.

More code, fewer staff — the industry is on a bender. But what about quality? At AI Dev 26 x San Francisco, Paul Everitt from JetBrains discussed the rise of agentic engineering and how old lessons can be adapted to build new professional practices.

What if your AI's memory was mathematically verifiable? What if every retrieval was provenance-backed, every result bit-exact and cryptographically reproducible? OnMemory.ai introduces deterministic semantic memory built on E8 lattice quantization, replacing probabilistic vector search with a multi-lane retrieval engine where every answer can be traced to its source. In this session, Andrew K. Davies demonstrated how deterministic memory transforms AI from systems that approximate recall into systems you can trust — because an AI that remembers with mathematical precision is an AI that cannot lie.