Ready to go from a plain repo to a workflow that changes code, verifies it, and merges it — on its own?AI coding demos look magical, but most stop at the pull request — and leave you wondering how to actually trust one at scale. The moment you point an agent at real repos, the questions pile up: how do you know it didn't break something? What stops a retry loop from running forever? When do you pull in a human? And who actually clicks merge? This workshop is the part the demos skip. You'll take a real repo and build the missing machinery: verification first, then an agent that does the work, proves it, and closes the loop by merging the safe changes itself.The core lesson: an agent can only automate what it can verify — and the loop isn't real until it merges.What you'll build:A repo made agent-ready — real tests, CI, and a baseline checkYour own skill, from scratch, that makes a code change and proves it didn't break anythingA verification gate that lets the agent fix only what its change broke — no false positivesA bounded execution loop that retries, then hands off to a human instead of hiding failuresAn auto-merge step that closes the loop — merging the change on green, with no human in the seatTopics covered:Splitting a task into a deterministic lane (scripts, zero model cost) and a non-deterministic lane (real judgment)Writing tests and wiring CI so the agent has eyesight into the repoCapturing a baseline and chasing only the NEW failures your change introducedAuthoring an agentic skill from scratch: what it reads, what it does, what it writes backPutting the loop on a leash — bounded retries, stable-green checks, routing failures to a humanClosing the loop with auto-merge — gate on green, merge the safe changes, escalate the restDesigning the skill so it composes into a larger fleet later — one reliable unit first, scale secondThis isn't a demo — it's a build. You'll write TypeScript, add real tests, and wire up a workflow that runs end to end: change, verify, and merge, on its own. By the end you'll have a working skill and the confidence to point it at your own codebase on Monday morning.

This workshop bridges the long-standing gap between React developers and production-ready delivery. Many front-end developers know how to build great interfaces but they stumble when it comes to building, testing, deploying, and monitoring those apps in real-world environments.This workshop gives React developers the DevOps superpowers they need.You’ll learn how to:Dockerize your React application for development and production following best practices from Docker Captain Leader.Build scalable CI/CD pipelines using GitHub ActionsOptimize your apps for performance and reliabilityThis is not theory. It’s not a shallow overview. This is a production-focused, real-world workshop by a front-end developer who lives and breathes this every day.

In this workshop we'll dive into the latest advancements in React and best practices for building modern React apps. We'll take a look at modern NextJS and React Router 7 Framework along with React's "React Server Components". We'll also talk about improving the data-fetching strategies of your SPAs along with options for migrating your SPA to modern React Router.

In this workshop we'll dive into the latest advancements in React and best practices for building modern React apps. We'll take a look at modern NextJS and React Router 7 Framework along with React's "React Server Components". We'll also talk about improving the data-fetching strategies of your SPAs along with options for migrating your SPA to modern React Router.

In this workshop we'll dive into the latest advancements in React and best practices for building modern React apps. We'll take a look at modern NextJS and React Router 7 Framework along with React's "React Server Components". We'll also talk about improving the data-fetching strategies of your SPAs along with options for migrating your SPA to modern React Router.

In this workshop we'll dive into the latest advancements in React and best practices for building modern React apps. We'll take a look at modern NextJS and React Router 7 Framework along with React's "React Server Components". We'll also talk about improving the data-fetching strategies of your SPAs along with options for migrating your SPA to modern React Router.

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.

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.

Learn how to easily add core infrastructure to a React app with ReactFire and FirebaseUI, add AI features with Firebase AI Logic, and deploy and monitor a production server-rendered React app with Firebase App Hosting and Cloud Monitoring.

AI is writing more code every day. The skill that will not get automated is knowing what to build. And how to ship it with confidence when agents do most of the implementation.

In this full-day workshop, you will practice product engineering judgment upstream of the code, then put an AI-native delivery loop underneath it. You will learn how to validate a problem before you commit to a solution, understand the users you are actually building for, prioritize ruthlessly, and make reversible product decisions. Then you will set up the systems that let agents implement safely: shared intent and context, durable primitives, verification gates, feature flags, and outcome review instead of reading every diff.

