CodeGenAI: 2-Day AI Coding Training for Engineers — Amsterdam Edition

Description

A 2-day in-person training for software engineers who want to use Claude Code and agentic coding workflows in real development environments. This training is focused on the practical engineering mechanics of working with AI coding agents. What participants will work on Flappy Bird clone Use Claude Code to modify an existing game loop, add features, re-theme assets, inspect diffs, checkpoint changes, and recover when the agent takes the implementation in the wrong direction. Unfamiliar codebase analysis Use Claude Code to map repository structure, identify entry points, trace control flow, infer module responsibilities, generate documentation, and build a test scaffold around existing behavior. Agile retro board Build a small full-stack application from spec to implementation using Claude Code, custom commands, subagents, acceptance criteria, and iterative review loops. Netflix database analytics via MCP Connect Claude Code to a structured database through MCP, generate and inspect queries, validate assumptions, analyze outputs, and control what the agent is allowed to execute. Hacked Space Invaders game Debug a broken game inside Docker by using logs, runtime errors, hypothesis-driven investigation, minimal patches, and validation instead of letting the agent guess blindly. Chrome DevTools debugging Use Claude Code with browser tooling to inspect DOM state, console errors, network activity, UI behavior, and connect runtime failures back to the source code. Spec-driven development Write implementation-ready specs with constraints, non-goals, interfaces, edge cases, acceptance criteria, and review checkpoints that Claude Code can execute without drifting from the intent. Agent output review Review generated code like a pull request: inspect diffs, test quality, hidden coupling, deleted constraints, over-engineering, shallow assertions, and architecture degradation. Core skills covered Context engineeringPrepare Claude Code with the right repository context, file boundaries, architectural constraints, examples, dependencies, and task-specific instructions before allowing it to modify code. Spec-to-implementation workflow designTurn vague requirements into executable specs with interfaces, constraints, non-goals, acceptance criteria, edge cases, and review checkpoints. Agent task decompositionBreak larger features, bugs, and refactors into small, safe, reviewable agent tasks that reduce drift and make output easier to validate. MCP workflowsHow to connect Claude Code to external context and tools through MCP, including databases, project management systems, documentation, and development tooling. Generated code reviewReview Claude-generated diffs for architectural regression, hidden coupling, deleted constraints, brittle abstractions, shallow tests, and unintended behavior changes. AI-assisted test generationUse Claude Code to generate, extend, and refactor tests while checking assertion quality, edge-case coverage, false positives, and gaps between generated tests and real system behavior. Debugging agent outputHow to inspect, redirect, recover, and continue when the agent produces broken, incomplete, or misleading output. Checkpointing and recoveryDiagnose broken agent output using logs, runtime errors, browser inspection, Docker environments, checkpoints, rollback, and minimal corrective patches. Autonomy controlDecide when to let Claude continue, when to narrow the task, when to interrupt, when to rewind, and when human engineering judgment should override the agent. Team-level AI workflowsCreate repeatable patterns for using Claude Code across a team, including shared specs, commands, review habits, task boundaries, and quality gates. Who this is for Software engineers from any language or stack who want structured hands-on experience with agentic coding workflows. You should attend if you write code professionally and want to understand how Claude Code can be used beyond simple code completion, pair-programming, or one-off prompting. You do not need prior Claude Code, Cursor, or AI/ML experience. The exercises use provided repositories and guided development environments. What participants leave with Trainers The training is led by senior engineers who use Claude Code and Cursor in their own work. Michael Müller — CTO & Co-Founder, re:cinqDesigned the multi-year engineer training programme that supported Adidas’ Cloud Native transformation. Helped define CNCF Kubernetes certification syllabi. Former DevOps lecturer at Lucerne University. Uses Cursor and Claude Code in production work. Daniel Jones — Head of Product, re:cinqCreated training programmes for The Linux Foundation and VMware. Previously led EngineerBetter, known for immersive mob-programming training. Hosts the Waves of Innovation podcast, interviewing technology leaders on CodeGenAI adoption. Uses Claude Code and Cursor daily. Michael Czechowski — Senior Engineer, re:cinqCreator of Wave, a deterministic pipeline tool for AI-assisted development. Built the CFO Agent using spec-driven methodology. Lecturer at HdM Stuttgart and DHBW Stuttgart. Focuses on production validation of AI-generated code. Agenda Day 1 — Claude Code workflow, agent control, and codebase understanding 09:00–09:30 — Arrival and environment setupParticipants set up Claude Code, verify local tooling, clone the exercise repositories, check package managers/runtime dependencies, and make sure they can run, test, and modify the provided codebases locally. 09:30–10:15 — Claude Code inside the development workflowIntroduction to the Claude Code operating loop: preparing repo context, selecting files, framing tasks, inspecting generated diffs, using checkpoints, controlling scope, and deciding when to continue, interrupt, redirect, or roll back an agent run. 10:15–11:15 — Exercise: Flappy Bird cloneParticipants use Claude Code to modify an existing game loop, adjust behavior, add features, change assets, and refactor small sections of the codebase. The focus is on bounded task prompts, incremental implementation, diff inspection, checkpointing, and recovering when the agent makes an over-scoped or structurally poor change. 11:15–11:30 — Break 11:30–12:30 — Checkpoints, rollback, and recoveryParticipants intentionally push Claude Code into ambiguous or badly scoped tasks, then recover from the resulting output. The session covers context cleanup, reverting to known-good states, narrowing instructions, separating exploration from implementation, and using rollback patterns to avoid compounding agent mistakes. 12:30–13:30 — Lunch 13:30–14:45 — Exercise: unfamiliar codebase analysisParticipants are dropped into an unknown repository and use Claude Code to build a working mental model of the system. They identify entry points, trace control flow, map module boundaries, infer responsibilities, inspect dependencies, and validate the agent’s explanations against the actual source code instead of accepting summaries at face value. 14:45–15:00 — Break 15:00–16:15 — Tests around existing behaviorParticipants use Claude Code to create or extend a test suite around the unfamiliar codebase. The focus is on characterization tests, assertion quality, edge-case discovery, test-data setup, false confidence, shallow coverage, and checking whether generated tests describe real behavior or only mirror the agent’s assumptions. 16:15–17:15 — Spec-to-implementation workflowParticipants turn a product-level requirement into an implementation-ready spec. They define constraints, non-goals, interfaces, acceptance criteria, edge cases, and review checkpoints, then use Claude Code to implement against the spec and inspect where the output drifts from the intended architecture or behavior. Day 2 — MCP, debugging, validation, and team workflows 09:00–09:15 — Recap and setup for Day 2Short review of the core working patterns from Day 1: repo context, task boundaries, checkpointing, validation, rollback, and review. Participants prepare the repositories and tooling used for the Day 2 exercises. 09:15–10:30 — Exercise: Agile retro boardParticipants build a small application from spec to implementation using Claude Code. The session focuses on breaking the work into agent-sized tasks, defining implementation order, using custom commands or subagents where useful, reviewing generated diffs, and preventing a greenfield build from turning into an unstructured prototype. 10:30–10:45 — Break 10:45–12:00 — MCP-connected workflowsParticipants connect Claude Code to external context through MCP and work with a Netflix-style database. They generate and inspect queries, validate assumptions, analyze returned data, check intermediate outputs, and define which actions can be agent-driven versus which require explicit human approval. 12:00–13:00 — Lunch 13:00–14:15 — Exercise: debugging a broken Space Invaders gameParticipants debug a broken game running inside Docker. They use logs, runtime errors, reproduction steps, hypothesis-driven investigation, minimal patches, and validation loops to guide Claude Code toward root-cause analysis instead of letting it guess at fixes. 14:15–14:30 — Break 14:30–15:30 — Browser-based debugging with Chrome DevToolsParticipants use Claude Code with browser tooling to debug a broken web page. They inspect DOM state, console errors, network activity, runtime behavior, and UI interactions, then connect browser-level failures back to the relevant source files and validate fixes through runtime feedback. 15:30–16:30 — Reviewing agent output like a pull requestParticipants review AI-generated changes with the same discipline they would apply to a human PR, but with agent-specific failure modes in mind. The review covers architectural regression, hidden coupling, deleted constraints, over-engineering, shallow assertions, security concerns, brittle abstractions, and changes that pass locally but weaken the wider design. 16:30–17:15 — Team workflows and closing reviewThe final session turns the individual exercises into repeatable team practice. Participants discuss shared specs, reusable Claude commands, review standards, quality gates, task boundaries, context conventions, and how to decide which parts of the development workflow should be automated, reviewed, or kept manual. Practical details The training is capped at 15 engineers. Registration closes once the cohort is full. Invoices are available for employer reimbursement. Cancellation policy: full refund up to 14 days before the training, 50% refund within 14 days.