Schedule

What if you had your own npm registry, your own GitHub, your own cron system, your own email address, and your own database? And what if your favorite AI assistant could build software with all of it on your behalf?That's Kody: a personal assistant platform where every user gets a fully isolated software ecosystem. Your AI writes packages into your own git repos, publishes them to your personal package registry with real versioned imports, schedules your jobs, runs your long-lived services and workflows, receives email at your own address, and stores everything in storage only you can touch.I built this entirely on Cloudflare, because Cloudflare is the only place it could be built. This is a technical deep dive into what happens when you take the newest parts of the developer platform to their limits: sandboxing AI-authored user code with Worker Loaders, per-user git hosting with Artifacts, modeling "one of everything per user" with namespaced Durable Objects, and composing D1, KV, R2, Vectorize, Queues, Workflows, and Email Routing into a true multi-tenant platform.

Tell an AI agent “Forbidden,” and instead of stopping, it finds a workaround: scaling services down to zero, deleting resources in smaller batches, and even changing its identity to get a fresh quota.Now imagine giving that same agent a clearer message: “You’ve reached your limit. This action affects 212 resources. Try again in 59 minutes, or ask a human for approval.”Suddenly, it behaves differently. It stops, considers the potential damage, and asks for help instead of finding a way around the rules.This talk explores how we can design safety boundaries that AI agents actually understand and respect.

"AI writes slop" is a common concern. So how can we use LLMs to not just generate good code, but to *ensure* quality? Let's explore how to create effective "guardrails". After this session you'll have a list of novel ideas for improving the quality of your LLM's output.

Writing code is only one part of delivering software. An agentic development loop begins with the intent behind a change and continues until its impact can be observed in production.That means understanding the product and the existing system, deciding what should change, implementing it across shared and platform-specific layers, verifying the result in the running application, releasing it safely, and learning from how the software behaves after deployment. Each step should produce context for the next one.Cross-platform products make this especially difficult. A change that looks correct in the repository can still fail at the boundary between JavaScript and native code, behave differently across platforms, or create problems that only become visible after release.This talk examines what it takes to close the full ADLC loop across mobile, web, and native.

"I panicked instead of thinking. I destroyed months of your work in seconds." That was a Replit agent after wiping a production database during a code freeze.We’ve entered the "YOLO" era of agentic development. Between July 2025 and early 2026, we saw everything from Claude Code sessions destroying years of student data to supply chain attacks stealing thousands of developer secrets via --dangerously-skip-permissions. Developers are choosing autonomy over security because approving 100 permission prompts an hour isn't a workflow—it’s babysitting.This talk explores why traditional container isolation fails AI agents and how the Docker Sandbox (sbx) model provides a way out.

Coding agents like Claude Code barely write bad code anymore. They write good code that misses the point. The failure moved from code time, where the agent couldn't write the function, to intent time, where it wrote a perfectly fine function for a task that wasn't quite the one in your head. That's misalignment, not incompetence.Our reflex is more review, more tests, more guardrails.

Autonomous agents are exciting, but not always the right solution. When we build our agent system to migrate complex legacy PDF forms to structured business workflows, an autonomous agent seemed to be the obvious choice.Except it wasn’t. The system outputs were inconsistent, difficult to validate, hard for users to trust, and expensive. To fix this, we redesigned the system around deterministic workflows, using AI only where it adds clear value.In this session, I'll walk through the architectural evolution of our PDF-to-Workflow AI system, the lessons learned from what failed, how it helped to reduce migration time by 90% and the engineering tradeoffs that led us to a more reliable production-ready architecture framework.You'll leave with practical patterns for designing trustworthy AI systems, understanding when deterministic workflows outperform autonomous agents, and building AI products that users are willing to adopt.

