JSNation US 2026

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.

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.

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