Name: AI Coding Summit NYC
Start: 2026-11-16T15:00:00.000Z
End: 2026-11-19T22:59:00.000Z

Seungho Park

Irina Baeva

Lera

Violina Popova

Will Klein

Sander Vervaeke

Kseniia Korostelova

Mykhaylo Ryechkin

Filip Michalowski

Alex Hayton

Burak Buruk

Boris Karaivanov

Jan Pfeiffer

Vitor Barbosa

Denis Radin

Arkadiusz Chatys

Basseydou OUATTARA

Sean Leow

Amy Rae Som

Srikanth Doddi

REYSMER WILLIANGEL VALLE RAMIREZ

Mik Khu

Richie Leahey

Sharon Harrison

Dennys Antunish

Yakovlev Eugen

Nirmal Lama-Titung

Yu Shen

VICTORIA CARRIZO PIN

Majk Peroša

Chan Wen Tjun

Hanns Haustein

David Navalho

Jamie  Craik

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. If AI agents are going to build and run software for everyone, this is what the infrastructure underneath looks like. You can start building it today.

I Built Your Personal Software Ecosystem

Kent C. Dodds

"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.

Automating Quality with AI

Cory House

Vibe coding is easy, until you have to make an app that actually works. Sure, AI agents can spin up an impressive demo in minutes, but building a full-stack app that's robust, bug-free, and true to spec is where things get messy. And completely cloning an existing full-stack app? That's next-level difficult. Adding more agents just multiplies the mess, and spec-driven development piles stale specs on top of it. So... what does it actually take? In this talk, we'll explore a radically different approach, learned from building (and cloning) hundreds of apps for RL agent training environments and more: a living spec (yes, including state machines) and an AI-generated implementation that iterate on each other until reaching equilibrium, where the app provably does what the spec says. You'll learn how to model full-stack behavior as states, events, and effects, why letting agents modify their own workflows beats any rigid pipeline, and how to apply this experimental but extremely effective iterative loop to your own AI-assisted development today.

Cloning Full-Stack Apps with AI: What It Really Takes

David Khourshid

What Comes After AI Coding

Dominik Kundel 

"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. Attendees will learn the architecture of microVM-based isolation and leave with a concrete pattern for running agents in "Full YOLO Mode" without risking their host machine or production data.

rm -rf: Horror Stories From Unsandboxed AI Agents (and How Docker Fixes This)

Rishab Kumar

What an agent can do is capped by infrastructure, not model quality. Harnesses like Claude Code and Codex stay narrow, so the hard parts of running agents in a real SDLC (permissions, CI, code changes, cross-session memory) get reinvented inside every org. A meta-layer is forming, just like Next.js formed around React. This talk defines the meta-harness and shows how it makes agents more autonomous.

Why Everyone Is Building a Meta-Harness

Victor Savkin

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. Drawing on Callstack's work in React Native and AI-native engineering, it maps the development system required to carry intent, context, and evidence through the entire lifecycle and turn agent output into dependable product outcomes.

Beyond Coding Agents: Making ADLC Work Across Platforms

Mike Grabowski

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.

Why We Chose Deterministic Workflows Over Autonomous Agents

Maya Shavin

"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. We'll look at what the AI actually built without accessibility context (spoiler: lots of custom code for features the browser already handles), why the accessibility-aware run converged faster, and what this means for how we ship AI-assisted code. You'll leave with the exact prompts and context patterns needed to make your model ship faster, more accessible UI on the first try, plus a data-backed argument for making accessibility a default in every AI-assisted workflow - not just because accessibility means that everyone can use the products we build - but because it's cheaper too.

The Cost of Accessibility in AI

Jemima Abu

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. All of it runs downstream of the failure. The miss already happened before any of those fire, so you're doing an autopsy instead of preventing anything. This talk shows the fix: work backwards. Before your agent writes a single line, you and the agent together define concrete, measurable success criteria and the validation strategy that proves them. Only then does it implement. It's TDD repurposed for AI agents! The validation-first plan gives the AI agent an actual contract for the task at hand. I'll walk through it live on a real codebase, in Claude Code, on an ordinary task: the naive version that passes every check and still does the wrong thing, the plan that makes "done" explicit, and the same task done validation-first. Then the part that compounds, which is that when a miss does slip through you don't just patch the bug, you evolve the system so the same class of mistakes goes away over time. You own the plan, the agent owns the typing. Attendees leave with three things they can apply on their next ticket, with no new tooling required.

The Validation-First Loop: How to Ship Production Code with Claude Code

Cole Medin