Every CI vendor now ships auto-fix: a job goes red, an agent patches it, reruns, pushes to your PR. That was the easy part.The hard part is what else the agent can change while it's in there. To the agent, a test file and the workflow file are the same push. Nothing in most setups knows the difference.There's a line between fixing the build and owning the pipeline.

Every MCP tutorial puts the server on a server. They don't have to. If your app already has the data, the auth, and the UI state, why are you copying it to a backend just so an agent can reach it? The future of the web is agentic, and it belongs to the client side.In this talk, I will show how the Prompt API and WebMCP enable a different architecture: the page exposes its own tools, an on-device model discovers and invokes them autonomously.

Back in mid-2024, my college roommate kept telling me to try Cursor and I kept saying no. Why would I spend longer coaxing three prompts out of a bot than just writing the code myself? And here's the thing: I was right. For about a quarter.But this isn't really a story about tools.

AI coding assistants are great at completing small tasks or features. But what do you do when you're working with more complex codebases and need to build in-depth features that require upfront planning?This talk makes the case for spec-driven development. I'll show how AI coding assistants can help break down complex tasks into three phases. We'll go from requirements gathering to technical design to task implementation.

AI can generate UI. But it rarely generates the UI your design system would approve.The issue isn’t capability — it’s missing structure.Design systems today are optimized for humans: tokens, components, documentation, and guidelines. But the knowledge that governs product logic, accessibility constraints, and brand intent lives in scattered places, invisible to machines.This talk introduces metadata as a semantic intelligence layer for frontend systems.I’ll show how an auto-synced metadata architecture — powered by extractors and webhooks — continuously transforms codebases and design assets into structured knowledge consumable by MCP (Model Context Protocol) and LLMs.We’ll explore the four knowledge layers required to make design systems machine-readable, why intent and context must be treated differently, and how this shift enables constraint-aware, accurate AI-generated UI.Through a live end-to-end demo, you’ll see how structured metadata flows into MCP, delivers intent-based context, and produces reliable UI output.We’ve spent years perfecting design systems for people.This session explores what changes when we build them for machines.

Getting a coding agent to produce a diff is easy. Deciding when that diff deserves a pull request is the engineering problem.This talk follows one issue through a real coding-agent workflow. We inspect the trace at the first meaningful divergence, then add only the controls that the observed failure justifies: agent-legible context, a checkable completion contract, independent verification, and action boundaries. The comparison becomes a practical framework for sizing the harness to the task: when instructions and tests are enough, when a separate evaluator or sandbox earns its cost, and when a human checkpoint should remain.

In test code the worst failure is silent: a test that passes for the wrong reason certifies a broken GPU driver, and nothing alarms. I maintain the Khronos Vulkan Conformance Test Suite and use AI coding agents in that work daily. This talk is how I keep it reliable: I grade every agent result against a human-reviewed solution, so I can measure it instead of trusting it, and I show the anti-patterns that quietly ship a broken test.

We write skills for our coding agents, then we forget about them. Six months later the skill is stale and the agent makes the same mistakes it made in March. Karpathy calls this the agent's amnesia: it doesn't get smarter by default. So don't wait for it to.I built a loop that trains the skill file itself.

Design-to-code used to be a one-way handoff: designers supplied intent and developers translated it into production. AI coding agents are changing that relationship. Developers can now give agents structured context from Figma, turn it into working interfaces, and bring code-generated results back to an editable canvas for review and iteration. In this demo-led talk, Riccardo Erra explores how the Figma MCP server connects these steps, where human judgment still matters, and the practical patterns teams can use as design and code move closer together in 2027.

AI can review a Git diff in seconds, but reviewing a few changed lines is very different from understanding the impact of a change across a real codebase. In this talk, I’ll share a hands-on case study of building an agentic code reviewer for a real application using Cursor CLI. I’ll show how we moved from simple diff-based reviews to a system that builds context from the codebase, understands relationships between files, learns project conventions, and continuously reviews changes as developers work.

