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

Seungho Park

Lera

Daria Shabala

Violina Popova

Will Klein

Sander Vervaeke

Karyna Bunta

Kseniia Korostelova

David Pugh

Mykhaylo Ryechkin

Filip Michalowski

Alex Hayton

Burak Buruk

Ryan Ogden

Boris Karaivanov

Jan Pfeiffer

Vitor Barbosa

Denis Radin

Irina Baeva

Arkadiusz Chatys

Basseydou OUATTARA

Amy Rae Som

Srikanth Doddi

REYSMER WILLIANGEL VALLE RAMIREZ

Richie Leahey

Sharon Harrison

Dennys Antunish

Artem Zozulia

Jegan

Yakovlev Eugen

Nirmal Lama-Titung

Yu Shen

VICTORIA CARRIZO PIN

Majk Peroša

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 is writing more code every day. The skill that won't get automated is knowing what to build and the system design thinking to make it happen at scale. In this full-day workshop, you will develop the judgment that sits upstream and downstream of implementation: how to validate a problem before you commit to a solution, how to understand the users you are actually building for (not the ones you imagine), how to prioritize ruthlessly when everything feels urgent, and how to establish feedback loops that keep you building the right things after you ship. These are not PM skills. They are the technical judgment that the best engineers have always had, and that becomes the defining skill as implementation gets faster and cheaper. What you will learn:- Validate before you build: surface real user pain, not solution-shaped stories- Understand users in context: close the gap between your mental model and theirs- Prioritize what deserves to exist: apply the Kano model and know what to cut- Translate decisions for stakeholders: navigate contested requirements productively- Close the loop: establish post-ship feedback habits that drive continuous improvement Who it's for: Software engineers with professional experience. No specific stack required. PMs and designers welcome.

Build the Right Thing: Product Engineering for Software Developers

"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

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. Using a real-world example, we'll look at the trade-offs of this approach and how you can start using it in your own projects right away.

Using Spec-Driven Development for Production Workflows

Erik Hanchett

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

Jack Gordley

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

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. Auto QA tests. I'll also share the OSS tools and AI skills behind it all.

Closing the Agentic Loop: How We Keep a 1.1M-Line Codebase Moving 24/7

Piotr Karwatka

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.

A Test That Passes for the Wrong Reason: Reliability for AI-Assisted Conformance Testing

Lorenzo Dal Col

Learn how to use OpenCode with an open-weight model to make a small, practical change in a sample application—from defining the task through reviewing and testing the result before you accept it.Together, we’ll choose the most suitable model provider—GLM, Kimi, or DeepSeek—based on reliable access and the group’s setup. You’ll see how to work with an AI coding agent in a controlled, repeatable way: set clear acceptance criteria, keep the scope manageable, inspect every proposed change, and validate it with tests.What we’ll cover<ul><li>Set up the challenge: Review the sample repository, define a focused task, and agree on clear acceptance criteria.</li><li>Configure your tools: Connect OpenCode to the selected model provider and understand credentials, access requirements, and potential usage costs.</li><li>Build with an agent: Use OpenCode to plan and implement a small, well-bounded feature.</li><li>Review before accepting: Inspect the generated diff, run the test suite, and learn how to diagnose or recover from an unsuccessful attempt.</li><li>Make the process reusable: Turn the workflow into a practical checklist you can apply to future coding tasks.</li><li>Ask questions: Bring your setup, workflow, and agent-development questions to the final Q&amp;A.</li></ul>By the end of the session, you’ll have:<ul><li>A reviewed and tested change in a sample app</li><li>Hands-on experience guiding an AI coding agent through a scoped task</li><li>A reusable checklist for planning, reviewing, and validating agent-generated code</li></ul>

From First Prompt to Reviewed Change: OpenCode with an Open-Weight Model

Eric Tech

AI coding agents work impressively when the task fits inside a few files. Enterprise software rarely does. A seemingly simple requirement can cross hundreds of files, shared libraries, APIs, data models, tests, infrastructure, and years of architectural decisions. At that scale, putting more source code into an LLM context window is not the same as giving an agent an understanding of the system. This talk shares lessons from building AI-augmented software development for large enterprise codebases. We’ll examine why file-level retrieval and ever-larger context windows break down, how coding agents can construct a task-specific model of a codebase using structural relationships and iterative exploration, and why planning and verification become more important than code generation as agent autonomy increases. The goal is to move the conversation from “How much code can the model see?” to “How does the agent determine what actually matters for this change?”

The Context Window Is Not Your Codebase: Enterprise Lessons for Scaling Coding Agents

Kranthi Manchikanti

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. Aleksandr will also reveal how this agentic loop successfully caught schema mismatches and ranking-order divergences that traditional unit tests and human code reviews completely missed. What You Will Learn: - Goal-Oriented Delegation: How to turn a massive codebase rewrite into a targeted agent goal with measurable pass conditions. - Shadow Workspaces: The architecture required to let agents execute and test refactored code safely under production load. - Live-Traffic Verification: Why continuous output verification against real user traffic is the key to trusting AI-generated code.

Delegating Production Migrations to AI Agents: Safe Verification and Shadow Testing Loops

Aleksandr Nikolenko

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.

What I Actually Test Before AI-Written Code Ships to Production

Artemis Leonardou

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. But the source code is only the beginning. I’ll take you inside our real-world migrations of TinyCC, HAProxy, Memcached, Redis, and the Cano editor, from C to Rust. In addition to working source code, you'll leave with knowledge of how the new software needs to be tested, documented, verified, benchmarked, debugged, and made upgradable.

From C to Rust with AI: Generation Is Easy, Verification Is Hard

Lawrence Lu

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.

From Git Diff to Codebase Intelligence: Building an Agentic Code Reviewer

Mateus Paulino

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. You chat with the local model, it decides which browser tool to trigger, aggregates the data, and renders the result. No backend LLM. No API tokens. Zero operational cost.

Agentic UI Without a Backend LLM

Navya Agarwal

Evals are integral to building quality agents. If you can't measure an agent's output, you can't ship it. This talk covers how to eval agents with multi-step trajectories involving planning, tool calls, edits, and more.

Evals for Coding Agents

Chris Munn

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. It's about a specific kind of grief: watching the line between your effort and the thing existing get shorter, three times, each time for genuinely good reasons. Copilot finished my keystrokes. Cursor wrote the functions I'd already designed. Then I stopped typing out code at all. And somewhere in there, the part made me want to become a software engineer in the first place? Gone. Nobody took it from me, exactly. It just wasn't mine anymore. Two years in, I was reduced to rubber stamping thousand-line PRs no human wrote, arriving faster than any human could honestly read them. And look, we were shipping. More than ever, in fact. But the person still holding the bar (hi!) had somehow become the one slowing everyone down. So I quit my founding CTO role with nothing lined up. Here's what I didn't know then, and what I really could have used: it wasn't just me. This is measured now, at industry scale, and I'm bringing the benchmarks. If there's grief on your team about what this job has become, it's real, it's everywhere, and it's not a performance problem. And then the part that isn't venting is what survived. Guardrails that live on infrastructure instead of my nervous system. Owning what "done" actually means. Here's the weird ending, though: the craft didn't die. It shifted. There's still one question I can't answer: what is code review even for when the author is an agent? I'll tell you where I've landed and where things are going (for now)!

All Ship, No Craft

Haldun Anil

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

Got my free ticket to AI Coding Summit NYC. Harness engineering, spec-driven dev, agent orchestration, shadow testing — from engineers at Anthropic, OpenAI, Google & Microsoft. 40+ talks, 5k+ devs online. Grab yours → https://aicodingsummit.com/nyc

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.