What if you could run powerful AI without sending your code and data to someone else’s cloud - or worrying about token limits, subscriptions, or vendor lock-in? Local LLMs put the model on hardware you control, giving you greater privacy, unlimited usage, and the freedom to choose and customize your own models. In this talk, we’ll explore how local AI works, what hardware you need, and what tools that you can use to turn your own computer into a powerful AI development environment.

Five years ago, in Python 3.10, PEP 634 was added to the language giving Python a standard way to do multi-dispatch with the syntax 

'''

match var:

    case pattern:

    ...

'''

At the time it was considered quite controversial since it was felt that the syntax was just a fancy way to express if-elif-else statements.  Over the intervening years it has come to be accepted as a way to show the intent of a block of code.  When used it is an element that processes a series of inputs and based on pattern matches does specialized work or updates the program state. 

This talk will explore the variety of pattern matching that can be done leading to a powerful expression that can be the organizing motif for program expression in some cases.

A look inside of the pip-tools project!

I'll introduce myself and share how I came to be a current maintainer, and give some quick background on pip-tools' history. We'll then dive in to what it means to maintain this package today, and what its role is in the ecosystem.

Finally, we'll look at the fact that pip-tools has long used pip's internals, and how that can help us think about internal APIs and boundaries between components.

# Docstrings as a Database

## Building a Documentation Pipeline with Python & 11ty

### Elevator Pitch

A contract renewal is coming. Your team has built a complex system over years, but the people who need to understand its value - subject-matter experts, product folks, the client - don't read code. Swagger/OpenAPI tells them what the API accepts and returns, but not what the system does or why.

This talk is the story of how I built a documentation site that solved that problem: a local-first, portable doc site that treats Python docstrings as a database of business logic.

### What You'll Learn

- How to extract structured data from Python docstrings using `griffe` and `docstring-parser`
- Why a Python → JSON → 11ty pipeline decouples data from presentation and keeps templates lean
- How to build a hard validation guardrail - if docs are incomplete, the site doesn't build
- How persona-based information architecture serves both SMEs (process maps) and developers (API references) from the same data
- How a local-first approach bypasses bureaucratic hosting approvals entirely

### Who This Is For

Python developers who have ever wished their docstrings did more than sit in an editor. Developers working on government or regulated projects where hosting approvals are a bottleneck. Anyone who's watched knowledge walk out the door when a contract ends.

No prior experience with 11ty, griffe, or static site generators needed.

### About the Speaker

I'm a developer currently working on public health data modernization projects. I contribute to and builds tools that help teams document what they know before they forget it. You can find him at `hi@rog.gr` or `@rogeruiz` on most platforms.

There are many types of programs and programming, especially when we care about time. What are they and how do we harmonize between them? We'll explore these taxonomies and how to piece them together. 

This is a talk about making a Jupyter client for the Apple Vision Pro targeting the VisionOS operating system. It has largely been implemented in Swift but there is also an extended Jupyter server to manage 3D models, Gaussian Splats and Point Cloud data. It has been vibe coded a great part of the implementation will be discussed.

• Apple Human Interface Guidelines (for the Vision Pro)
• Complying with App Store policies (what can be done on devices)
• Interfacing with Jupyter Remotely
• Rendering custom cells.

Transcribing a few audio files with Whisper is easy. Transcribing millions of recordings efficiently, reliably, and cost-effectively is a very different problem.

In this talk, I'll dive into the Python code and infrastructure behind a large-scale speech transcription platform built for the insurance industry. Starting from a notebook prototype, we'll explore how the system evolved into a distributed inference pipeline running across thousands of GPU workers.

Rather than focusing on machine learning theory, we'll focus on inference engineering: benchmarking CPU and GPU workloads, maximizing throughput, orchestrating jobs with Azure Machine Learning, handling spot-instance interruptions, and writing resilient Python code that can recover from failures and resume processing automatically.

Along the way, I'll share benchmark results, architecture decisions, code examples, and the lessons learned while processing millions of real-world recordings.

If you're interested in Python, distributed systems, performance optimization, or production machine learning infrastructure, this talk will show what happens after the model is trained.

Mini Shai Hulud is self-propagating malware that steals credentials from developer machines and CI/CD pipelines.  It was first reported infecting npm packages in 2025, but as of May 2026, it has spread to PyPI.  This talk will cover how Shai Hulud works and some of the mitigation strategies discussed at PyCon. 

Everyone has this deep rooted existential fear that AI are taking software developers / engineers jobs. Not only that epistologically when we write code with AI or when working with others they may introduce deficiencies, regressions and problems with readability of committed code.  

We will address these fears and problems with going through techniques on writing a AGENTS.md file and other similar files like CLAUDE.md . These are guides for agents that work with your code and it introduces rules on how your code should be treated when you are working on them and you can even commit these files to any code repo and other people who use things like codex and claude code can read them. These can be used to perform tests before regressions exist and undo them, look for bugs and security holes and even enforce style rules in your code and applications. Last we will go over ways to generate diagrams

https://agents.md

At SREcon 2026, I showed how untyped infrastructure configs fail silently and how dimensional analysis catches those failures at definition time. But catching errors in human-written configs is only half the story. AI agents are now generating configs, writing IaC, computing dosages, and scaling parameters autonomously. They make the same unit mistakes humans do, faster and more confidently.

This talk extends the SREcon argument into agentic territory. I’ll show how ucon’s MCP server turns dimensional analysis into a verification primitive that any AI agent can call not as a unit converter, but as an algebraic safety net. I'll walk through real agent workflows where structured error responses (dimensional vectors, got/expected pairs, likely-fix hints) enable a model to self-correct in a single retry, and demonstrate how kind-of-quantity enforcement catches errors that no existing unit library can even represent. The core claim: small models paired with algebraic verification outperform large models without it and the infrastructure to prove that should be a tool call, not a training objective.