My Playwright Automation Journey with an AI Partner

If you’ve spent more than five minutes on LinkedIn recently, you’ve probably seen the panic. Everyone is talking about how AI is going to take over software testing and replace us all.

Let’s just pause for a second. Whenever I see those posts, this is the console output running in my head:

console.log(“Deep breaths. The AI Revolution is just a tool upgrade. It’ll be the new normal in a few years.”);

Here is the truth: AI isn’t here to steal your job. It’s here to do the tedious work so you can focus on the bigger picture. I recently put this to the test by building a complete Playwright automation suite using JavaScript from scratch, assisted by the Antigravity inbuilt AI agent.

Here is exactly how it went down.

Laying the Foundation

Starting a new automation framework is usually a chore because of all the initial setup. With AI, it was incredibly fast:

Quick Initialization: We kicked things off smoothly with a standard

> npm init playwright@latest.

Structured Architecture: The AI helped me build a clean Page Object Model (POM) right away. We organized locators into neat files like LoginPage.js and AdminPage.js instead of scattering them everywhere.

Smart Configuration: Because my workflows depend on earlier test steps passing, the AI helped tweak my playwright.config.js. We set the tests to run sequentially (workers: 1 and mode: ‘serial’) to prevent random failures.

The “Before AI” vs. “After AI” Reality Check

This is where things got really interesting. Before using AI, my approach to writing a script—let’s take a simple Login page, for example—was pretty basic.

How I used to write it (Before AI):

Tell Playwright to go to the login URL.
Blindly throw fill commands at the Email and Password fields.
Click Submit and hope the dashboard loads before the test times out.

javascript
test('Basic Login', async ({ page }) => {
  // Just blindly going to the URL and typing
  await page.goto('https://myapp.com/login');
  await page.locator('#email').fill('myEmail@test.com');
  await page.locator('#password').fill('myPassword123');
  await page.locator('#submitBtn').click();
  
  // Hoping the dashboard loads...
});

How we write it now (After AI):

The script verifies the page has actually fully loaded.
It checks that the input fields are visible and enabled before typing.
It explicitly waits for the network response to return a 200 OK and the dashboard URL to appear before moving on.

javascript
test('Robust Login with AI', async ({ page }) => {
  // Navigation with error handling
  await page.goto('https://myapp.com/login', { waitUntil: 'domcontentloaded' });
  
  // Explicitly waiting for the elements to be ready before interacting
  const emailInput = page.locator('#email');
  const passwordInput = page.locator('#password');
  const submitBtn = page.locator('#submitBtn');
  await expect(emailInput).toBeVisible();
  await expect(emailInput).toBeEnabled();
  
  // Now we interact
  await emailInput.fill('myEmail@test.com');
  await passwordInput.fill('myPassword123');
  
  // Smart click and wait for the successful network response and dashboard URL
  await Promise.all([
    page.waitForResponse(response => response.url().includes('/api/auth') && response.status() === 200),
    page.waitForURL('**/dashboard'),
    submitBtn.click()
  ]);
});

The AI also handled the really messy parts of my app:

Data Passing: Helped me store a dynamically generated sign-up email to use in later admin approval tests.
Smarter Clicks: Created custom methods to wait for background loading spinners to disappear before clicking.
Auto-Cleanup: Wrote scripts that automatically delete test data at the end of the run to keep the database pristine.

Automating the Flow with Jenkins

“It works on my machine” means nothing if it doesn’t run automatically in your pipeline. For that, we needed Jenkins.

What is Jenkins?

Jenkins is a popular continuous integration/continuous delivery (CI/CD) server.
It acts as a robotic traffic cop for your code—automatically triggering, building, and running your test scripts every time developers push new updates to the application.

Writing a Jenkinsfile pipeline script from scratch can be a headache, but the Antigravity agent drafted it out in minutes. Our pipeline now successfully:

Pulls the latest code automatically.
Installs dependencies and Playwright browsers.
Runs the entire test suite headlessly.
Generates a clean HTML report and emails the results directly to stakeholders.

Wrapping Up

Building this suite completely opened my eyes to where testing is headed, and the numbers speak for themselves.

Before AI: Building a framework of this size and complexity used to take me roughly 464 hours of grinding through syntax, debugging brittle selectors, and scrolling through StackOverflow.
After AI: With the AI agent handling the heavy lifting, I completed the exact same automation suite in just 144 hours.

That is the whole point of using AI. It doesn’t replace your testing fundamentals—you still need to understand your business logic and tell the AI what to do. But when it comes to the how, it is a massive time-saver. It reduces your effort by hundreds of hours and turns brittle scripts into a rock-solid automation framework.

If you’re hesitant about the AI wave, don’t be. Pick a tool like Playwright, fire up an AI assistant, and just start building. Testing is just getting an awesome upgrade.

Happy automating!