What you will learn:
1. Validate before you build: surface real user pain, not solution-shaped stories
2. Align intent with agents: shared understanding, options with trade-offs, and clear "done"
3. Prioritize what deserves to exist (cut ruthlessly)
4. Design two-way doors: use flags and reversible decisions so you can ship and learn
5. Build agent-ready primitives: structure the repo so agents reuse building blocks instead of inventing slop
6. Close the delivery loop: tests, AI review, CI, preview environments, and risk-aware shipping without babysitting every line
7. Keep the system improving: friction logs, cleanup, and feedback loops after you ship

Who it's for: Software engineers with professional experience who already use (or are starting to use) coding agents. No specific stack required. PMs and tech leads welcome.

Format: One full day, hands-on. Bring a laptop, take notes, and have your preferred agent ready to go!

AI is writing more code every day. The skill that will not get automated is knowing what to build. And how to ship it with confidence when agents do most of the implementation.

In this full-day workshop, you will practice product engineering judgment upstream of the code, then put an AI-native delivery loop underneath it. You will learn how to validate a problem before you commit to a solution, understand the users you are actually building for, prioritize ruthlessly, and make reversible product decisions. Then you will set up the systems that let agents implement safely: shared intent and context, durable primitives, verification gates, feature flags, and outcome review instead of reading every diff.

What you will learn:
1. Validate before you build: surface real user pain, not solution-shaped stories
2. Align intent with agents: shared understanding, options with trade-offs, and clear "done"
3. Prioritize what deserves to exist (cut ruthlessly)
4. Design two-way doors: use flags and reversible decisions so you can ship and learn
5. Build agent-ready primitives: structure the repo so agents reuse building blocks instead of inventing slop
6. Close the delivery loop: tests, AI review, CI, preview environments, and risk-aware shipping without babysitting every line
7. Keep the system improving: friction logs, cleanup, and feedback loops after you ship

Who it's for: Software engineers with professional experience who already use (or are starting to use) coding agents. No specific stack required. PMs and tech leads welcome.

Format: One full day, hands-on. Bring a laptop, take notes, and have your preferred agent ready to go!

AI is writing more code every day. The skill that will not get automated is knowing what to build. And how to ship it with confidence when agents do most of the implementation.

In this full-day workshop, you will practice product engineering judgment upstream of the code, then put an AI-native delivery loop underneath it. You will learn how to validate a problem before you commit to a solution, understand the users you are actually building for, prioritize ruthlessly, and make reversible product decisions. Then you will set up the systems that let agents implement safely: shared intent and context, durable primitives, verification gates, feature flags, and outcome review instead of reading every diff.

What you will learn:
1. Validate before you build: surface real user pain, not solution-shaped stories
2. Align intent with agents: shared understanding, options with trade-offs, and clear "done"
3. Prioritize what deserves to exist (cut ruthlessly)
4. Design two-way doors: use flags and reversible decisions so you can ship and learn
5. Build agent-ready primitives: structure the repo so agents reuse building blocks instead of inventing slop
6. Close the delivery loop: tests, AI review, CI, preview environments, and risk-aware shipping without babysitting every line
7. Keep the system improving: friction logs, cleanup, and feedback loops after you ship

Who it's for: Software engineers with professional experience who already use (or are starting to use) coding agents. No specific stack required. PMs and tech leads welcome.

Format: One full day, hands-on. Bring a laptop, take notes, and have your preferred agent ready to go!

Join us for a hands-on workshop built for developers who want to move from idea to working software faster, using Claude Code, Anthropic's agentic coding tool. Unlike a typical autocomplete-style assistant, Claude Code lives in your terminal, IDE, or desktop app, reads and understands your entire codebase, and can take direct action: editing files, running commands, and handling git workflows, all through natural language.
In this workshop, you'll initialize a Next.js project from scratch and use Claude Code to plan, build, and iterate on a real, working application. You'll set up a `CLAUDE.md` file to give Claude persistent project context and conventions, so you're not repeating yourself in every prompt, and use Plan Mode to review an agent's approach before it touches any code, keeping you in control of multi-step changes. Along the way, you'll write effective prompts, delegate multi-step coding tasks, and let Claude Code handle the repetitive work of scaffolding, wiring up components, and debugging, so you can focus on product decisions and architecture instead of boilerplate.
By the end of the session, you'll have shipped a functioning Next.js application and gained a practical workflow for using Claude Code on your own projects, whether you're prototyping quickly or working within an existing codebase.
No prior experience with Claude Code is required. Some familiarity with React or Next.js is helpful but not essential; we'll cover what you need to know as we go.

