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.

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.

Every team now has the same frontier models. Same models and similar prompts mean similar defaults, so the code your agent writes looks a lot like everyone else's. Picking a better model won't set you apart anymore. What sets you apart is what your agent knows, and whether it can prove its work.In this hands-on workshop, you'll give your coding agent two advantages. Modern Web Guidance adds expert-vetted web platform knowledge, best practices and browser compatibility data. That steers your agent towards leaner, faster, more accessible solutions instead of heavyweight defaults and outdated APIs. Chrome DevTools for Agents lets your agent open your app in a real browser with powerful DevTools capabilities to see what the code alone doesn’t show, from runtime performance and layout shifts to the accessibility tree and memory leaks. You'll compare guided and unguided agents on real features, then use the same workflow on an existing codebase.This workshop is for frontend and full-stack engineers who already use AI coding agents and want output that stands out. You'll leave with a setup that works with the agent you already use, and a repeatable way to build, check and ship work.

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.

In this hands-on 90-minute workshop, we'll turn a small business request into a clear specification, then use OpenCode and an open-weight model to implement a bounded change in a sample app. We'll build a repeatable loop around task planning, coding, automated tests and human review, including how to recover when an agent's first attempt fails. I'll draw on the software factory workflow I built at Eric Tech and my experience helping businesses apply this approach.Audience: Developers comfortable with a terminal and basic Git.Outcomes: Participants leave with a reviewed change, a reusable task specification and a checklist for deciding when AI-generated work is ready to ship.90-minute outline:
10 min: Define the task, acceptance criteria and software factory workflow.
15 min: Set up OpenCode, an open-weight model and the starter repository.
25 min: Plan and implement a small feature with the agent.
20 min: Run tests, review the diff and troubleshoot a failed attempt.
10 min: Turn the process into a repeatable workflow with human approval.
10 min: Q&A.

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.

A founder spent around eight weeks of his spare time adding 349,000 AI-written lines to a sports platform we had built. On the surface it worked. Underneath, anyone signed in could read strangers' private chats, and the tests that came with it passed. Three of us could not review our way through it.

Agents write faster than any team reviews, and an AI marking its own homework gives itself a pass. The harness is the scaffolding in your repository that an agent works inside, so every session inherits your standards and every change meets checks the model doesn't control. In three hours you build three of its five layers:

Repository instructions every agent session picks up, whichever tool it runs in
Deterministic enforcement: your team's rules as custom checks that fail the build (analyzers, lint rules, strict types, post-edit and pre-commit hooks, CI that blocks the merge), with error messages the agent has to fix before it continues
A validation loop the model doesn't grade: tests written from the spec by a session that never saw the code, and a check that calls every endpoint as every kind of user
You work on a deliberately vibe-coded club app, then spend the last half hour on your own repository. Every merge faces one test: could you debug it half asleep at three in the morning? If not, it doesn't merge.

What participants take away

- Structure a repository so any coding agent inherits your standards
- Move enforcement into deterministic tooling that gives agents immediate, non-negotiable feedback
- Validate agent work with checks the model doesn't grade: tests from the spec, and every endpoint called as every kind of user
- Hold your next merge to a gate you can defend at three in the morning
Practical exercises

1. Run the task with no harness, find the defects in your own run, and see that the agent's tests pass
2. Write house rules as repository instructions and re-run a probe task
3. Write a custom lint rule (ESLint in the lab; a Roslyn analyzer or your stack's equivalent at home) that fails the build when code changes a balance outside the ledger, with an error message written for the model; wire it to a post-edit hook and watch the agent fix its own code
4. Break the hook on purpose and watch the edit go through: hooks fail open
5. Have a second session that never saw the code write tests from the spec, and run a check that calls every endpoint as every kind of user; it finds the hole the agent added and one nobody touched
6. In your own repository: your team's most repeated review comment as a custom lint rule or analyzer that fails the build, or one spec-first test for code nobody fully owns

Prerequisites

A laptop with Claude Code, Codex or a comparable coding agent installed and authenticated, and the lab repository cloned before the session; we'll send a setup check in advance. Bring a repository you actually work in for the last half hour.

AI can generate a React feature in minutes, but getting it to production quality is a different story. In this advanced, hands-on workshop we go beyond simple prompting and build a real React application with Cursor AI, the way professional teams do it.

You will learn how to:
- Set up Cursor for a real codebase with project rules, context and reusable prompts
- Plan and build features with Cursor's Agent while keeping full control over architecture and code quality
- Generate and maintain tests, types and documentation with AI
- Review AI-generated code for security issues, performance problems and hidden bugs
- Refactor and scale an existing React codebase safely with AI assistance
- Prepare the application for production with CI checks, linting and deployment best practices

By the end of the workshop you will have a practical workflow for using AI to ship React features faster without sacrificing quality, security or maintainability.

Level: intermediate to advanced. Basic React and TypeScript knowledge is recommended.

AI can generate a React feature in minutes, but getting it to production quality is a different story. In this advanced, hands-on workshop we go beyond simple prompting and build a real React application with Cursor AI, the way professional teams do it.

You will learn how to:
- Set up Cursor for a real codebase with project rules, context and reusable prompts
- Plan and build features with Cursor's Agent while keeping full control over architecture and code quality
- Generate and maintain tests, types and documentation with AI
- Review AI-generated code for security issues, performance problems and hidden bugs
- Refactor and scale an existing React codebase safely with AI assistance
- Prepare the application for production with CI checks, linting and deployment best practices

By the end of the workshop you will have a practical workflow for using AI to ship React features faster without sacrificing quality, security or maintainability.

Level: intermediate to advanced. Basic React and TypeScript knowledge is recommended.

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