"It costs too much" is one of the most common things I hear about accessible development. And the same thought-process applies in AI-generated code. An LLM defaults to what's easiest to write, and correcting for accessibility feels like extra work. Or at least that's what it's been trained to think.But what if the opposite were true?I ran the same prompts through the same model twice (once without any accessibility guidance in context and once with a lightweight accessibility skill loaded) and what I found confirms what accessibility advocates have been saying all along: it actually costs more and takes longer to ship inaccessible code.In this talk, I'll walk through the experiments, the numbers, and the failure modes it exposed.

Open Mercato (MIT license) lets you build your CRM/ERP app with 80% done. Yet, no single line of the 1.2M+ codebase was written by a human. I'll show you how we manage a team of 130+ contributors with autonomous coding and code review. Auto-updated context with evals.

AI is writing a growing share of my production code, and it fails in ways my old testing habits were never built to catch. This is the honest field report: what breaks, what I test for now, and the checks that actually catch it before it ships.

Everyone is looking for AI metrics. Organizations are tracking token consumption, AI adoption rates, generated code volume, and agent activity in an attempt to measure engineering performance. Yet, many teams still struggle to answer a simple question: what does quality look like with AI?This talk argues that AI changed how software is produced, not what good software looks like. We'll explore why many AI KPIs miss the point and how to distinguish productivity, quality, and business outcomes when measuring engineering success.

At 68, my father had brewed more than 200 batches but had never written code. With OpenClaw, we translated his brewing expertise into brewOS, an open source Python system that controls a Grainfather G30 over Bluetooth, exposes live state, and pauses for human approval at physical transitions. The case later appeared in Jensen Huang's NVIDIA GTC keynote and Peter Steinberger's TED2026 talk.This practical 20 minute session goes beneath the headline and into the coding workflow and engineering boundaries. I show how we turned tacit domain knowledge into executable workflow state, separated AI assisted creation from deterministic execution, and hardened the result with bounded tools, state visibility, checkpoints, failure recovery, and human ownership.

Claude Code Mods let you customize how Claude Code behaves, interact with session events, and build custom UI directly in the terminal or desktop app. In this talk, I’ll explain what Mods are, the main components behind them, how to build one step by step, and how to discover and install existing Mods from aitmpl.com.

Your coding agent botched a multi file refactor once in production. You rerun the exact same prompt to debug it, and it works. The model sampled different tokens, a tool returned a different payload, the context drifted, and the failure was gone. This session shows how to capture every nondeterministic input to an agent loop into an append only execution log, replay the failed run step by step, and then turn that replay into reproducible evals so the bug never quietly returns.

Teams often start agent adoption by adding tools: MCP servers, API wrappers, chat interfaces in developer portals. But once coding agents move from local help into real delivery workflows, they usually fail earlier than the tool call. They read stale ownership, conflicting runbooks, missing deploy history, and policies that were written for humans.This talk introduces company memory as the missing layer for production coding agents: trustworthy, permission-aware engineering context that agents can read, cite, and act on safely. We’ll look at what belongs in that memory, how to expose it through capability registries and machine-readable tool contracts, how to use on-behalf-of identity instead of shared AI service accounts, and how to grow trust from read → recommend → act.The goal is simple: before giving agents more tools, make sure they can trust what they read.

Every team does the same thing. Agent behaves weirdly in production - retries endlessly, drops tasks, returns confident nonsense. First reaction: swap the model, tweak the prompt.It's never the model.Multi-agent systems aren't an AI problem. They're a distributed systems problem with an AI layer on top.

What if your AI agent wasn't just a tool, but a teammate? Not a chatbot you query, but an engineer who picks up tickets, opens PRs, ships to production, and is accountable for what it merges. We learned this the hard way, and the architecture required to make that work is fundamentally different from anything in the current playbook.Most teams treat AI agents as assistants, but at monday.com, AI agents are real teammates and colleagues: each has a name, a role, and a team. They join engineering squads, get assigned tasks, reply in Slack threads, review PRs on GitHub, ship features to production, and monitor what they shipped.This session explores the architecture behind that shift - from a task assignment to a shipped feature.