Join us for a hands-on workshop built for developers who want to move from idea to working software faster, using Claude Code, Anthropic's agentic coding tool. Unlike a typical autocomplete-style assistant, Claude Code lives in your terminal, IDE, or desktop app, reads and understands your entire codebase, and can take direct action: editing files, running commands, and handling git workflows, all through natural language.
In this workshop, you'll initialize a Next.js project from scratch and use Claude Code to plan, build, and iterate on a real, working application. You'll set up a `CLAUDE.md` file to give Claude persistent project context and conventions, so you're not repeating yourself in every prompt, and use Plan Mode to review an agent's approach before it touches any code, keeping you in control of multi-step changes. Along the way, you'll write effective prompts, delegate multi-step coding tasks, and let Claude Code handle the repetitive work of scaffolding, wiring up components, and debugging, so you can focus on product decisions and architecture instead of boilerplate.
By the end of the session, you'll have shipped a functioning Next.js application and gained a practical workflow for using Claude Code on your own projects, whether you're prototyping quickly or working within an existing codebase.
No prior experience with Claude Code is required. Some familiarity with React or Next.js is helpful but not essential; we'll cover what you need to know as we go.

Join us for a hands-on workshop built for developers who want to move from idea to working software faster, using Claude Code, Anthropic's agentic coding tool. Unlike a typical autocomplete-style assistant, Claude Code lives in your terminal, IDE, or desktop app, reads and understands your entire codebase, and can take direct action: editing files, running commands, and handling git workflows, all through natural language.
In this workshop, you'll initialize a Next.js project from scratch and use Claude Code to plan, build, and iterate on a real, working application. You'll set up a `CLAUDE.md` file to give Claude persistent project context and conventions, so you're not repeating yourself in every prompt, and use Plan Mode to review an agent's approach before it touches any code, keeping you in control of multi-step changes. Along the way, you'll write effective prompts, delegate multi-step coding tasks, and let Claude Code handle the repetitive work of scaffolding, wiring up components, and debugging, so you can focus on product decisions and architecture instead of boilerplate.
By the end of the session, you'll have shipped a functioning Next.js application and gained a practical workflow for using Claude Code on your own projects, whether you're prototyping quickly or working within an existing codebase.
No prior experience with Claude Code is required. Some familiarity with React or Next.js is helpful but not essential; we'll cover what you need to know as we go.

Most agents fail in production for reasons the model can't fix. In this workshop, we start from an agent that fails and lies about it, then harness it step by step until it does the job reliably, without a single change to the prompt. Workshop outline:

1. The failing agent: why it breaks, and why it claims success anyway
2. The agent loop, built up from an empty loop
3. A tool registry and context management
4. Guardrails, context compression and retries that hold whichever model sits underneath
5. Deterministic verification, so the agent fails honestly instead of claiming success
6. Moving secrets and fragile steps, like login, out of the model and into the harness
7. A harness plan for the agents you're building

Most agents fail in production for reasons the model can't fix. In this workshop, we start from an agent that fails and lies about it, then harness it step by step until it does the job reliably, without a single change to the prompt. Workshop outline:

1. The failing agent: why it breaks, and why it claims success anyway
2. The agent loop, built up from an empty loop
3. A tool registry and context management
4. Guardrails, context compression and retries that hold whichever model sits underneath
5. Deterministic verification, so the agent fails honestly instead of claiming success
6. Moving secrets and fragile steps, like login, out of the model and into the harness
7. A harness plan for the agents you're building

Most agents fail in production for reasons the model can't fix. In this workshop, we start from an agent that fails and lies about it, then harness it step by step until it does the job reliably, without a single change to the prompt. Workshop outline:

1. The failing agent: why it breaks, and why it claims success anyway
2. The agent loop, built up from an empty loop
3. A tool registry and context management
4. Guardrails, context compression and retries that hold whichever model sits underneath
5. Deterministic verification, so the agent fails honestly instead of claiming success
6. Moving secrets and fragile steps, like login, out of the model and into the harness
7. A harness plan for the agents you're building