End-to-end tests are powerful, but they’re slow to write and easy to drift. We translate requirements into test code by hand, and over time the intent gets lost. What if behavior could be described in plain language and turned into reliable E2E coverage through a repeatable playbook? As an architect working across teams, I’ve been building structured playbooks that AI agents run through the Playwright CLI. These playbooks take requirements, designs, or existing code and generate natural language-based E2E scenarios tied to real user flows. The key isn’t automation. It’s structure. The playbook defines how context is gathered, how scenarios are created, and how results are validated so the system stays predictable. Join me to see how this works in practice. I will walk through the playbook design, the tradeoffs, and where AI helps versus where human judgment still matters. You will leave with a practical approach to adding AI-driven E2E testing without losing control of your test suite.

Playbook-Based E2E Testing with Playwright CLI and AI Agents

Avindra Fernando

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.

Beyond Design-to-Code: Building Interfaces in 2027

Riccardo Erra

The Problem Enterprise engineering teams are burdened by aging Node.js/Express monoliths tightly coupled to fragile templates and untyped data layers. Manually refactoring these massive codebases into modern cloud-native architectures is notoriously slow, introduces severe regressions, and creates massive code review bottlenecks for developer workflows. The Solution Instead of manual rewrites, modern teams can harness advanced agentic-programming patterns to orchestrate dedicated agent swarms. This workshop guides advanced engineers through an automated refactoring and migration pipeline using Google Antigravity. Attendees will learn how to leverage structured task planning, parallel subagents, and automated LLM code reviews to transform a legacy Express monolith into a strongly-typed Next.js application. Key Takeaways By the end of this hands-on session, attendees will be able to: 1. Orchestrate Agent Swarms: Author deterministic task plans and custom Agent Skills that direct parallel subagents to audit legacy middleware, API contracts, and schemas. 2. Execute AI Refactoring &amp; Migrations: Automate large-scale structural code generation while establishing rigorous LLM-assisted code review gates. 3. Implement AI-Assisted Testing &amp; QA: Set up autonomous CI/CD verification loops where agents execute failing tests, parse error logs, and self-correct code until runtime parity is perfectly proven.

Orchestrating Agent Swarms: Automating Migrations with Agent Loops in Antigravity

James O'Reilly

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. And most teams skip all the boring infra - state management, observability, failure handling, routing - and pay for it later. We'll go through 8 agentic patterns (supervisor/worker, swarm, reflection, human-in-the-loop and more), and for each one: what the pattern does, where it breaks, and what infra you actually need before shipping it to production.

Your Agent Failed. You Blamed the Model. You Were Wrong.

Daniel Ostrovsky

In this workshop, I'll guide participants through a decision framework for Claude Code's orchestration tools. Most people already use two or three of them and guess about the rest.

Advanced Claude Code Orchestration: A Decision Framework for Skills, Subagents, Goals, and Workflows

 Shrey Shah

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. The agent runs a held-out task suite and gets scored, with deterministic checks where possible and a pinned LLM judge where not, with the accept bar set above the judge's own noise. A second model reads the failures and proposes one small, bounded edit to the skill. Then a gate decides. Score went up: commit. It didn't: git reset --hard, and the bad edit never happened. Rejected edits go back to the proposer so it stops repeating its own mistakes. I'll show you a real overnight run, including the ugly parts: one real gain, two edits that tanked the score and got thrown away, and a loop that said 'no progress' and stopped instead of faking a win. I'll also cover the two tests that tell you whether it's learning or just chasing noise, and how to mine your own agent session history for new training tasks. What you ship is still one skill file. No added cost at inference. The agent just follows better instructions than it had yesterday.

Stop Writing Skills. Start Training Them.

AI agents can be fast, available, and still completely wrong. Standard application monitoring can show latency and errors, but not whether an answer was useful, a tool call behaved correctly, or a prompt change introduced a regression. This talk shows how to instrument, trace, and evaluate production AI agents using OpenTelemetry and AI Observability.

Your Agent Returned 200. Was It Right?

Nathan Marrs

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.

Agentic Design Systems: Making Design Systems Machine-Readable for MCP and LLMs

Preethi Selvam

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.

Your Coding Agent Is Only as Good as Your Company’s Memory

Eugene Sergueev

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.

Debugging the Agent That Refuses to Fail the Same Way Twice

Tisha Chawla

Susheem Koul