Rewriting legacy code is historically one of the most high-risk, labor-intensive bottlenecks in software engineering. But what if you could safely delegate an entire live-production migration to an AI agent?In this session, Aleksandr Nikolenko walks through a real-world case study from Perplexity: migrating a critical search pathway from an old Python service to a new, high-performance Rust implementation in under a month. By leveraging autonomous agents, the team successfully deleted roughly 50,000 lines of legacy Python code with zero user-facing regressions.This talk breaks down the strict engineering contract that made this autonomous delegation possible. You will explore the mechanics behind building ""shadow workspaces"" where AI-generated code can fail safely, and how to implement output verification loops that test against real, live-traffic samples rather than static data.

AI coding assistants have quietly become a real line item in engineering budgets - and most teams have no strategy for it, just a bill. The uncomfortable truth: you don't pay for tokens, you pay for tokens that produce no value.This talk is a practical playbook built on two levers. First, model routing: matching model tiers to task phases - frontier models for planning and review, mid-tier for implementation, the cheapest for mechanical work. Second, context management: why agents that explore large codebases burn premium tokens on searching instead of thinking, and the architectural pattern that fixes it - a code intelligence layer where an expensive model asks questions and a cheap, locally-run system that already knows the codebase answers them.

Many assumptions about CI are breaking down. Faster hardware alone can’t keep pace with growing repositories and AI workloads. Underpowered cloud sandboxes push agents to validate changes in CI, without opening PRs. The tradeoffs between speed and cost are changing.

Rust is a high-performance programming language that is memory-safe without garbage collection. The migration to Rust is gaining traction across projects and organizations.- Bun migrated 535,000 lines from Zig to Rust.- Turso for SQLite.- Pgrust for PostgreSQL.- Cloudflare replaced critical NGINX/Lua infrastructure software.- Android, Dropbox, Microsoft, and others are adopting Rust for performance, reliability, and memory safety.Government agencies in the US and Europe are urging software developers to move away from C/C++ due to memory-safety concerns. Until recently, rewriting large production software was risky and time-consuming, and most projects were abandoned. Coding agents can now rewrite large codebases in a few weeks.

After a weekend away at a cabin with limited cell service, I returned to work and discovered unexpected Fable usage (50% of my weekly budget was blown before I even got started). Tracing the consumption back into the contributing session revealed Fable checking on the status of a PR every 5 minutes, death by a thousand cuts. Icing on the cake is the pull request contained only one Markdown file: a plan for a feature I wasn't sure I wanted. I found the problem because I happened to look.

The gap between "agent on my laptop" and "agent for the team" is wider than most people realize. We crossed it. This is what's on the other side.When every developer runs their own agent, context scatters. Skills diverge.

Your AI coding agent can run rm -rf, force push to main, install a typosquatted package, and read your .env file, all on its own. This talk shows how event-driven hooks enforce least privilege at runtime, mapped to 6 of the OWASP LLM Top 10, backed by an open-source toolkit (claude-code-hooks, 439 stars).

Agile was built on a true assumption that is no longer true: developer capacity is the constraint. Sprints, story points, velocity, “protect the engineers.” The whole machine is designed to ration scarce coding time.Agents broke that. Code got cheap. Software projects still fail, for the same old reason they always did: the work is poorly defined.

With frontier models, now anyone in your company can build a dashboard with an agent. Rapidly, thousands of dashboards appear across the company. Then the underlying data model changes: revenue must exclude the new Buy-One-Get-One Free discount. Now all of those dashboards are silently but dramatically wrong, and incorrect numbers are presented to the board.The foundational solution to this problem is to build a semantic layer: a centrally governed set of well defined business metrics that all dashboards consume.