--- title: Where to find developer conference talks worth watching | daily.dev description: Find high-signal developer talks fast: pick the right conference, filter by topic/speaker/length, and use a simple watchlist. canonical: https://daily.dev/blog/where-to-find-developer-conference-talks/ og:type: article og:url: https://daily.dev/blog/where-to-find-developer-conference-talks/ og:title: Where to find developer conference talks worth watching | daily.dev og:description: Find high-signal developer talks fast: pick the right conference, filter by topic/speaker/length, and use a simple watchlist. og:image: https://media.daily.dev/image/upload/s--0ZHZc0dF--/f_auto,q_auto/v1/recruiter-landing/6ab5ced9c5072cdcadb5f7c2_1790302913350_a090372e82?_a=BAMAMiB80 og:site_name: daily.dev og:locale: en_US article:published_time: 2026-09-25 article:modified_time: 2026-09-25T02:51:21.119Z article:author: Alex Carter twitter:card: summary_large_image twitter:site: @dailydotdev twitter:creator: @dailydotdev twitter:title: Where to find developer conference talks worth watching | daily.dev twitter:description: Find high-signal developer talks fast: pick the right conference, filter by topic/speaker/length, and use a simple watchlist. twitter:image: https://media.daily.dev/image/upload/s--0ZHZc0dF--/f_auto,q_auto/v1/recruiter-landing/6ab5ced9c5072cdcadb5f7c2_1790302913350_a090372e82?_a=BAMAMiB80 --- **I’d start with official conference YouTube channels and one talk index, then filter by _topic_, _speaker_, and _length_.** That cuts through huge archives fast. As of **September 25, 2026**, **conf.directory lists 29,652 talks**, so browsing at random is a bad use of time. Here’s the short version: - I’d use **PyCon US**, **GopherCon**, and **RustConf** for language-specific talks - I’d use **KubeCon** for cloud and Kubernetes - I’d use **Strange Loop** and **Papers We Love** for theory and systems ideas that age well - I’d use **FOSDEM** when I already know the project or dev room I care about - I’d use **AI Engineer** only with a strict date filter because AI talks age fast, so I'd cross-reference them with [the best AI tools for developers](https://daily.dev/blog/the-best-ai-tools-for-developers-in-2024) Before I watch anything, I’d check for: - **Concrete titles** instead of vague ones - **Abstracts with tradeoffs, failures, metrics, or code** - **Slides or GitHub links** in the description - **Recent recording dates** for AI, security, cloud, async, and tooling topics - **Talk length around 20 to 45 minutes** for most deep sessions I’d also treat sponsor talks as **case studies**, not broad guidance. ::: @figure {Best Developer Conference Talks: Quick Comparison Guide 2026} ## Quick comparison | Source | Best for | Best filter | Main issue | | --- | --- | --- | --- | | **KubeCon + CloudNativeCon** | Kubernetes, cloud, DevOps | Project or track | Huge archive | | **PyCon US** | Python, data, AI tools | Year and abstract | Many sponsor sessions | | **GopherCon** | Go | Speaker and topic | Narrow scope | | **RustConf** | Rust, systems | Topic and speaker | Smaller archive | | **Strange Loop** | Systems, language ideas, architecture | Best-of lists | No new events after 2023 | | **FOSDEM** | Open source projects, kernels, systems | Dev room | Search can get messy | | **Papers We Love** | CS papers and system ideas | Paper title | More theory than shipping code | | **AI Engineer** | [LLM apps, agents, MLOps](https://daily.dev/blog/meta-llama-3-everything-you-need-to-know-in-one-place) | Newest uploads and employer | Gets old fast | If I had to make this even simpler, I’d do this: 1. Pick **one conference** that matches my stack 2. Search by **problem**, not playlist 3. Skip any talk that takes **more than five minutes** to get to the point 4. Write down the **problem, proof, version numbers, and next links** That’s the whole playbook in one page. ## How to judge a conference talk before watching Use these signals to turn a huge archive into a short watchlist. Start with the title. A concrete title like **"How we run Notebooks on Kubernetes"** usually signals hands-on depth. A vague title like **"Thinking in Platforms"** is more likely to lean toward big-picture opinions than practical takeaways. The strongest abstracts name specific technical details: benchmarks, architectural tradeoffs, or lessons from production failures. Skip abstracts that read like a press release. Phrases like **"every obvious approach failed"** are often a good sign the speaker is sharing lived operational experience instead of a polished win story. [\[1\]](https://conf.directory/talks)[\[3\]](https://confs.space/) After that, check the description for slides or code. Look for **supplemental materials** in the video description. Slides linked to [slidr.io](https://slidr.io) or a [GitHub](https://github.com) repo usually mean the speaker wanted the talk to be reusable. If there are no links, there are often fewer takeaways you can put to work right away. [\[4\]](https://conf.directory/) Recency matters most in fast-moving topics. For AI, cloud infrastructure, and application security, stick with talks from the current year or, at minimum, the year before. For core topics like memory models, garbage collection, or the JavaScript event loop, an older talk can still be worth your time. The table below gives a quick reference. [\[9\]](https://dev.to/techtalksweekly/tech-talks-weekly-106-5c7j) | Topic area | Recommended recency | When older talks still hold up | | --- | --- | --- | | AI / LLMs | Under 6 to 12 months | Mathematical foundations of neural networks | | Cloud / DevOps | Under 2 years | Architectural patterns and org scaling lessons | | Security | Under 1 year | Physical security and fundamental exploit theory | | Languages / Tools | Under 3 years | Core mechanics like GC, memory, and language philosophy | Sponsor-labeled talks often present one company’s answer to a specific enterprise problem. That doesn’t make them bad. It just means you should treat them like case studies, not neutral overviews. Use these filters on the conference list below. ## Quick comparison table This table gives you the fast version: where each conference lives, what it talks about, and the best way to find the strongest sessions without digging through hours of uploads. | Source | Primary Topics | Recording Location | Best Discovery Filter | Main Limitation | | --- | --- | --- | --- | --- | | **[KubeCon + CloudNativeCon](https://www.cncf.io/kubecon-cloudnativecon-events/)** | Cloud native, Kubernetes, DevOps | YouTube / CNCF Archive | Project tag | Huge archive [\[5\]](https://cotalks.dev/) | | **[PyCon US](https://us.pycon.org/)** | Python, data science, AI agents | YouTube | Year | Sponsor-heavy schedule [\[1\]](https://conf.directory/talks)[\[7\]](https://conf.directory/year/2026) | | **[GopherCon](https://www.gophercon.com/)** | Go (Golang) | YouTube | Speaker | Narrow focus on a single language | | **[RustConf](https://rustconf.com/)** | Rust, systems programming | YouTube | Topic | Smaller archive than Python or Go | | **[Strange Loop](https://www.thestrangeloop.com/)** | Distributed systems, CS theory | YouTube | Best-of collections | Historical archive only [\[4\]](https://conf.directory/)[\[6\]](https://github.com/sean-beard/conference-videos) | | **[FOSDEM](https://fosdem.org/)** | Open source, systems, kernel | FOSDEM Archive / YouTube | Track | Less polished production [\[3\]](https://confs.space/) | | **[Papers We Love](https://paperswelove.org/)** | CS research, distributed systems | YouTube | Paper title or topic | Highly academic and theoretical | | **[AI Engineer](https://www.ai.engineer/)** | LLMs, AI agents, MLOps | YouTube | Tag | Fast-moving field makes older talks obsolete quickly [\[3\]](https://confs.space/)[\[5\]](https://cotalks.dev/) | A couple of shortcuts make this easier. KubeCon is the toughest archive to scan, so **project tags** are usually the fastest way in. AI talks go stale the fastest, so it makes sense to sort by **newest uploads** first. Use the table to choose one archive, then jump to the matching conference below. ## 1\. [KubeCon](https://www.cncf.io/kubecon-cloudnativecon-events/) + CloudNativeCon KubeCon is the biggest archive on this list, so it helps to narrow things down before you start browsing. The [Cloud Native Computing Foundation (CNCF)](https://www.cncf.io/) sorts KubeCon + CloudNativeCon recordings by region and year [\[5\]](https://cotalks.dev/). Start with the track or topic filters first. It’s also smart to check the co-located events if you want narrower, higher-signal talks. These smaller tracks often include the most practical sessions. Events like [KyvernoCon](https://kyverno.io/) Virtual and [EnvoyCon](https://events.linuxfoundation.org/envoycon/) Virtual focus on specific projects instead of the [cloud-native space](https://daily.dev/blog/cloud-native-basics-for-developers), so they’re worth a look if you work with a certain tool or service mesh [\[5\]](https://cotalks.dev/). When you’re picking talks, put extra weight on sessions from operators running Kubernetes at scale. The best ones usually include failures, metrics, and clear lessons instead of polished success stories. Boyan Dimitrov's "10 years of platform engineering at SIXT" is a good example of that kind of long-view retrospective [\[3\]](https://confs.space/). For version-sensitive topics like Kubernetes releases, service meshes, and admission controllers, stick with this year’s talks so the APIs and examples stay current. After that, use format as another filter: - **Lightning talks** for quick tool overviews - **Keynotes** for trends and roadmaps - **Deep dives** for project internals [\[7\]](https://conf.directory/year/2026) ## 2\. [PyCon US](https://us.pycon.org/) For PyCon US, the fastest way to shortlist talks is to look for **concrete abstracts** and **recent Python versions**. [PyCon US](https://us.pycon.org/) recordings are on its [YouTube channel](https://www.youtube.com/@PyConUS), and [conf.directory](https://conf.directory/) plus [tech-confs.com](https://tech-confs.com/) are the best places to start when you want to filter by speaker, duration, and topic tags [\[2\]](https://tech-confs.com/)[\[4\]](https://conf.directory/). Titles with phrases like **"from scratch"** or **"inside"** often point to implementation-heavy material. That kind of wording usually means you’ll get code, internals, and the nuts and bolts instead of a high-level overview. A good example is Arie Bovenberg's 26-minute session **"Taking Generators Too Far: Writing a PDF from Scratch in Python"**, which is a clear deep dive into core Python primitives [\[4\]](https://conf.directory/). Once a talk looks implementation-heavy, do one more check: is it a general Python talk, or is it a sponsor case study? Talks like **"Pydantic Monty: Wild LLMs, from tool calling to computer use"** (Sponsor: Pydantic) can still be useful, but they usually lean more toward tool-specific or company-specific context than broad Python patterns [\[1\]](https://conf.directory/talks). It’s better to treat sponsor sessions as case studies, not general Python guidance. Give extra weight to speakers who talk about real production Python work, especially scale, migrations, or failure modes. After speaker fit, the next filter is version relevance. For packaging, typing, and async talks, stick with the newest cycle when you can, and verify Python 3.13 or Pydantic v2 details against current release notes. ## 3\. [GopherCon](https://www.gophercon.com/) If you write Go, GopherCon is one of the best places to start. It’s also one of the highest-signal archives for Go talks. [GopherCon](https://www.gophercon.com/) publishes recordings on its [YouTube channel](https://www.youtube.com/@GopherAcademy) after each event[\[6\]](https://github.com/sean-beard/conference-videos). For older sessions, use [dev.tube](https://dev.tube/), which makes things easier with speaker and tag filters. If you want 2026 talks, [conf.directory](https://conf.directory/) and [cotalks.dev](https://cotalks.dev/) are good places to search by year and topic[\[5\]](https://cotalks.dev/)[\[7\]](https://conf.directory/year/2026). Once you have the recordings, don’t just click the flashiest title. Go straight to talks with concrete production details. Focus on sessions about distributed systems, software architecture, and platform engineering[\[4\]](https://conf.directory/). On [tech-confs.com](https://tech-confs.com/), you can combine the Golang tag with those topics and sort by duration to bring up deeper sessions[\[2\]](https://tech-confs.com/). After that, the speaker’s track record matters a lot. Put more weight on speakers who have shipped Go systems at scale. That usually shows up in the talk: fewer vague ideas, more hard-earned lessons. Recency also matters more in Go than many people expect. Go has a six-month release cycle, so older talks can miss major changes in runtime behavior, modules, tooling, performance, and language features. A talk recorded before Go 1.18 won’t cover generics, and one from before Go 1.22 won’t include `math/rand/v2`[\[5\]](https://cotalks.dev/). ## 4\. [RustConf](https://rustconf.com/) [RustConf](https://rustconf.com/) recordings live on YouTube, and you can browse them through [confs.space](https://confs.space/), [conf.directory](https://conf.directory/), and [cotalks.dev](https://cotalks.dev/). Each one lets you filter by language and year, which makes the search a lot less messy [\[1\]](https://conf.directory/talks)[\[3\]](https://confs.space/)[\[5\]](https://cotalks.dev/). If you want a shorter path to the good stuff, conf.directory keeps a **"Best Rust Talks"** collection that helps screen out weaker recordings [\[4\]](https://conf.directory/). After that, the fastest move is to lean on topic and speaker filters. The September 2025 archive is a strong place to start if you're after systems programming, safety-critical infrastructure, and high-performance interprocess communication [\[3\]](https://confs.space/). The strongest RustConf talks tend to stick to **one concrete systems problem** instead of trying to cover Rust as a whole. Christian Eltzschig's _"Breaking language barriers: High-performance IPC with iceoryx2"_ digs into zero-copy communication and cross-language integration at the systems level. Guillaume Binet's _"Bridging robotics and systems programming: Why Copper is a game changer"_ shows Rust in real-time hardware settings [\[3\]](https://confs.space/). When you're scanning abstracts, look for signs that the talk is about something specific: - A named system, crate, or runtime - A clear performance limit or engineering constraint - A narrow problem the speaker is trying to solve If the session is framed as a general language intro, it's usually not the best use of time [\[3\]](https://confs.space/). It's also worth checking whether the speaker actually worked on the project or in the domain they're covering. [dev.tube](https://dev.tube/) and conf.directory both show speaker track record, so this is easy to verify [\[4\]](https://conf.directory/)[\[8\]](https://hackernoon.com/find-thousands-of-developer-talks-organized-in-dev-tube-a136396fe0fc). Once a talk looks technical enough, make sure the runtime or crate details still line up with the current Rust ecosystem. This matters most for async, compiler, and crate-specific talks. Compare the recording date with current Rust release notes on the [official Rust Blog](https://blog.rust-lang.org/). A talk recorded before a major stabilization can point you toward an approach that's already been replaced. On [tech-confs.com](https://tech-confs.com/), sort Rust talks by duration to surface 30-minute-plus deep dives and skip short sponsor talks [\[2\]](https://tech-confs.com/). ## 5\. [Strange Loop](https://www.thestrangeloop.com/index.html) For evergreen, theory-heavy talks, not day-to-day tooling updates, [Strange Loop](https://www.thestrangeloop.com/) is one of the best archives here. Its [YouTube channel](https://www.youtube.com/@StrangeLoopConf) hosted its final conference in 2023, so what you have now is a fixed but carefully selected library centered on programming languages, distributed systems, software architecture, and functional programming [\[6\]](https://github.com/sean-beard/conference-videos). If you want talks on language theory, consistency, and architecture that still hold up years later, this is a good place to spend time. Strange Loop was language-agnostic, which is part of what made it so useful. You can move from Clojure to Rust to Elixir to Scala to type theory without feeling like the conference was pushing one camp over another [\[6\]](https://github.com/sean-beard/conference-videos). That mix matters. It lets you compare ideas across ecosystems instead of getting stuck in one lane. Rich Hickey's talks, including _Simple Made Easy_ and _The Language of the System_, are a strong place to start if you want evergreen engineering ideas with real depth [\[6\]](https://github.com/sean-beard/conference-videos). When you scan abstracts, skip the vague ones. Look for talks built around a clear tradeoff, a theory limit, or a hard operations problem. If a title seems good, check the speaker and the description to see whether the talk goes deep or just sounds smart. In most cases, the best sessions come from people who built or maintain the system they're talking about. A nice bonus: many Strange Loop recordings link straight to [Slidr.io](https://slidr.io/) or the speaker's own repo in the YouTube description, which makes dense technical material much easier to follow [\[4\]](https://conf.directory/). [dev.tube](https://dev.tube/) can also help you find other sessions by the same speaker, and that's a fast way to judge signal density [\[8\]](https://hackernoon.com/find-thousands-of-developer-talks-organized-in-dev-tube-a136396fe0fc). If you want a shortcut, [conf.directory](https://conf.directory/) pulls together collections like Best Distributed Systems Talks and Software Architecture, so you can jump right into strong sessions [\[4\]](https://conf.directory/). ## 6\. [FOSDEM](https://fosdem.org/) FOSDEM works best when you already know the part of the ecosystem you want to follow. The main way to find talks is through **topic-specific dev rooms**, so skip the full program and head straight to the dev room that fits your [tech stack](https://daily.dev/blog/ive-made-up-my-mind-i-know-how-to-choose-my-next-tech-stack). Recordings are available in the official archive and on YouTube. If a dev room still feels too broad, use outside filters to narrow things down. That’s the weak spot here: discovery can get messy fast. Start with the right dev room, then trim the list. [conf.directory](https://conf.directory/) helps you narrow the archive fast. [tech-confs.com](https://tech-confs.com/) adds filters for speaker, language, tags, and duration [\[2\]](https://tech-confs.com/), so you can cut the list down before you watch. Then open only the sessions that match your stack. ## 7\. [Papers We Love](https://paperswelove.org/) Talks live on the official [Papers We Love](https://paperswelove.org/) YouTube channel. They focus on the papers behind modern systems. Use Papers We Love to learn **why** a system works, not how to ship it. If you know the speaker or event, [tech-confs.com](https://tech-confs.com/) can help you narrow the archive fast. Unlike tool-focused talks, PWL tends to stay useful longer because the paper matters more than the release cycle. It’s at its best for core ideas, not fast-moving production issues. ## 8\. [AI Engineer](https://www.ai.engineer/) Recordings from AI Engineer conferences mostly live on the [AI Engineer YouTube channel](https://www.youtube.com/@aiDotEngineer). You can also find hand-picked collections on [conf.directory](https://conf.directory/) and [confs.space](https://confs.space/). The focus here is applied AI and LLM engineering, not research. So if you're building systems, this is usually a better fit than if you're doing research. And the fastest way to find high-signal talks is simple: check who the speaker works for. Speaker employer is a strong filter. Talks from engineers at [Anthropic](https://www.anthropic.com/), [Hugging Face](https://huggingface.co/), Google, Meta, and [Stripe](https://stripe.com/) are often closer to production work. At AI Engineer Europe in May 2026, Chris Ruiz from [Stripe](https://stripe.com/) showed how the company uses Claude Code-based agents to handle multi-step migrations inside a large enterprise monorepo [\[9\]](https://dev.to/techtalksweekly/tech-talks-weekly-106-5c7j). That's the kind of session worth moving to the top of your list. Session format matters too. Keynotes are good for strategy, but talks labeled **"from scratch"** or **"inside the SDK"** usually get deeper into the technical details. Lightning talks and technical sessions on agent infrastructure, MCP, or tool calling are also good places to start. After that, make sure the implementation still lines up with the current SDK or model release. That last part matters more than it might seem. A talk from six months ago can already show API patterns that are out of date. Brandon Walsenuk from Unblocked put it plainly at AI Engineer Europe 2026: > "The problem isn't access but understanding: a context engine reasons across your codebase, Slack history, PR patterns and org structure." [\[9\]](https://dev.to/techtalksweekly/tech-talks-weekly-106-5c7j) Before you use anything from an AI Engineer talk, check the repo's latest release tag. Then scan for breaking changes or migration guides posted after the recording date. ## How to find good talks without watching everything Use conference lists as your starting point. Then narrow things down by **problem**, **length**, and **speaker fit**. The list above includes eight conferences, but you don't need to watch all of them. In most cases, it's better to pick **two or three** that line up with what you're working on right now and go deeper there instead of skimming everything. Match the conference to the kind of problem you're trying to solve. If you're debugging something language-specific, head straight to **PyCon**, **GopherCon**, or **RustConf**. If you're dealing with architecture work, like platform design or distributed systems, **Strange Loop** or **KubeCon** make more sense. For cloud infrastructure, **KubeCon** is the clear first stop. Once you know the problem type, use the right archive instead of bouncing around every playlist. [conf.directory](https://conf.directory/) and [tech-confs.com](https://tech-confs.com/) both have focused indexes with filters for tags, speaker, duration, and language. That means you can search for a concrete technical issue instead of clicking through random talk titles.[\[1\]](https://conf.directory/talks)[\[2\]](https://tech-confs.com/) Talk length is a strong signal. Sessions in the **20 to 45 minute** range often hit the sweet spot. Keynotes over **60 minutes** usually lean toward roadmaps. Talks under **25 minutes** often work better for demos than deep technical walkthroughs. So after you search, open only the talks that fit the query and the format you're after. Then do a simple gut check in the first five minutes. A strong talk gets to the problem and the approach fast. If the speaker is still setting up context after five minutes, skip it. Search by problem, not by playlist. Use terms like **"HTTP/3 latency"** or **"async database client Python"** instead of browsing broad conference feeds. ## A simple watchlist template Use this after you've narrowed down talks by topic, length, and speaker. Before you hit play, paste these five prompts into your notes app. | Prompt | What to capture | | --- | --- | | **Problem** | The exact technical or team challenge the speaker is trying to solve | | **Evidence** | Hard metrics, case studies, or live demos that support the fix | | **Freshness** | The tech versions mentioned and whether they still make sense in 2026 | | **Follow-up** | Repos, docs, protocols, or speakers worth checking after the talk | | **Transferability** | How the lesson fits your current project or team setup | Use the table as a quick filter, then fill it out as you watch. For **Evidence**, grab one number or result. Write down at least one concrete metric, outcome, or demo. If you can't find one, skip the talk. A session with measured results, like a **51% [reduction in connection handshake latency](https://daily.dev/blog/10-proven-techniques-to-reduce-latency-in-software)** from DeliveryHero's HTTP/3 rollout across **18 markets**, is a very different use of your time than a talk that only walks through theory [\[9\]](https://dev.to/techtalksweekly/tech-talks-weekly-106-5c7j). For **Freshness**, compare the versions mentioned with your own stack. If a speaker calls out version numbers like **JDK 25**, **Spring Boot 4**, or **Kotlin 2.4**, that gives you a fast way to judge whether the material still lines up with what you're using [\[9\]](https://dev.to/techtalksweekly/tech-talks-weekly-106-5c7j). For **Transferability**, write one sentence about how you'd use the idea. A Netflix talk on Java AOT startup time using Project Leyden [\[9\]](https://dev.to/techtalksweekly/tech-talks-weekly-106-5c7j) may not map straight onto your codebase. But the pattern behind it, AOT compilation for autoscaling, still might. If you can't write that one sentence, it's probably time to move on. ## Conclusion The best talks usually come from **the right conference first**, then from a pretty tough filter: _Does this match your stack?_ and _Does it show concrete evidence?_ Those are the two strongest signals. If you still end up with too many options, use the FAQ below to trim your next watchlist. Start small. If you write Python, begin with **PyCon US**. If you work in Go, **GopherCon** should be your first stop. After you’ve covered your main language, branch into language-agnostic events like **Strange Loop** for broader engineering ideas. Stick with the same filters from the watchlist template so your shortlist doesn’t get out of hand. Concrete evidence is the clearest signal. Look for talks that show real implementation details, lessons learned, or internal architecture. And be careful with titles built around vague promises like “the future of” or “the era of.” Those can sound exciting, but they often tell you less than you’d hope. The watchlist template speeds up the filtering process by focusing on four core checks: **problem, evidence, freshness, and transferability**. [daily.dev](https://daily.dev) can help surface talk ideas fast, but it works best when you already know which problem you’re trying to solve. The FAQ below covers the fastest next steps. ## FAQ ### Are older conference talks still worth watching in 2026? If you want the short version: **the topic matters more than the age**. Yes, older talks can still be worth your time. Talks on architecture, distributed systems, and language mechanics often hold up well. Those subjects change more slowly, so the ideas tend to stick. In plain English, _evergreen topics_ usually age better than talks tied to one product release or framework update. ### How do you tell if a talk is too outdated for 2026? A simple test helps here: is the talk teaching a concept, or is it walking through one tool version? Concept-driven talks usually hold up. Version-specific talks usually don't. AI and frontend content shifts the fastest, so newer recordings are often the safer bet. Architecture and distributed systems are different. In those areas, talks from five or even ten years ago can still be **must-watch material**. ### Which conferences work best for beginners or advanced engineers? Different skill levels usually need different conference picks. For beginners, **PyCon US** and **GopherCon** are good starting points. For deeper systems work, look at **Strange Loop** and **KubeCon**. The titles can also tell you a lot. Beginner-friendly talks often include phrases like: - _Learning_ - _Intro to_ More advanced sessions often use terms like: - _Scaling_ - _Tradeoffs_ - _Architecture_ ### Where are AI engineering talks most useful in 2026? [AI Engineer](https://www.ai.engineer/) is a strong place to find practical AI systems talks. **PyCon US 2026** also had a strong AI track, including sessions on AI Agent SDKs and LLM tool calling [\[1\]](https://conf.directory/talks)[\[7\]](https://conf.directory/year/2026). For AI content, it's smart to put the newest recordings at the top of your list. ### Is there a faster way to find high-quality talks without browsing everything? Yes. When an archive feels huge, stick with the same three filters from this guide: **speaker, topic, and duration**. Start with the speaker's name. That works well on [conf.directory](https://conf.directory/) and [dev.tube](https://dev.tube/). Then add a duration filter of **45 minutes or longer**. That tends to bring up deeper technical sessions instead of short sponsor spots or sales-heavy talks. ```json {"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/og-image.png?v=a830cdf1","width":1200,"height":630},"sameAs":["https://twitter.com/dailydotdev","https://www.linkedin.com/company/dailydotdev","https://github.com/dailydotdev","https://www.instagram.com/dailydotdev"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","description":"Free, personalized developer news aggregator. Stay on top of software development news, AI coding tools, and web dev - curated daily from trusted sources.","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}},{"@type":"WebPage","@id":"https://daily.dev/blog/where-to-find-developer-conference-talks/","url":"https://daily.dev/blog/where-to-find-developer-conference-talks/","name":"Where to find developer conference talks worth watching | daily.dev","description":"Find high-signal developer talks fast: pick the right conference, filter by topic/speaker/length, and use a simple watchlist.","inLanguage":"en-US","isPartOf":{"@id":"https://daily.dev/#website"},"timeRequired":"PT16M"},{"@type":"Article","@id":"https://daily.dev/blog/where-to-find-developer-conference-talks/#article","headline":"Where to find developer conference talks worth watching","url":"https://daily.dev/blog/where-to-find-developer-conference-talks/","datePublished":"2026-09-25","dateModified":"2026-09-25T02:51:21.119Z","isPartOf":{"@id":"https://daily.dev/#website"},"publisher":{"@id":"https://daily.dev/#organization"},"mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/blog/where-to-find-developer-conference-talks/"},"description":"Find high-signal developer talks fast: pick the right conference, filter by topic/speaker/length, and use a simple watchlist.","image":{"@type":"ImageObject","url":"https://media.daily.dev/image/upload/s--0ZHZc0dF--/f_auto,q_auto/v1/recruiter-landing/6ab5ced9c5072cdcadb5f7c2_1790302913350_a090372e82?_a=BAMAMiB80"},"author":{"@type":"Person","name":"Alex Carter","url":"https://app.daily.dev/alexcarterdev"},"timeRequired":"PT16M","potentialAction":{"@type":"ReadAction","target":"https://daily.dev/blog/where-to-find-developer-conference-talks/"}},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev/"},{"@type":"ListItem","position":2,"name":"Blog","item":"https://daily.dev/blog/"},{"@type":"ListItem","position":3,"name":"Trends","item":"https://daily.dev/categories/trends/"},{"@type":"ListItem","position":4,"name":"Where to find developer conference talks worth watching","item":"https://daily.dev/blog/where-to-find-developer-conference-talks/"}]},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Are older conference talks still worth watching in 2026?","acceptedAnswer":{"@type":"Answer","text":"If you want the short version: the topic matters more than the age. Yes, older talks can still be worth your time.\n\nTalks on architecture, distributed systems, and language mechanics often hold up well. Those subjects change more slowly, so the ideas tend to stick. In plain English, evergreen topics usually age better than talks tied to one product release or framework update."}},{"@type":"Question","name":"How do you tell if a talk is too outdated for 2026?","acceptedAnswer":{"@type":"Answer","text":"A simple test helps here: is the talk teaching a concept, or is it walking through one tool version?\n\nConcept-driven talks usually hold up. Version-specific talks usually don't.\n\nAI and frontend content shifts the fastest, so newer recordings are often the safer bet. Architecture and distributed systems are different. In those areas, talks from five or even ten years ago can still be must-watch material."}},{"@type":"Question","name":"Which conferences work best for beginners or advanced engineers?","acceptedAnswer":{"@type":"Answer","text":"Different skill levels usually need different conference picks.\n\nFor beginners, PyCon US and GopherCon are good starting points. For deeper systems work, look at Strange Loop and KubeCon.\n\nThe titles can also tell you a lot. Beginner-friendly talks often include phrases like:\n\nLearning\nIntro to\n\nMore advanced sessions often use terms like:\n\nScaling\nTradeoffs\nArchitecture"}},{"@type":"Question","name":"Where are AI engineering talks most useful in 2026?","acceptedAnswer":{"@type":"Answer","text":"AI Engineer is a strong place to find practical AI systems talks.\n\nPyCon US 2026 also had a strong AI track, including sessions on AI Agent SDKs and LLM tool calling [\\[1\\]](https://conf.directory/talks)[\\[7\\]](https://conf.directory/year/2026). For AI content, it's smart to put the newest recordings at the top of your list."}},{"@type":"Question","name":"Is there a faster way to find high-quality talks without browsing everything?","acceptedAnswer":{"@type":"Answer","text":"Yes. When an archive feels huge, stick with the same three filters from this guide: speaker, topic, and duration.\n\nStart with the speaker's name. That works well on conf.directory and dev.tube. Then add a duration filter of 45 minutes or longer. That tends to bring up deeper technical sessions instead of short sponsor spots or sales-heavy talks."}}],"@id":"https://daily.dev/blog/where-to-find-developer-conference-talks/#faq","mainEntityOfPage":{"@id":"https://daily.dev/blog/where-to-find-developer-conference-talks/"}}]} ```