Lead the AI transition in your QA team — without being replaced by it.
A six-week, hands-on course for QA automation engineers. You build a governed Playwright framework with Claude Code — and finish running a small fleet of governed agents that builds, maintains, and reviews it. The agents propose. Your rules decide. You stay the gate.
Almost every team can watch their AI.
Barely half can judge it.
LangChain's State of Agent Engineering report: 57% of organizations already run agents in production — about 89% have observability, but only about 52% have evals.
That gap is not a footnote. It is a job description — and it reads a lot like QA.
Someone has to decide which agents ship, which tests to trust, and where AI belongs in a pipeline. This course trains you to be that someone: the engineer who runs the AI, not the one replaced by it.
Not another prompt course.
No slideware, no toy todo app, no "10 magic prompts." You build and govern a real framework, the way a real team would.
Two real apps. One governed suite.
Playwright + TypeScript against a blog and a store. Auth, CRUD, async, checkout, money math, stock — the patterns your job actually has.
Rules Claude reads. Rules Claude cannot skip.
CLAUDE.md and rule files steer the AI. Hooks enforce it with deterministic code. Prose gets "mostly followed." A hook that exits 2 is a gate. You learn which rule deserves which.
One brain. Many hands.
You don't stop at one AI assistant. By Week 6 you run subagent fleets — test designers, a triage crew, a review fleet with an adversarial verifier. Read-only by construction: agents propose, fixing stays human.
MCP-first, like 2026 works.
The first question for any tool: "Is there an MCP for it?" Jira and Playwright connect in-tool, with your permissions. Reads are free; writes are gated.
Your tests catch a real bug.
While building this course, the suite caught a real concurrency bug in the store's checkout. In Week 4, yours does too. Not staged — rediscovered, every cohort.
No API keys. No metered bills.
Everything runs on a standard Claude subscription. We even teach session hygiene as a skill — method beats raw quota.
The course you join today will not be the course it is in two months. That is the point.
Tech and AI do not stand still, and neither does this material. We track the industry — MCP, evals, Claude Code itself — and when it moves, the course moves. We keep an open adjustments log, and every gap we find becomes a lesson between cohorts. Your goal is to stay on top of the latest trends. Ours is to make sure the course keeps you there.
This course ships like software: versioned, reviewed, and honest about its own changelog.
- a3f21cAdding Docker: run your suite in a container One containerization lesson — you run tests locally in a container, because that is how CI runs them.
- f0a9d2Shipped The agentic rebuild — all six weeks Ten new lessons: subagent fleets, the full hook lifecycle (yes, a hook that blocks the session from ending), a capped headless lane, and the autonomy dial that ties them together.
- 95dafeShipped Verifiable course certificate Issued from the platform on completion.
- 7c09b1Renamed "Agentic QA Automation" The old name undersold what you build here.
- d41e88Replaced Dropped a test-management tool mid-build Its API didn't hold up. Cases now live Jira-native — and we teach the reversal, not just the result.
- ·····Ongoing Trend review every cohort MCP landscape, agent evals, new Claude Code capabilities.
Six weeks. One notch per week.
The course runs on an autonomy dial: each week your agent earns one notch more freedom, and you build the governance that makes that notch safe. Every week ends in one push to your repo that a mentor reviews.
Foundation
Meet your agent, then build the rails. You watch Claude write, run, and fix a test on its own — the agentic loop, named on day one. Then plan mode, permission rules, environment guards, and your first tests.
Framework & governance
The loop gets hands — then meets the law. Claude drives a real browser on day 1. Then Page Objects, the CLAUDE.md constitution, a self-maintaining knowledge vault, and the full hook lifecycle — including a Stop hook that won't let a session end without its worklog.
Data, APIs & test design
Tools and teammates — the agent stops guessing. Postgres and Jira connected in-tool via MCP, API testing, then your first subagent — and a three-agent design fleet working three tickets at once.
Maintenance
One brain, many hands. A triage fleet — self-heal, flaky-verify, bug-reporter — heals locators or files bugs, and never loosens an assert. The week your suite catches the store's real concurrency bug.
Integrations
Two lanes, one gate. Lane 1: CI stays deterministic — no model call decides if the build is green. Lane 2: a capped, headless drafter triages the night's runs each morning. Every external write stays human-gated. The big week.
Synthesis & capstone
Command the fleet, show the work. You build a four-agent review fleet — three reviewers plus a skeptic that kills false positives — and point it at your own six weeks of work. Then two career tasks — an ATS-ready resume and a full LinkedIn rebuild — turn it into hiring evidence.
You don't leave with notes.
You leave with a system.
- A governed Playwright framework — and the agent fleet around it — built by you, line by line, reviewed weekly.
- Your private GitHub repo, transferred to you at graduation — six weeks of real commits. That's a portfolio, not a certificate wall.
- Instruction files, hooks, subagents, and a knowledge vault you can port to your job on Monday.
- A real Jira project with tracked test cases wired to your suite.
- A one-page AI adoption plan for your team — the document that makes you the person leading this at work.
- A completion certificate — and a repo that proves more than any certificate.
Video · Lesson · Reading
Every week ships as three tracks: videos, step-by-step lessons with checklists and acceptance criteria, and readings with a growing glossary. Nothing is graded by an answer key — a mentor reviews your real pushed work.
Weekly push. Weekly proof.
Every week ends at a push gate. You push, a mentor reviews, and the next block builds on verified work — not on hope.
Propose → review → tighten
The core skill isn't prompting — it's the loop. The AI proposes, you review against your rules, and you tighten the rules or accept. By Week 6 you run that same loop over a whole fleet — the mental model of managing a team: clear contract, hard gates, freedom in the middle.
We teach what actually went wrong.
Most courses cut their failures. Ours are on the syllabus — because your production rollout will have the same ones.
A tool we dropped mid-build
A test-management tool made it into the design, then its API didn't hold up in practice. We reversed the decision and teach how to recognize that moment.
A guardrail of ours that looped
One of our own hooks got an agent stuck in a loop. Now it's the Week-2 set-piece on why guardrails need guardrails.
A test that lied to us
A green test that never tested anything — a false pass hiding in the cookie jar. Week 3 teaches you to catch it before it teaches you.
Built for working QA engineers.
This is the AI layer on top of automation skill — not a Playwright tutorial.
- You're a QA automation engineer or SDET with roughly 1–4 years of experience.
- You've written automated tests in some framework and know JS/TS basics, Git, and a terminal.
- Your company has started talking about AI in QA — and you want to lead that conversation, not survive it.
- You're brand new to test automation. Start with Codemify's Manual QA → Automation path first — this course assumes that ground is solid.
- You want theory about AI. Everything here is built, pushed, and reviewed.
- You're looking for "10 prompts that write your tests." That course exists. It isn't this one.
Be the engineer who runs the AI.
Small cohort — every weekly push gets a mentor's eyes. Six weeks from now you have a governed framework, a review fleet you command, a portfolio repo that's yours, and an adoption plan with your name on it.
Discount applied automatically at checkout — no code needed.