Organizations like Anthropic claimed 70-90% of their code was written by AI early this year. This aligns with my own experience building an AI startup and what I hear from engineers around me. As coding agents get better, writing code itself is becoming a smaller part of software engineering. So what happens when AI eventually writes nearly all of it? What still makes someone a great engineer? In this talk, I’ll look at this question from both sides: what engineers should become better at, and what companies should look for when hiring them. I’ll share observations from building with AI coding tools, hiring engineers, and advising founders on technical hiring—and discuss which engineering skills are becoming more valuable, which may matter less, and how technical hiring needs to evolve.

When AI Writes 100% of the Code, What Makes a Good Engineer?

Andrea Gao

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. Attendees will leave with a repeatable method for turning agent failures into systematic improvements instead of longer prompts and more manual review.

From Issue to Verified PR: Sizing the Harness for Coding Agents

Kiriti Badam

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. Lessons learned in one session never reach the next person. We wanted a single agent that the whole team could rely on: shared skills, shared memory, zero sessions colliding, and a clear answer to who can do what. Building that meant rethinking storage, isolation, access boundaries, and how config files become team infrastructure. The result changed how our engineers ship. This talk is the architecture that got us there, the decisions we'd defend, and the ones we wouldn't.

Sharing an Agent Shouldn't Scare You. Here's What We Learned.

 Shreshth Goyal

Stop prompting. Start orchestrating. In four intense hours you'll go from using Claude Code like a faster autocomplete to commanding it like a senior engineer commands a team: engineering its context, deploying fleets of subagents, locking it down with hooks, and turning it loose on work that runs without you.Every Claude Code user hits a ceiling where the easy wins run out. The agent handles small stuff beautifully, then loses the thread on anything real. The difference between that ceiling and real mastery isn't better prompts. It's control. This workshop is about control.You'll spend the whole four hours inside CLASH, a real full-stack application, handed to you fully built so nothing stands between you and the hard parts. A serious codebase is the point: it's the only place agentic engineering shows you whether it actually holds up.The throughline is context. Treated carelessly, the context window fills with noise until the agent drifts. Treated as a resource you engineer, it becomes the biggest lever you have. From there the toolkit opens up. Repeatable work becomes a reusable Skill. Noisy, exploratory work goes to subagents that run in their own isolated context, several at once when the job allows. Hard rules become hooks the agent cannot cross. Your own systems come into reach through MCP.Then you let go of the wheel, carefully. The same agent that pairs with you can run headless in a pipeline, drive a long task to a defined finish on its own, or live inside your software through the Agent SDK. We close by setting two greenfield methodologies, Spec Kit and BMAD, side by side, so you leave knowing not just how to drive the agent but which approach fits which problem.Two ideas hold it together: context is king, and you push it, you own it. This was never about generating code faster. It's about staying in command while the agent does more.This is an advanced session for engineers, tech leads, and architects who already use Claude Code every day and want to reach the top of the curve. We move fast, and we start in the deep end.

Claude Code: Black Belt

Pawel Sawicki

Don’t get left behind—discover how AI is revolutionizing software engineering at the AI Coding Summit. Dive into cutting-edge talks and hands-on workshops on AI-powered software development. Network with industry leaders, explore game-changing tools, and stay ahead in the fast-evolving world of AI-driven development. Do not miss the biggest shift in software engineering.

AI Coding Summit

I'm attending AI Coding Summit with 5k other participants to learn how AI transforms software development and stay up to date with the latest AI tools - get your free remote ticket and join me there!

Bringing AI coding best practices to NYC. Two days of practical talks and workshops on coding agents, AI code review, context engineering, prompt-driven development, and shipping production software with AI at scale. Connect with the East Coast AI developer community and learn proven workflows from engineering leaders who use AI tools daily.

AI Coding Summit NYC

FocusReactive

Hygraph

Auth0 by Okta

Progress

Braintrust

Secure AI agents, humans, and whatever comes next

Progress Software empowers organizations to achieve transformational success in the face of disruptive change. Progress software enables our customers to develop, deploy and manage responsible AI-powered applications and digital experiences with agility and ease. &nbsp;

AI Enable Your Business. Turn AI disruption into a competitive advantage.

FocusReactive is an&nbsp;<meta charset="utf-8" id="isPasted">engineering-led <a href="https://focusreactive.com/" target="_blank" rel="noopener noreferrer">Headless CMS Development Company</a>&nbsp;and&nbsp;<a href="https://focusreactive.com/next-js-expert-agency/">NextJS&nbsp;development experts</a>. Independent partners of Payload CMS, Sanity, Storyblok, Vercel and Shopify. Delivering&nbsp;<meta charset="utf-8" id="isPasted">Composable content platforms built for AI SEO, growing teams, and marketing velocity.

AI Coding Summit NYC

See how AI transforms software development