Most agents fail in production for reasons the model can't fix. In this workshop, we start from an agent that fails and lies about it, then harness it step by step until it does the job reliably, without a single change to the prompt. Workshop outline:

1. The failing agent: why it breaks, and why it claims success anyway
2. The agent loop, built up from an empty loop
3. A tool registry and context management
4. Guardrails, context compression and retries that hold whichever model sits underneath
5. Deterministic verification, so the agent fails honestly instead of claiming success
6. Moving secrets and fragile steps, like login, out of the model and into the harness
7. A harness plan for the agents you're building

Most agents fail in production for reasons the model can't fix. In this workshop, we start from an agent that fails and lies about it, then harness it step by step until it does the job reliably, without a single change to the prompt. Workshop outline:

1. The failing agent: why it breaks, and why it claims success anyway
2. The agent loop, built up from an empty loop
3. A tool registry and context management
4. Guardrails, context compression and retries that hold whichever model sits underneath
5. Deterministic verification, so the agent fails honestly instead of claiming success
6. Moving secrets and fragile steps, like login, out of the model and into the harness
7. A harness plan for the agents you're building

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 & Migrations: Automate large-scale structural code generation while establishing rigorous LLM-assisted code review gates.

3. Implement AI-Assisted Testing & 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.

There is no single correct way to assemble a software factory. Labs want us to trust agents more than we should. Tech influencers gloss over important, practical details. This workshop introduces several composable patterns for making a codebase more factory-like: to improve the throughput, quality, and verifiability of autonomous agent work in your project.We will cover: - Planning the work that gets handed over to a software factory- Converting plans and specifications to durable internal docs (and rules) that don’t go stale- Task decomposition for coding agents, and the tools that help with it- Review strategies and tools that can manage massive PRs - Agent-friendly QA setups that allow coding assistants to verify their work and fix bugs before human review- When you can safely skip human review entirely- The role of sandboxes (local and remote) for scaling and handling agent work on your codebase

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 coverSet up the challenge: Review the sample repository, define a focused task, and agree on clear acceptance criteria.Configure your tools: Connect OpenCode to the selected model provider and understand credentials, access requirements, and potential usage costs.Build with an agent: Use OpenCode to plan and implement a small, well-bounded feature.Review before accepting: Inspect the generated diff, run the test suite, and learn how to diagnose or recover from an unsuccessful attempt.Make the process reusable: Turn the workflow into a practical checklist you can apply to future coding tasks.Ask questions: Bring your setup, workflow, and agent-development questions to the final Q&A.By the end of the session, you’ll have:A reviewed and tested change in a sample appHands-on experience guiding an AI coding agent through a scoped taskA reusable checklist for planning, reviewing, and validating agent-generated code

You don't need a framework to orchestrate coding agents well — you need the disciplines. In this hands-on workshop you'll take a real repo and orchestrate a small fleet by hand, reaching honest L1 Orchestrated Coding (spec: https://github.com/vnovick/orchestrated-coding) — one owner of context, worktree-per-task isolation, brief/report handoffs, an independent reviewer behind a deterministic gate. Then you'll flip on orchestra - an open-source plugin - and watch the exact same disciplines become enforced: a hook that refuses to let an agent commit, fail-closed verification that says "unverified" instead of lying. Finally I'll run the fully autonomous L3 version live. Vendor-neutral, spec-driven, nothing to buy.

Your UI already knows how to fetch data, submit forms, and navigate - so why are AI agents still scraping your DOM? In this workshop you'll turn your React app into something AI agents can talk to directly - an MCP app.

WebMCP is an emerging browser API protocol that lets web applications expose structured MCP tools directly to AI agents via navigator.modelContext. Instead of agents reverse-engineering your UI, they discover typed, documented functions - complete with JSON Schema inputs and structured responses. Basically, an MCP server running inside your web page.

In this hands-on workshop, we'll take a real React application with GraphQL data fetching and progressively transform it into an agent-ready MCP app. You'll learn how to identify which parts of your UI to expose as tools, architect a clean WebMCP layer that doesn't pollute your existing codebase, and add imperative API calls that agents can invoke on demand. We'll cover the spec, the practical patterns, and the gotchas - and you'll leave with a working implementation you can apply to your own apps.

No AI background required. If you build web apps, this is for you.