From Drift to Trust: A Test-First AI Dev Workflow - Master Class (In-Person & Online)

Abstract

Can you trust the code your agent just wrote? Probably not on sight. That's what tests are for, so you ask the agent to write those too. Now you have twice as much code you can't vouch for, and a cook grading his own dish.

A few days later, your agent refactors a service and breaks 42 test files. It investigates, burns tokens and time, then rewrites them until they're all green. How can you tell if these changes were legitimate or if they just swept a bug under the carpet? Review the tests? No, not again.

That's a testing strategy problem before it's an AI-assisted development problem.

During this hands-on workshop, on an Angular app, you will:

• Cook tests that focus on behavior and survive refactorings
• Leverage the tools and patterns that let agents write tests and efficiently self-debug
• Discover a test-first AI-assisted dev workflow that keeps agents from drifting, from manipulating you into accepting their design, and from exhausting you with code review and context switching

Prerequisites

Exercises run on an Angular app, but the patterns and the workflow aren't Angular-specific; we call out the React equivalents as we go. You don't need to be an Angular expert; you do need to be comfortable reading it.

For frontend developers, tech leads, and architects who:

• Are drowning in code review
• Get headaches from tests cluttered with mocks
• Are worn down by babysitting agents and context switching all day
• Want a trust strategy that holds up when most of the code is written by agents

Bring Your Own Agent: This is not a workshop about one vendor's tool.

Every pattern, test technique, and workflow step works with any agent and any harness: Claude Code, Codex, Cursor, Copilot, Gemini CLI, or whatever ships next month.

Where an example is tool-specific, such as a hook, a skill file, or an MCP server, we cover the underlying mechanism and its equivalent elsewhere, so you can port it to your team's setup on Monday.

No agent, or not enough quota? A license can be provided for the day.

Agenda

1. Write Tests Worth Trusting (Hands-On)

A bad testing strategy, or poorly generated tests, confuse agents and humans alike. The game-changing craft: tests that focus on behavior, not implementation details.

• Vitest Browser Mode: Real rendering, real interactions
• Actionability checks: Catching what JSDOM can't
• Fakes over mocks: Test doubles that survive refactors and keep agents honest
• Gloves: Handle components without touching their internals, so the agent can refactor underneath your tests instead of rewriting them
• Object mothers & readable setup: Specs an agent can extend without guessing
• Designing tests that cut review fatigue: Readable enough to review at a glance, so you're not re-reading every line your agent writes

2. Fast & Precise Feedback for Your Agent (Hands-On)

A trustworthy test suite is almost useless if feedback arrives slowly or vaguely. Wire up tools that give your agent quick, precise signals instead of letting it drift on stale or noisy output.

• Runtime visibility with WallabyJS & Chrome DevTools MCP: Give your agent eyes at runtime
• Testronaut & the Playwright agent CLI: Browser-level feedback the agent can drive itself
• Focused, token-efficient runs

3. Charted Coding: Beyond AI-Assisted TDD (Hands-On)

Charted Coding is our flow for keeping every step small enough to review in a single pass, and cheap enough to revert when the agent takes a wrong turn. TDD is one step of it, not the whole of it.

• Design doc first: Decide the shape before the agent shows you one, so its draft can't anchor yours
• Scaffold → Red → Green → Refactor: One step at a time, with the agent driving and the suite keeping it honest
• Hooks: Enforce the workflow through tooling instead of your patience
• Incremental commits: Review a small diff, or roll back to the last one, instead of arguing with a 900-line pull request
• When to intervene, when to let it run: The judgment calls

4. Skills You Can Prove (Live Demo)

Writing tests, debugging, and refactoring each need their own agent skill. But how do you know a skill really works?

• Evaluating skills with Skillgrade
• Catching regressions when you edit a skill, or the model updates

5. Trust Strategy (Discussion)

Now that you know all the mechanics, the real question is: what do you actually trust, and what do you verify? Trusting nothing costs as much as trusting everything.

• What to test and how: Narrow vs. Wide and what earns which
• The trust ladder: What you review line by line, what you review by reading the spec, and what you let run
• Aligning on a consistent trust strategy within a team