Forem: Nikolay Advolodkin

Decoupling Temporal Services with Nexus and the Java SDK

Nikolay Advolodkin — Thu, 02 Apr 2026 13:50:51 +0000

Your Temporal services share a blast radius. A bug in Compliance at 3 AM crashes Payments, too, because they share the same Worker. The obvious fix is separate services with HTTP calls between them - but then you're managing HTTP clients, routing, error mapping, and callback infrastructure yourself.

We published a hands-on tutorial on learn.temporal.io where you take a monolithic banking payment system and split it into two independently deployable services connected through Temporal Nexus.

You'll learn:

Nexus Endpoints, Services, and Operations from scratch
Two handler patterns for different use cases
How to swap an Activity call for a durable cross-namespace Nexus call

The caller-side change is minimal - the method call stays the same:

// BEFORE (monolith - direct activity call):
ComplianceResult compliance = complianceActivity.checkCompliance(compReq);

// AFTER (Nexus - durable cross-team call):
ComplianceResult compliance = complianceService.checkCompliance(compReq);

Same method name. Same input. Same output. Behind that swap: a shared service contract, a Nexus handler, an endpoint registration, and a Worker configuration change.

Here's what the Nexus handler looks like - it backs the operation with a long-running workflow so retries reuse the existing workflow instead of creating duplicates:

@OperationImpl
public OperationHandler<ComplianceRequest, ComplianceResult> checkCompliance() {
    return WorkflowRunOperation.fromWorkflowHandle((ctx, details, input) -> {
        WorkflowClient client = Nexus.getOperationContext().getWorkflowClient();
        ComplianceWorkflow wf = client.newWorkflowStub(
            ComplianceWorkflow.class,
            WorkflowOptions.newBuilder()
                .setTaskQueue("compliance-risk")
                .setWorkflowId("compliance-" + input.getTransactionId())
                .build());
        return WorkflowHandle.fromWorkflowMethod(wf::run, input);
    });
}

The tutorial includes a durability checkpoint: you kill the Compliance Worker mid-transaction, restart it, and watch the payment resume exactly where it left off. No retry logic, no data loss across the namespace boundary. Java SDK, runs entirely on Temporal's dev server.

Try it

Secrets Behind 3 Years of Automation Success!

Nikolay Advolodkin — Mon, 29 Sep 2025 00:07:11 +0000

I'm Nikolay Advolodkin from UltimateQA, and in this article I unpack a two-year journey I led alongside our automation engineer Oles Nikaniuk, on a massive European enterprise migration. If you watched the episode, you already know the highlights; if not, this post compresses everything—decisions, processes, pitfalls, and the exact engineering moves that produced measurable Automation Success across UI, API, and integration testing.

💌 If you're interested in more JavaScript testing tips, click here to subscribe to our newsletter.

Project overview 🧭
Choosing the right tools 🛠️
Building the API testing strategy 🔐
CI/CD and parallelization ⚡
Schema management: RAML → OpenAPI → Types 🔁
UI testing: challenges & lessons 🖥️
Mobile testing note 📱
ROI and metrics 📊
Developer experience and static code analysis 🧩
Lessons learned & culture 🤝
How to replicate this — a step-by-step plan 🛣️
FAQ ❓
Conclusion ✅

Project overview 🧭

We supported three major areas inside the customer’s ecosystem: a supply-chain/logistics application (One Network), an internal recommendations platform built on a low-code environment (Appian), and a central integration layer built on Mulesoft that ties HR, finance, legal, transportation and other core systems together. From the outset, the project was a multi-year migration from legacy internal systems to modern stacks. Achieving Automation Success in a landscape like that required a different approach for each domain.

The supply chain product had long, manual end-to-end workflows that made test setup painfully slow. A single manual reproduction of a workflow could take me nearly an hour on the first try, and even after familiarity it was still often 5–10 minutes. Multiply that by dozens of scenarios and you see why teams were frustrated and why manual testing was unsustainable. In this environment Automation Success wasn't optional—it was mandatory.

The recommendations platform added complexity because many flows involved multiple users and concurrent browser sessions. That forced us to solve test orchestration, user state, and credential management in an automated way. Finally, the integration (Mulesoft) work required a focused API testing strategy: functional, contract/schema testing, and security tests (including fuzzing, header combinations, JWT handling, and policy enforcement checks). The combination of UI and API work led us to define a robust testing strategy that prioritized quick feedback, maintainability, and developer collaboration—three fundamentals to achieving Automation Success.

Choosing the right tools 🛠️

Picking tooling was one of our most consequential early decisions. We started with an objective evaluation rather than choosing tools we happened to know. The organization was primarily a .NET shop so Selenium with C# was the expected choice. We also evaluated Playwright (TypeScript and C#), Cypress (TypeScript), and Selenium (C#) in a PC-style comparison against criteria like testing capabilities, reporting, CI compatibility, community support, and speed.

I’ll be blunt: engineers frequently pick the tool they already know and shoehorn it into every problem. That approach kills Automation Success. Instead, we scored tools against the project requirements. Playwright with TypeScript won for our environment because it handled cross-domain navigation (important for Salesforce-like flows), supported parallel workers and sharding for fast CI runs, and offered a unified test runner that worked well for both UI and API tests. Cypress had strengths, and Selenium still has a place—especially when enterprises need a “one tool to rule everything” approach that ties into Appium for mobile/desktop coverage—but Playwright fit our needs best.

Playwright C# existed, but many features are more mature in the TypeScript implementation. Choosing a language is not just personal preference—it's about community, plugins, and long-term viability. We deliberately accepted a learning curve to achieve the Automation Success we wanted.

Building the API testing strategy 🔐

Because Mulesoft acted as the central integration platform, API testing became our primary focus. We designed a testing approach that included:

Functional tests for endpoints (parameters, responses, error paths)
Contract/schema validation (living OpenAPI-driven tests)
Security tests: missing/invalid headers, authentication checks, JWT forging, fuzzing
Boundary tests and negative cases (malformed payloads, rate limits)

One early, practical win was catching integration policy mistakes. For example, one API should reject requests without client ID and secret—this policy was occasionally omitted. Automated security checks uncovered such lapses quickly, preventing potentially exploitable behavior from reaching production. That is tangible Automation Success: preventing real-world risks through automated verification.

We separated functional test runs from security test runs to keep fast feedback loops during development while still running thorough security suites as part of every build. Over time this matured into nearly 1,000 API tests that run quickly in CI.

CI/CD and parallelization ⚡

Fast, reliable CI is the engine of Automation Success. Our CI/CD lived in Azure DevOps. To get from hundreds of tests to sub-5-minute runs we used three techniques together:

Playwright sharding (CLI shard indexes)
Azure DevOps job matrix (multiple instances of the same job)
Playwright worker processes inside each job

Here's a simplified example of what we did: create two CI jobs in the pipeline, each with a job matrix producing multiple instances. Each job runs Playwright with shard indexes so tests partition across instances. Inside each job we enabled multiple Playwright worker processes. In one realistic configuration we ended up with two jobs, each spinning up two workers and each worker running two shards—yielding multiple parallel consumers that execute independent subsets of tests. The end result: an 846-test suite executing in roughly 4 minutes—about 0.3 seconds per test on average for our API-focused checks.

That kind of performance unlocked real, measurable Automation Success. It meant developers received fast feedback on commits, builds either succeeded quickly or failed fast, and our testing suite became part of everyday development rather than an afterthought.

Schema management: RAML → OpenAPI → Types 🔁

Managing API schemas was one of the most time-consuming and impactful parts of the project. Mulesoft uses RAML for documentation. The native conversion from RAML to Swagger v2 existed, but Swagger v2 is outdated and many modern tools expect OpenAPI v3. Additionally, the intermediate Swagger 2 files Mulesoft produced sometimes contained custom properties that violated the spec, which broke automated conversion tools.

Our transformation pipeline looked like this:

Convert RAML → Swagger v2 (generated by Mulesoft)
Fix non-standard custom properties injected by Mulesoft (custom transformation code)
Convert Swagger v2 → OpenAPI v3
Generate JSON Schema artifacts from OpenAPI v3
Generate TypeScript types and interfaces from JSON Schema

Generating TypeScript types allowed us to import response and request types directly into our tests and API clients. When a schema changed, TypeScript would flag mismatches in the tests at compile time—forcing an immediate, visible update. This reduced the maintenance burden and increased the accuracy of our contract validations. In short: putting schemas at the center enabled Automation Success by making tests resilient to change and keeping test code synchronized with API contracts.

We considered AI to help during the transformation. AI assisted in designing the pipeline and resolving tricky transformation edge cases, but the core transformation needed deterministic tooling and custom code to handle Mulesoft’s non-standard properties. The extra investment paid off: the living documentation approach drastically reduced schema-related bugs between integrations.

UI testing: challenges & lessons 🖥️

UI automation for supply chain and the Appian platform had unique challenges. Workflows were long and brittle, required heavy test data setup, and involved multi-role scenarios where one user’s actions needed to be visible to another user in the same scenario. Creating and maintaining end-to-end UI tests was harder and delivered less ROI than API tests.

Key issues we solved in UI automation:

Managing multiple sessions and credentials for role-based flows
Stabilizing selectors in a low-code environment that frequently changed DOM structures
Speed: UI tests are slower and more fragile, so we limited the number of full end-to-end UI tests

Playwright handled cross-domain and session management well, which is why it beat alternatives like Cypress for some of our use cases. However, UI automation’s overall cost-benefit ratio was lower than API testing—so we focused UI automation on the highest value end-to-end paths (happy paths and critical flows) and relied on robust API testing for the majority of verification logic. That combination delivered balanced Automation Success.

Mobile testing note 📱

A short but important note: Playwright is not a replacement for native mobile testing. If you need deep native mobile compatibility, use the native frameworks (XCUITest for iOS and Espresso for Android). Native test frameworks are fast, well-supported by device vendors, and provide the most reliable results for mobile behavior. Appium and similar tools have their place, especially when you need cross-platform coverage, but for the best performance and value we recommend native frameworks for mobile automation.

Mixing web automation and mobile automation into one “golden hammer” rarely produces the best Automation Success. Choose the right tool for the job.

ROI and metrics 📊

Numbers tell the story better than words. Starting from zero, we implemented security and functional pipelines and grew the automation suite to the following:

571 security tests (from 0)
~850 total automated tests (at times approaching 1,000)
846 tests executing in about 4 minutes
~56 hours saved per release (assuming conservative per-test manual execution times)
Over 100 production bugs prevented from leaking through (tracked via metrics)

We measured time saved, bug prevention, and deployment velocity improvements to quantify Automation Success. Because the API suite runs as part of each build and deployment, developers get immediate feedback. Security regressions that would previously require manual verification are now caught automatically, and schema mismatches show up before they can break downstream consumers.

Developer experience and static code analysis 🧩

Automation Success wasn't just about tests—it also involved improving the developer experience. We built custom static code analysis checks tailored to the Mulesoft environment and team best practices. These checks run in the pipeline and enforce standards (we had roughly seven sets of important rules). If a pull request violates the rules, the pipeline shows a red status and the PR cannot be merged until issues are fixed.

That enforcement had two effects:

It improved long-term code quality and prevented anti-patterns that would create test flakiness.
It sparked collaboration. Developers started asking questions, raising counter-proposals, and working with us to adjust the rules where appropriate. Static analysis became a conversation starter, not just a blocker.

Being the “automation person” turned from a lone gatekeeper role into a trusted technical partner for the development teams. That cultural shift is one of the hardest but most important parts of Automation Success.

Lessons learned & culture 🤝

I want to distill the practical lessons that guided our path to Automation Success. These are the behavioral and strategic takeaways that matter as much as technical choices.

Lesson 1 — Collaborate, don’t silo

“Without collaboration... you will reach nothing.” This quote became our mantra. Automation is a team sport. Tests succeed when developers, testers, product owners, and operations agree on goals and share responsibilities. Don’t try to be a solo hero.

Lesson 2 — Expand your scope responsibly

Don’t be afraid to go beyond your job description if you see a systemic issue you can fix—static analysis, schema pipelines, or CI improvements. Those investments create outsized value and make you a far more effective contributor.

Lesson 3 — Choose tools objectively

Throw away your biases. Evaluate tools against real requirements, not personal comfort. Picking the right tool may require team training, but the long-term returns are worth it.

Lesson 4 — Automate the things that matter

Prioritize API and integration tests where they provide the fastest feedback and highest value. Use UI tests for critical, high-impact flows and keep their number limited to reduce maintenance costs.

Lesson 5 — Make schemas the source of truth

Automated contract validation and generated types keep your tests synchronized with the API. Living docs and generated types reduce a category of bugs that are otherwise hard to find until integration time.

Lesson 6 — Fast feedback loops win

Optimize for speed in CI. Sharding, workers, and a smart pipeline architecture turn tests from a drag into a productive, quick feedback tool—key to Automation Success.

How to replicate this — a step-by-step plan 🛣️

If you want to reach Automation Success in a large, complex enterprise environment, follow these practical steps we used (abbreviated and actionable):

1. Inventory: Catalog systems, integrations, and critical flows. Identify the “integration core” (e.g., Mulesoft) and prioritize it.
2. Tool evaluation: Build an objective scoring matrix. Compare tools against real criteria—CI support, cross-domain support, community, performance, mobile needs, language support.
3. Start small: Implement API tests first for critical integrations. Keep security tests separate from fast functional tests initially.
4. Schema-first: Make API schemas the canonical source. Automate conversions (RAML/Swagger/OpenAPI) and generate types to catch mismatches early.
5. Pipeline design: Use CI job matrices, Playwright sharding (or equivalent), and worker processes. Aim for sub-10-minute full runs for your primary suites.
6. Static analysis: Create code checks tailored to your platform and enforce them in PRs to prevent anti-patterns.
7. Limit UI scope: Automate only the highest-value E2E flows. Rely on API checks for the bulk of validation.
8. Collaborate: Engage developers and stakeholders early. Use failing tests as conversation points, not blame.
9. Measure ROI: Track test coverage, execution time, bugs prevented, and time saved per release to quantify Automation Success.
10. Iterate: Revisit tooling and practices regularly—what's optimal now might change in two years.

FAQ ❓

Why did you choose Playwright with TypeScript?

Playwright with TypeScript offered the best combination of cross-domain support, test runner integration, sharding, and community maturity for our needs. It handled both API and UI workflows well and enabled rapid CI parallelization. Choosing a language with strong community support (TypeScript) also mattered for long-term maintainability and plugin support—key to Automation Success.

Could you have used a different stack and still reached Automation Success?

Possibly. But the point is not which tool is objectively best—it's to pick the one that fits your requirements and team and then commit. If API testing were the only concern, a purpose-built API tool might be more efficient. If mobile native tests are required, native frameworks are preferable. Automation Success comes from aligning tool choice with constraints and goals.

How did you keep UI tests stable in a changing low-code platform?

We limited the UI test surface area to high-value flows, used resilient selectors, built reusable page objects, and relied on API tests for most validation. We also collaborated closely with developers to stabilize parts of the UI that mattered for automation.

What about flaky tests—how did you control them?

Reduce flakiness by shrinking UI test scope, improving selectors, adding retries sparingly, and ensuring tests are deterministic. API tests were naturally less flaky and were the backbone of reliable CI. Fast feedback and clear logs from the Playwright test runner helped root-cause flakiness quickly.

Did you involve the development team in test ownership?

Yes. Static code analysis and living schemas made APIs and patterns clearer. Developers began collaborating—fixing failing contract tests, updating schemas, and engaging in design conversations. That shared responsibility drove Automation Success.

Any advice for teams with no TypeScript experience?

Evaluate the cost of training versus the long-term benefits. If your team is heavily invested in C#, you might pick the best-supported C# tool and invest in good practices. But if you want the Playwright feature set and community, training the team can pay off in better Automation Success later.

How important was reporting and logging?

Very important. We relied on Playwright’s built-in traceability, logs, and the test runner’s reporting. For API clients that circumvented the test runner, we lost logs and traceability—another reason to prefer a unified runner like Playwright for most of our tests.

Conclusion ✅

Automation Success is not a single technology choice or a single architectural tweak. It’s the result of a focused strategy: pick the right tools for the problem, invest in living documentation and schema-first pipelines, build fast CI, enforce quality through automated code checks, and—most importantly—collaborate with your team. Those are the pillars that helped us go from nothing to nearly a thousand automated tests, fast CI runs, over a hundred prevented production bugs, and significant time savings.

If you’re starting a similar journey, begin with an objective assessment of your needs, prioritize API-first automation, and design a CI pipeline that gives fast feedback. Invest in schema generation and type safety so your tests are maintainable and reliable. Lastly, be the person who builds bridges across teams.

Automation Success depends on people as much as on code!

Thank you! 😉

Master Web Development with GitHub Spark AI

Nikolay Advolodkin — Thu, 25 Sep 2025 00:02:51 +0000

Hi — I'm Nikolay Advolodkin, Chief Engineer at Ultimate QA. In this guide I'll walk you step-by-step through how I used GitHub Spark AI and GitHub Copilot agents to build, test, and deploy a Next.js e-commerce web application with CI/CD and automated tests. This is a practical, hands-on walkthrough that captures the exact workflow I use with AI-powered tools, plus best practices and exercises so you can reproduce the same results in your own projects.

If you're interested in more JavaScript testing tips, click here to subscribe to our newsletter

🚀 What You'll Build and Why It Matters
🧭 Overview: Tools and Tech Stack
🛠️ Getting Started with GitHub Spark
💡 UI Mode, Code Mode, and Assets
🔧 Working Locally: Visual Studio Code & GitHub Copilot
🗂️ Project Setup & Running the App Locally
🧾 Copilot Instructions & Context Engineering
🧪 Automated Tests with Playwright (and How AI Helps)
🔁 Branches, Pull Requests, and AI-Powered Code Reviews
⚙️ Implementing CI/CD with GitHub Actions
🧭 Best Practices & Guidance for AI-Assisted Development
🎯 Exercises & Challenges (Hands-on Learning)
❓ FAQ
🔚 Final Thoughts and Next Steps
📣 Want Help or More Resources?

🚀 What You'll Build and Why It Matters

By the end of this tutorial you'll be able to:

Use GitHub Spark to generate a full-stack web app using natural language prompts.
Run the project locally with Visual Studio Code and GitHub Codespaces.
Set up GitHub Copilot and Copilot coding agents to author code, write tests, and review pull requests.
Create automated Playwright tests (both end-to-end and API tests) and have Copilot generate and run them.
Implement a CI/CD pipeline with GitHub Actions that runs tests and deploys your app.
Orchestrate agentic workflows so AI performs many routine tasks while you remain the context engineer and reviewer.

This workflow dramatically increases development velocity and helps teams shift left on quality — but it requires clear context, review discipline, and configuration of the right AI settings.

🧭 Overview: Tools and Tech Stack

The core technologies and services I use in this workflow are:

GitHub Spark — AI-driven, no-code/low-code app generator inside GitHub for rapid prototyping and app generation.
GitHub Copilot (and Copilot Chat / Copilot coding agent) — AI pair programmer and agent to author code, create branches, and implement issues.
Visual Studio Code — The IDE where you install Copilot extensions and manage local development.
GitHub Codespaces — Containerized cloud development environments so "works on my machine" disappears.
Next.js — React + server-rendered frontend framework used for the e‑commerce demo app.
Playwright — End-to-end and API testing framework used for automated tests.
GitHub Actions — CI/CD pipelines for test execution and deployments.

🛠️ Getting Started with GitHub Spark

Getting started with GitHub Spark is straightforward if you follow the necessary account steps:

Create a GitHub account (if you don't already have one).
Subscribe to GitHub Pro Plus (or an equivalent plan that grants access to GitHub Spark and Copilot). The Pro Plus plan includes Spark message credits (e.g., 375 messages per month), multiple active sessions, and unlimited manual edits.
Navigate to github.com/spark to begin composing natural language prompts and generating applications.

When you open Spark, you'll see a chat-like prompt interface. Type a clear, specific description of the app you want — the clearer your requirements, the more deterministic the output. For my e-commerce example I supplied a detailed prompt describing:

Technology stack (Next.js, TypeScript, simple REST API endpoints)
Key UI components (product cards, cart badge, checkout placeholders)
Testing and CI expectations (Playwright tests and a GitHub Actions workflow)

Spark then generates a working app you can preview, tweak the theme for, or open in Codespaces for deeper edits.

💡 UI Mode, Code Mode, and Assets

GitHub Spark provides multiple views that accelerate iteration:

UI mode — Click elements on the rendered app to edit text and trigger Copilot to change the UI (theme swaps are fast and visually immediate).
Code mode — A VS Code-like file explorer and editor inside Spark for direct code edits.
Assets — Upload logos, images, audio files and manage the application's data and API backend directly from the Spark UI.

These modes let you alternate between high-level composition and low-level code changes without context switching between tools.

🔧 Working Locally: Visual Studio Code & GitHub Copilot

After Spark generates an app, clone the repository and open it in Visual Studio Code (VS Code). I recommend the following setup steps:

Install VS Code from code.visualstudio.com.
Install the GitHub Copilot extension and the Copilot Chat extension (Command/Control+Shift+X → search for "Copilot").
Authenticate Copilot with your GitHub account when prompted.
Open the Copilot chat with Command/Control+Shift+I to paste errors, ask for fixes, and run agentic commands.

When you first run into build or runtime errors (which is likely on diverse developer machines), copy error messages into Copilot Chat and put the agent into agent mode to have it suggest or even run remediation steps. Use high-quality models for software tasks (GPT-5 or Claude Sonnet 4+ where available) to reduce hallucination and iteration cycles.

🗂️ Project Setup & Running the App Locally

A typical setup sequence after cloning the repo:

Open Terminal in the repo root.
Run npm install to fetch dependencies.
Run npm run build to build the project.
Run npm run dev to start the development server (Next.js will typically serve on localhost:3000).

If the app loads but displays a blank page, open the browser console, copy the error output, and paste it into Copilot Chat to get targeted fixes. This is where Copilot shines — iterative troubleshooting that would otherwise take a lot longer to debug manually.

🧾 Copilot Instructions & Context Engineering

To make Copilot a reliable, consistent collaborator, you must provide it context. The single most important artifact here is a Copilot instructions file placed inside the .github folder of your repo. These instructions define how Copilot should behave across the project and act like a project's AI standard operating procedures.

Key ideas to include in your Copilot instructions:

Repository preferences (coding style, TypeScript rules, naming conventions)
Testing directives (when to create browser tests vs API tests; example commands for running tests)
CI behavior and commands to run in background terminals
Security and data sensitivity constraints
How to handle TypeScript typing and linter warnings

This process is often referred to as context engineering: curating the context the AI needs to make correct choices and avoid costly assumptions. You can generate a starter Copilot instructions file by creating an issue in GitHub and inviting Copilot as your AI pair programmer — Copilot can propose and even implement a recommended configuration automatically.

🧪 Automated Tests with Playwright (and How AI Helps)

Automated testing is vital but often disliked because it is repetitive. With agentic AI we can delegate much of the heavy lifting, but we still must guide, review, and correct the output.

I recommend this approach when creating tests with Copilot:

Create a small, explicit test prompt that lists the required tests. For the workshop I limited tests to two initial Playwright specs (one browser e2e and one API test).
Remove existing test files and Playwright config so Copilot generates the entire testing stack from scratch. This often leads to a better, more coherent test suite.
Feed your Copilot instructions plus the Playwright prompt into Copilot Chat in agent mode and ask it to create tests, update configuration, and run them.

Important testing caveats:

AI tends to over-generate tests for browser automation and may produce nonsensical or brittle tests. Keep the test set small and iterate.
For API tests, do not use the browser — instruct the AI explicitly to use direct HTTP requests (fetch or Playwright's API testing features).
Ask Copilot to run browser tests with no reporters (in CI) to avoid interactive prompts that block non-interactive runs.
Always review tests manually and tune timeouts (I prefer shorter timeouts like 10000ms instead of 30000ms).

Example of generated tests I reviewed:

Browser spec: verifies the home page displays featured products and that adding an item increments the cart badge.
API spec: verifies the GET /products endpoint returns the full product list and required properties.

Once tests are generated and validated locally, commit them into a branch and push the changes so CI can pick them up.

🔁 Branches, Pull Requests, and AI-Powered Code Reviews

When Copilot or you push a change, create a pull request as usual. GitHub Copilot can be configured to automatically review pull requests and provide suggested improvements.

Best practices for AI-assisted code reviews:

Treat AI suggestions as recommendations, not commandments. Validate each suggestion against project goals.
Use the review comments to teach Copilot via the repository's instruction file — over time Copilot's suggestions will better align with your patterns.
Accept only high-confidence changes; leave nitty-gritty style or architectural changes to human reviewers when necessary.
Use an additional third-party tool like CodeRabbit if you want another perspective, but ensure you are not automerging without human approval.

A real example: Copilot suggested replacing a text cart indicator with a card badge. That suggestion was sensible generally, but in my specific test the expectation relied on text. I ignored that suggestion and explained why in the PR conversation. This is how you guide the AI and keep it aligned to project logic.

⚙️ Implementing CI/CD with GitHub Actions

Once checks and tests are validated locally, the next step is CI. I recommend recreating the CI workflow with Copilot rather than copying an existing one so the actions reflect your repo layout and test commands.

High-level CI flow I use:

Checkout code and set Node version.
Install dependencies and build the app.
Start a web server to serve the built app (for browser tests).
Run Playwright API tests (non-browser) and browser tests with no reporters in CI mode.
Upload test artifacts or coverage reports as needed.
Deploy on successful test completion (optional; can be gated behind manual approvals).

To validate your CI pipeline, delete the old workflow, create a new one via Copilot prompts, and let Copilot iterate until tests pass. You will know you’ve succeeded when GitHub Actions reports a passing run for all checks on your branch.

🧭 Best Practices & Guidance for AI-Assisted Development

Here are concise, practical rules I follow when I integrate AI into my software development lifecycle:

Provide clear context: descriptive comments, project standards, and constraints reduce hallucination.
Validate suggestions: always review generated code and run tests locally and in CI.
Keep AI as collaborator: treat Copilot as a junior-to-mid-level developer to offload routine tasks; you remain lead architect and reviewer.
Maintain code quality: refactor AI-generated code as needed and enforce linters and type checks.
Design Copilot instructions: the better your instructions file, the more reliable Copilot behavior becomes.
Prefer API tests for backend logic: instruct Copilot to use direct network requests for API verification.

🎯 Exercises & Challenges (Hands-on Learning)

Practice is how you internalize this workflow. Here are incremental exercises I recommend:

Use GitHub Spark to generate a simple app using a prompt I provide (or your own): clone it, run npm install, npm run dev, and confirm it renders.
Create a Copilot instructions file in .github/copilot-instructions.md setting project standards and test commands.
Use Copilot Chat in agent mode to create two Playwright tests: one browser spec and one API spec. Review and fix them.
Create an issue in your repo and add Copilot as an AI pair programmer. Have Copilot implement the issue on a new branch and review the PR.
Delete any existing workflow files in .github/workflows and ask Copilot to implement a CI pipeline that runs your tests. Iterate until CI passes.

These exercises reflect the exact steps I use in production workshops and client implementations. Repeat them until you feel comfortable orchestrating multiple agents across tasks.

❓ FAQ

How do I get access to GitHub Spark?

Sign up for a GitHub account and subscribe to a plan that includes Spark (for example Pro Plus). Then visit github.com/spark to begin building apps using natural language prompts.

Which Copilot model should I use for software development?

Use the highest-accuracy models available to you for complex software tasks: GPT-5 if accessible, or Claude Sonnet 4+ for focused code generation and debugging. These models reduce hallucination and iteration cycles.

Can Copilot create tests reliably?

Copilot can generate functional tests quickly, but you must verify and refine them. It is stronger at API tests than complex browser end-to-end suites. Use small, specific prompts and incrementally validate tests.

Should I trust Copilot's PR review suggestions?

Consider Copilot's suggestions as a second pair of eyes. Accept suggestions that align with your project's logic and style. Use the PR conversation to correct or reject suggestions and refine Copilot instructions.

How do I avoid flaky or nonsensical tests generated by AI?

Provide explicit instructions (e.g., "Use direct network requests for API tests" or "Do not rely on visual timing delays"), keep tests focused on essential behavior, and enforce timeouts and stable selectors. Regularly refactor tests to remove brittleness.

Is this approach suitable for enterprise teams?

Yes — with governance. For teams, codify Copilot instructions, add test and security gating in CI, and keep human reviewers in the loop before merging to main. Use Codespaces to ensure consistent developer environments.

🔚 Final Thoughts and Next Steps

AI tools like GitHub Spark and Copilot are game changers for web development. They help you rapidly prototype apps, automate repetitive tasks, and scale testing and CI/CD. But AI is best used as a partner — not a replacement. Your role as a context engineer, reviewer, and orchestrator remains essential.

Short‑term action items I recommend:

Sign up for GitHub Pro Plus and explore GitHub Spark for a weekend prototype.
Install Copilot and Copilot Chat in VS Code and run the exercises from the previous section.
Create a robust Copilot instructions file tuned to your project and invite Copilot to implement a small issue.
Practice converting manual tests into Playwright API tests and run them in CI with GitHub Actions.

Longer term, aim to become the team’s AI integrator: curate instructions, maintain test hygiene, and lead the cultural shift to AI-augmented engineering. This skillset will place you at the forefront of modern software development.

📣 Want Help or More Resources?

If you found this useful, follow me on social media for more tutorials, sign up for any newsletters I share, and consider reaching out if your organization needs help implementing automated testing, CI/CD, or AI‑driven workflows. I consult and train teams on robust, practical AI integration across JavaScript, TypeScript, C#, and Java ecosystems.

📱 Social Medias:

Linkedin Nikolay
Linkedin UltimateQA
YouTube Channel
Instagram
Newsletters

If you try the exercises, please provide feedback on what worked and what didn't — it's the best way I can refine further tutorials and help you even more.

Peace 🕊️ — and happy building!

Revolutionizing Test Automation with Vibium AI: Jason Huggins

Nikolay Advolodkin — Mon, 22 Sep 2025 19:24:30 +0000

This article recaps and expands on an in‑depth conversation with Jason Huggins (creator of Selenium) hosted by Nikolay Advolodkin. In that discussion Jason lays out a bold vision for Vibium AI: a system that learns how your application is actually used, builds a map of workflows, and then generates and runs tests intelligently—more like a self‑driving car with a steering wheel than an autopilot that obliterates human control.

If you're interested in more JavaScript testing tips, click here to subscribe to our newsletter

🛠️ Is Selenium obsolete?

Short answer from Jason: no. Selenium is very much alive under the hood—it's the foundation for browser automation that many newer tools still rely on. That said, Selenium has two problems: perception and marketing. It's been around for two decades, and people often use age as a shorthand for "replace it." Jason warns that perception can overshadow substance: projects with corporate backing can flood the market with shiny marketing materials, and open source projects like Selenium—without a deep marketing war chest—get unfairly labeled "old."

Technically, Selenium continues to evolve. The WebDriver BiDirectional protocol (WebDriver Bidi) adopted lessons from tools like Puppeteer and Playwright; it's baked into modern tooling and modern browsers. Jason points out that some of what people think of as "new" is actually lessons harvested from Selenium's long history—so yes, Selenium is still "inside" many stacks in visible and invisible ways.

"Selenium is not obsolete because I'm literally depending on it as the base layer for the stuff that I'm working on."

🚗 Beyond Selenium: The vision of Vibium AI

Jason frames Vibium AI using a persisting metaphor: a self‑driving car that still includes a steering wheel. That line captures the product's core philosophy—automation that doesn't remove human agency, just reduces repetitive, error‑prone work.

At a low level you could still write traditional tests in libraries—vibm.py, vibe.ts, vbm.js—if you want. At a high level, the platform aspires to do the heavy lifting for you: build the tests, run them, triage failures, and bootstrap more coverage from real usage.

Jason describes three developer archetypes in this emerging age:

Traditional coders who write code manually.
Vibe coders who prompt LLMs to write code with minimal direct interaction (the "robot takes the wheel" extreme).
AI‑assisted engineers who keep one foot in both worlds—using AI to do most work while reviewing and shaping outputs.

Vibium AI targets the middle ground and the extremes: it aims to help the AI‑assisted workflow and make fully automated workflows safer and more testable.

🗺️ How Vibium AI works: App maps and model‑based testing

The heart of Vibium AI is the idea of an application map: record real user interactions (or dev loop interactions), convert those telemetry events into a model of the app, then use that model to generate intelligent tests and prioritize execution.

Here's the practical flow Jason describes:

Instrument the app so important user actions emit events (page visits, button clicks, form submissions, zooms in a 3D view, etc.).
Aggregate those events (telemetry, analytics, or custom logs) to build a graph representation of the application's pages and states.
Feed that graph into an LLM (the "LLM washing machine") which can reason about workflows like "can a user buy a product?" and synthesize end‑to‑end tests using the recorded paths.
Run the generated tests and surface results with richer triage that understands when the system had to route around unexpected UI changes.

This is model‑based testing revisited with modern tools. Historically, building the model was expensive and tedious; with LLMs, that barrier drops dramatically. The model lets you move from guesswork (have an LLM poke your site repeatedly trying to "figure out" how to buy something) to reasoned, reproducible execution that leverages real workflows and telemetry.

"By recording all these events, you're effectively creating a model of your application. Once you have a model, you get automated tests for free."

♟️ Concrete demo: TestTrack and the 3D chess example

Jason created a demo site—testtrack.org—to explore tricky UI scenarios. One module was a 3D chess simulation rendered with three.js. Three.js content and other complex interactive UIs are intentionally hard to test with classical DOM‑centric approaches, so they make a perfect stress test for the Vibium AI approach.

That 3D chess module forced Jason to think about what “testability” means: zooming, clicking, moving pieces, and firing events for every important action. For Vibium AI to interpret interactions, the app must produce structured telemetry about user actions—like "user zoomed to location X" or "piece moved from A3 to B4". Those semantic events are what let the LLM build workflows from chaotic UI interactions.

The approach is agnostic to whether the UI is a traditional form or a WebGL canvas: as long as the app emits the right events, Vibium AI can map the flow and reason about it.

🔌 Developer experience: extension, include, and the dev loop

Jason envisions multiple routes to instrument apps and capture events for the map:

Browser extension—fast to adopt for developers and QA because it can instrument an app without code changes.
JavaScript include—a small library embedded in your app that emits events (page, click, type) to Vibium AI. This is more complete but may require approvals and shipping the include as part of the app.

Once instrumentation is in place, Vibium AI can integrate into the dev loop. Imagine your AI co‑pilot (Lovable, Claude Code, or similar) making a change; Vibium AI then:

Determines the small subset of the app's map that the change might affect.
Runs targeted end‑to‑end tests for that neighborhood instead of the entire suite.
Runs background regression checks on less likely affected areas.

This reduces test runtime and gives developers feedback that’s both fast and relevant—crucial when embracing vibe‑coding style workflows where rapid iteration is the norm.

⚠️ Handling flakiness: green, orange, red

One of the most recognizable sections of the conversation is Jason's argument for a three‑color triage system: green, orange, and red. He advocates moving beyond the binary pass/fail mentality and treating flaky, worked‑around test runs as a distinct “orange” state that warrants human attention.

Examples of orange situations include:

Extra cookie/consent popups that needed to be dismissed programmatically.
Designer changed a button color or label; the test clicked an alternate control to get through the flow.
Transient network issues that required retries or alternate routing to reach the expected page.

By recognizing and surfacing these "near misses," Vibium AI avoids the false optimism of green and the panic of red—Instead it offers a nuanced triage that helps engineering teams decide whether to accept, fix, or investigate.

🌐 Where Vibium AI fits among browser automation killer apps

Jason points out three killer apps for browser automation:

Process automation (RPA style workflows such as approving invoices).
Data scraping (collecting information from websites).
Test automation (QA and reliability engineering).

Many big vendors shape generic browser automation capabilities to serve all three needs. Vibium AI focuses tightly on the third: test automation. By concentrating on the unique requirements of tests—modeling application flows, minimizing flakiness, and integrating tightly into dev loops—Vibium AI seeks to outcompete general‑purpose drivers for QA‑specific scenarios.

🗺️📹 User interface ideas: zoomable maps and live cams

Jason imagines a slick visual interface where your app's map becomes something you can zoom, pan, and inspect—much like Google Maps for your application. The UI could overlay production telemetry, show popular user paths, and reveal which workflows have automated test coverage.

He also suggests a split‑screen mode: map view on one side and a live "cam" showing automated browser runs on the other. That visual coupling would make it easy to explain to managers and stakeholders what the automated agents are doing and why certain tests passed, failed, or wound up in orange.

👥 Jobs and the future of QA with Vibium AI

Will Vibium AI kill manual QA jobs in five years? Jason’s answer is a nuanced “no”—jobs will change. The pattern is shifting from manual execution to supervision, orchestration, and higher‑level QA work.

Think of testers becoming conductors or managers of automated agents. They’ll:

Define expectations and acceptance criteria.
Interpret orange results and tune models or instrumentation.
Design experiments and edge‑case tests that agents struggle with.

New roles may emerge too: vibe‑coding cleanup specialists, model engineers for test maps, telemetry engineers who make apps testable, and people who operate the global test networks Vibium AI envisions.

🧪 Practical advice: play with vibe‑coding tools today

Jason gives a piece of practical advice for developers: try the tools yourself. Don’t just read about vibe coding—build an app with an LLM‑driven workflow (Cloud Code, Lovable, Claude Code, or similar) and see how long you can go without manually editing code.

His point isn’t to push everyone to the fully autonomous extreme. Rather, the fastest way to develop a grounded opinion—and to see the real risks and benefits—is first‑hand experimentation. Try a few small projects, iterate, then form an informed view about where Vibium AI or similar tools fit in your team’s workflow.

❓ FAQ

Is Selenium dead?

No. Selenium remains a foundational layer for browser automation. Vibium AI builds on modern browser protocols (including WebDriver BiDirectional) and often leaves Selenium "under the hood."

Will Vibium AI replace QA engineers?

Not entirely. Roles will evolve. Many manual QA tasks will automate, but humans will supervise, triage, and extend the system. Vibium AI aims to shift QA work up the stack, toward modeling, instrumentation, and orchestration.

How does Vibium AI reduce test flakiness?

By building a model of the app and using graph routing, Vibium AI can choose resilient paths and recognize when it needed to use a workaround (the "orange" state). That awareness improves triage and reduces wasted investigation time.

Do I have to add telemetry to my app?

Either instrument the app with a small JS include or use a browser extension to capture events. The more semantic events your app emits, the better the generated models and tests will be.

How does Vibium AI choose which tests to run?

Using the map and graph theory, Vibium AI can compute a neighborhood of impacted nodes for any code change and only run the tests that matter first—saving time while maintaining confidence.

Where can I get involved?

Jason recommends following updates on the project’s site (vibe.ai) and following him on social channels like LinkedIn. Public repos and contribution paths are planned for when the first release is ready.

🏗️ Legacy: what Jason hopes Vibium AI will leave behind

Jason hopes Vibium AI becomes a practical platform that preserves tester expertise while embracing AI automation. His aspiration isn’t to erase careers built on Selenium and Appium; it’s to give those practitioners modern tools and roles where their knowledge is still valuable—shifted to higher‑impact tasks.

Whether Vibium AI ends up being a brand (like Selenium once was) or a set of practices and tools that get absorbed into the testing ecosystem, Jason wants there to be an economy of work for people who know how to test—and to help them transition into supervising, tuning, and building for the AI era.

🔭 Final thoughts and next steps

Vibium AI is an ambitious attempt to reframe testing from brittle scripts to a living map of how applications are used. The central ideas are clear and pragmatic:

Make your app emit semantic events when important things happen.
Aggregate those events to build a graph/model of your app’s flows.
Use large language models to translate that model into targeted, resilient tests.
Integrate testing into the developer AI loop so that vibe coding and human review are both safe and efficient.

If you want to get involved: follow Jason on LinkedIn, keep an eye on vibe.ai, and be ready to experiment. Vibium AI will need people to test the recorder, validate generated tests, file pull requests, and help shape the visual map experience.

Automation ecosystems don’t change overnight, but Vibium AI points to a future where automated agents and human expertise collaborate in richer, more explainable ways. Whether you’re a traditional test engineer, a vibe coder, or somewhere in between, this approach offers concrete tools and metaphors to navigate the era of AI‑assisted engineering.

Thanks to Nikolay Advolodkin of UltimateQA and the Tech Heartbeat podcast for the conversation that inspired this write‑up. If you found these ideas useful, try a small experiment today: add an event hook to a page and record a user flow—then ask an LLM to generate a test from that trace. It’s a small step toward a map that may change how your team tests forever.

Thank You 😉

How to Use v0 by Vercel for Beginners

Nikolay Advolodkin — Thu, 14 Aug 2025 17:41:09 +0000

If you've ever wished you could create professional React components and launch fully functioning websites in mere minutes instead of hours, then Vercel v0 might just be the game-changer you've been waiting for. This innovative AI-driven platform promises to streamline the entire web development process—from initial design to deployment—making it accessible for developers and entrepreneurs alike.

In this comprehensive guide, I'll walk you through everything you need to know about using Vercel v0, sharing my own insights and experiences building a real estate rental properties website from scratch. Whether you're a seasoned developer or just starting out, this article will show you how Vercel v0 can accelerate your workflow and simplify deployment to production.

🚀 Getting Started with Vercel v0
🧠 Choosing the AI Model and Generating Code
🔄 Iterating with Version Control and Code Previews
🌐 Exploring the Generated Website and UI Quality
✨ Adding Features: Contact Forms and Property Showcases
🎨 Customizing with Uploads and Styling Updates
💰 Understanding Vercel v0 Pricing and Plans
🚀 Deploying Your Website to Production
🔗 Managing Domains and URL Customization
🛠️ Additional Features and Developer Tools
💡 Why Vercel v0 Stands Out in the Low-Code Landscape
❓ Frequently Asked Questions about Vercel v0
🔚 Conclusion: Is Vercel v0 Right for You?

Free, JavaScript testing tips newsletter.

1 tip in your inbox every week.

ultimateqa.kit.com

🚀 Getting Started with Vercel v0

To dive into Vercel v0, the first step is to visit v0.dev and sign up for an account. Once logged in, you'll be greeted by the intuitive Vercel v0 chat window—an AI assistant designed to understand natural language commands. This conversational interface is where much of the magic happens, enabling you to build websites by simply describing what you want.

The platform offers several quick-start options to jumpstart your project, such as:

Cloning a screenshot
Importing designs directly from Figma
Uploading an existing project
Creating a landing page
Building a sign-up form
Or crafting more unique custom components

For my project, I chose to create a landing page for Nice Properties, a small company that manages rental properties. This example helps illustrate how Vercel v0 can be applied to real-world business needs.

🧠 Choosing the AI Model and Generating Code

One of the standout features of Vercel v0 is the ability to select different AI models tailored to your task complexity and budget. The options typically include:

Medium model: Ideal for everyday tasks and UI generation with moderate cost
Large model: More powerful but significantly more expensive, costing around $7.50 per million input tokens and $37.50 per million output tokens

For my landing page, I selected the medium model as it strikes a good balance between quality and cost.

Once you input your project description—in my case, instructions to create a website for rental property management—the AI begins generating the React code. You can watch the process unfold live: on the left side, Vercel v0 shows its "thinking" process, while on the right, you see a live preview of the website alongside the code being generated.

🔄 Iterating with Version Control and Code Previews

One of the most powerful aspects of Vercel v0 is its built-in versioning system. Every time you make a change or generate new code, it saves that iteration as a distinct version. This allows you to:

Experiment freely without fear of losing progress
Compare multiple versions of your application
Roll back to previous versions if you hit a dead end or unwanted changes

Because AI-generated code often requires refinement—especially for complex projects—the iteration feature is invaluable. You can tweak your instructions, request UI fixes, or add new components, and the platform will regenerate updated code accordingly.

🌐 Exploring the Generated Website and UI Quality

After the initial generation, I reviewed the landing page Vercel v0 created for Nice Properties. The UI design was impressive—clean, professional, and modern, which aligns with Vercel's reputation as one of the best tools for UI design. Even though the website initially contained a lot of text (likely due to my original instructions mentioning SaaS, which was not the intended business model), the overall layout was solid.

There were minor UI issues, like some overlapping elements at the bottom of the page, but these are easy to fix through further iterations. The platform encourages ongoing dialogue with the AI assistant, so you can request specific improvements or additions.

✨ Adding Features: Contact Forms and Property Showcases

One of the coolest features I discovered was how Vercel v0 understands context and can generate relevant components on demand. For example, I asked it to add a property showcase section to highlight available rental properties. The AI created a visually appealing showcase complete with location info, pricing, tags, and descriptions—all of which can be customized by simply uploading property images.

Similarly, you can add a contact form that integrates with popular CRM tools like HubSpot, enabling seamless lead capture and follow-up. This flexibility means you can rapidly build fully functional apps tailored to your business needs without extensive coding.

🎨 Customizing with Uploads and Styling Updates

To make the site truly my own, I uploaded Nice Properties' logo and asked Vercel v0 to incorporate it into the design and update the styling accordingly. The AI quickly adapted the layout, added social credibility elements such as “Since 2017” and an NPS score, and crafted compelling headlines and calls to action.

This level of customization through simple file uploads and natural language requests makes Vercel v0 a powerful tool for branding and personalization.

💰 Understanding Vercel v0 Pricing and Plans

Vercel v0 offers a tiered pricing model suitable for different user needs:

Free tier: Great for exploring the platform and building small projects
Premium plan ($20/month): Includes $20 worth of monthly credits, access to more advanced AI models, and increased attachment size limits
Enterprise plan: Custom solutions for large organizations with additional features and support

Credits are consumed based on the tokens used during AI interactions, both input and output. The interface clearly displays your monthly credits and usage, helping you manage costs effectively.

🚀 Deploying Your Website to Production

One of the highlights of Vercel v0 is how effortless it makes deployment. Once you're satisfied with your website, publishing it to production is as simple as clicking a button. Vercel handles the entire deployment pipeline, including building, hosting, and generating a live URL.

The deployment process is fast—usually under a minute—and you can monitor logs in real-time to ensure everything is running smoothly.

🔗 Managing Domains and URL Customization

By default, your site is hosted on a Vercel subdomain (e.g., nice-properties.vercel.app). However, you can easily add custom domains or create friendlier URLs directly within the platform. This flexibility lets you maintain professional branding without needing external DNS configuration.

🛠️ Additional Features and Developer Tools

Vercel v0 includes several advanced tools to help you manage and refine your project:

Page navigation: Easily switch between multiple pages like Home, Contact, or App within your project
Component selection and editing: Select individual UI components (such as logos) and request size adjustments or styling changes
Source code download: Export your entire project’s code to continue development locally or in other IDEs
GitHub integration: Connect your project to GitHub for version control and continuous integration/continuous deployment (CI/CD) pipelines
Version history: Track all iterations and roll back to any previous version if needed
Console and debugging: View runtime logs, errors, and messages to troubleshoot issues with your application

💡 Why Vercel v0 Stands Out in the Low-Code Landscape

Having experimented with various low-code and AI-assisted web development tools, I can confidently say that Vercel v0 ranks among the best—if not the very best—for UI design and rapid iteration. Its conversational AI interface, combined with robust versioning and seamless deployment, creates a uniquely productive environment.

Compared to traditional no-code platforms like WordPress, Vercel v0 offers far greater customization, better code quality, and a more developer-friendly experience. It significantly reduces the time and cost of building websites, especially for React-based applications.

Whether you’re building a simple landing page, a complex SaaS app, or a service website like mine, Vercel v0 empowers you to do it faster and with less hassle.

❓ Frequently Asked Questions about Vercel v0

What exactly is Vercel v0?

Vercel v0 is an AI-powered web development platform that generates React components and websites based on natural language instructions. It streamlines the entire process from design to deployment.

Do I need to know how to code to use Vercel v0?

No, Vercel v0 is designed to be accessible for both developers and non-developers. You interact with it using natural language, and it generates production-ready React code for you.

Can I customize the generated website?

Absolutely! You can upload assets like logos, specify styling preferences, add or remove components, and iterate on the design through the chat interface.

How does deployment work?

Once your website is ready, you can deploy it to production with a single click. Vercel handles hosting and provides a live URL immediately.

Is there a free plan available?

Yes, there is a free tier for exploration and small projects, with premium and enterprise plans offering additional features and usage credits.

Can I integrate Vercel v0 with other tools?

Yes, Vercel v0 supports integrations with services like Supabase, HubSpot, GitHub, and AI services such as XAI to expand your app’s capabilities.

How does version control work in Vercel v0?

Every iteration you make is saved as a separate version. You can view, compare, and roll back to any previous version at any time.

Is Vercel v0 suitable for building SaaS applications?

Yes, Vercel v0 can generate UI and code for SaaS apps, though some manual tweaking may be required depending on complexity.

🔚 Conclusion: Is Vercel v0 Right for You?

In my experience, Vercel v0 is a revolutionary tool that truly delivers on its promise to let you build professional React websites quickly and deploy them effortlessly. Its AI-driven approach, combined with powerful iteration and deployment features, makes it an excellent choice for startups, small businesses, and developers who want to accelerate their workflow without sacrificing quality.

While no tool is perfect, Vercel v0’s rapid prototyping capabilities, intuitive interface, and seamless cloud deployment make it a standout in the emerging landscape of AI-assisted web development.

If you’re curious about low-code or AI-powered web design, I highly recommend giving Vercel v0 a try and seeing how it fits into your development toolkit. Whether you’re creating a landing page, a portfolio, or a complex app, Vercel v0 offers a fast, efficient, and enjoyable way to bring your ideas to life.

Have you tried Vercel v0 or other AI coding tools? What has your experience been like? Feel free to share your thoughts and discoveries as this exciting technology continues to evolve.

I Tried GPT-5 for Coding — My Review

Nikolay Advolodkin — Fri, 08 Aug 2025 21:00:11 +0000

GPT-5 has just arrived, and it’s making waves as one of the most impressive AI models for coding and software development to date. With an extended context window, enhanced reasoning, and coding capabilities, this model promises to revolutionize how developers build, test, and deploy applications. In this article, I’m going to take you through an extensive hands-on journey with GPT-5, exploring its ability to handle complex coding tasks, automated testing, multimodal inputs, API testing, and even UI design—all while maintaining a sharp focus on precision and usability.

From debugging a challenging web application to generating sophisticated automated tests and creating a stunning landing page, this exploration will showcase GPT-5’s strengths, limitations, and potential impact on the future of automated software testing. So buckle up as we dive deep into the world of GPT-5 and its game-changing capabilities.

🚀 GPT-5’s Impressive Benchmark Performance and Pricing
🛠️ Putting GPT-5 to the Test: Debugging a Complex Web Application
🧪 Automated UI Testing with Playwright: Successes and Struggles
🖼️ Multimodal Testing: Generating Tests from Images
🔗 Automated API Testing from Postman Collections
🎨 Designing a Beautiful Landing Page with Automated Tests
🔍 Final Thoughts on GPT-5’s Capabilities and Future Potential
❓ Frequently Asked Questions about GPT-5

🚀 GPT-5’s Impressive Benchmark Performance and Pricing

Before diving into practical demonstrations, it’s essential to understand the foundation of GPT-5’s capabilities. According to recent benchmarks and livestreams, GPT-5 offers a massive 400,000 token context window and an output window of 128,000 tokens. This means it can handle and remember far more information during a single interaction than previous models, making it ideal for complex coding and multi-step tasks.

In terms of pricing, GPT-5 comes in at a competitive rate, with input tokens priced at $1.25 per thousand and output tokens at $10 per thousand. This pricing structure makes it accessible for extended use without the prohibitive costs associated with some other pro licenses, which can reach $200 monthly.

On the performance front, GPT-5 scores a flawless 100% on math capabilities—a critical factor for coding and algorithmic tasks. While the comparisons in the benchmark focus on OpenAI’s own models, GPT-5 also competes closely with other top-tier AI coding assistants like Claude and Grok, both renowned for their software engineering prowess.

One standout feature is GPT-5’s improved reliability, boasting significantly lower hallucination rates and fewer response errors, which means it provides more accurate and trustworthy outputs than its predecessors. This improvement is vital for developers who depend on AI for code generation and testing, as it reduces the need for constant manual corrections.

🛠️ Putting GPT-5 to the Test: Debugging a Complex Web Application

To truly understand GPT-5’s capabilities, I decided to test it on a real-world challenge: pulling down and running a complex e-commerce web application built by GitHub Spark. This app forms part of a workshop I conduct on agentic tools and workflows for software development, testing, and deployment. While I had previously only run this application in GitHub’s cloud environment, I wanted to see if GPT-5 could help get it running locally, solve initial bugs, and improve its functionality.

Interestingly, I used the Cursor platform to interact with GPT-5 instead of ChatGPT’s pro version, which requires a costly subscription. Cursor provides access to GPT-5 without additional fees, making it a practical choice for developers like myself who are already investing heavily in AI tools.

Upon attempting to run the app locally, I immediately encountered errors related to missing GitHub Spark implementations—likely dependencies that only exist in the cloud environment. Here’s where GPT-5’s problem-solving skills shone. I tasked it with diagnosing and fixing these issues.

Much to my amazement, GPT-5 successfully identified the problematic package and replaced it with a suitable alternative, getting the app to start without crashing. Although the app didn’t fully load its UI components yet, this initial fix was a massive win given the complexity of dependency management and environment differences.

🧪 Automated UI Testing with Playwright: Successes and Struggles

With the app partially functional, I pushed GPT-5 further by asking it to implement a missing feature and then write automated UI tests to verify the fix using Playwright. Automated end-to-end testing is notoriously tricky for AI models, especially when it comes to writing meaningful assertions and avoiding redundant or ineffective test cases.

From previous experiences, many AI-generated tests tend to be either overly verbose, testing irrelevant interactions, or simply logging information without making real assertions. I was curious if GPT-5 could break this pattern.

Impressively, GPT-5 managed to write a suite of Playwright tests that performed sensible actions:

Adding a to-do item and verifying its presence in the list
Persisting to-dos across page reloads
Checking toggle completion status and filter count updates

For example, it smartly assigned the to-do item “walk the dog” to a variable and then asserted its visibility on the page, which is a best practice in test writing. However, more complex tests—such as editing and deleting to-dos—were a bit more problematic. GPT-5 chose brittle XPath locators that are prone to breaking and struggled to correctly assert UI changes in these cases.

In the end, while GPT-5 was able to fix the core bug and generate useful automated tests, it got stuck on the more intricate browser testing tasks, spending too much time without a successful resolution. This suggests that although GPT-5 has made strides in automated testing, human oversight and refinement remain essential for complex UI scenarios.

🖼️ Multimodal Testing: Generating Tests from Images

One of GPT-5’s novel features is its multimodal capability—meaning it can process and understand images alongside text. To explore this, I took a screenshot of the contact section from my personal website and uploaded it to Cursor, asking GPT-5 to generate automated UI tests based on that image.

The results were a mixed bag. GPT-5 correctly identified some UI elements such as headers, submit buttons, email input fields, and even reCAPTCHA frames. However, it also generated incorrect information, like a wrong contact URL, which would cause the tests to fail if run as is.

Moreover, the tests lacked depth and meaningful validation. They mostly checked for element existence rather than verifying functionality or user interactions. This experiment highlighted that while GPT-5’s multimodal testing shows promise, it’s still in its infancy and requires careful review before use in production environments.

🔗 Automated API Testing from Postman Collections

API testing is a critical component of modern software quality assurance. To test GPT-5’s ability here, I uploaded a Postman collection for a contact list API—created by Kristen Giacvoni, an expert in software testing—to see if GPT-5 could generate a reliable suite of automated API tests.

GPT-5 didn’t disappoint. It generated a comprehensive set of API tests covering the entire lifecycle of contacts:

User registration and login
Creating a contact
Listing contacts and verifying the created contact is included
Updating contact information
Deleting a contact

These tests used appropriate HTTP methods and status code assertions, such as expecting 201 Created for successful resource creation. GPT-5 also smartly avoided hardcoding test data, which means these tests are more likely to work reliably on repeated runs.

Running these tests confirmed their solid implementation, showing GPT-5’s strength in generating meaningful and maintainable API test suites from existing documentation formats like Postman collections.

🎨 Designing a Beautiful Landing Page with Automated Tests

For the grand finale, I challenged GPT-5 to create a stunning, responsive landing page for our to-do app, complete with dynamic and interactive elements. The goal was to showcase the app’s features attractively and allow users to access the main application through this landing page.

GPT-5 designed a clean, modern UI with cool moving shapes and hover animations. The page was simple yet visually appealing, emphasizing usability and interactivity. However, it lacked images and some content felt empty, suggesting room for refinement.

Additionally, GPT-5 wrote automated UI tests for the landing page. While some tests, like verifying the visibility of headings and navigation to the app, were solid, others—such as checking animation on hover—were superficial. For instance, the test waited for an element to be visible but didn’t genuinely verify the animation effect, which could lead to false positives if left unchecked.

After implementing the landing page, the main to-do app broke due to some integration issues. GPT-5 helped identify and fix these errors, restoring functionality. This process demonstrated GPT-5’s ability to juggle multiple complex tasks, including UI design, test automation, and debugging.

🔍 Final Thoughts on GPT-5’s Capabilities and Future Potential

GPT-5 is undeniably a groundbreaking AI model that pushes the boundaries of what AI can do in software development and testing. From fixing complex bugs and generating automated Playwright tests to creating API test suites from Postman collections and designing interactive landing pages, GPT-5 showcased versatile and powerful capabilities.

However, the model is not without limitations. Automated UI testing remains challenging, especially for complex interactions and fragile locators. Multimodal testing from images still requires refinement to produce truly valuable and actionable tests. Human expertise is crucial to review, refine, and complement GPT-5’s outputs.

Nevertheless, GPT-5’s ability to follow instructions precisely and perform tasks as requested—without going beyond or falling short—is a significant step forward. Its lowered hallucination rates and improved reliability make it a trustworthy partner for developers aiming to automate and accelerate their workflows.

As AI models like GPT-5 continue to evolve, they will likely become indispensable tools in the software development lifecycle, transforming how we write code, test applications, and deliver high-quality software faster than ever before.

❓ Frequently Asked Questions about GPT-5

What makes GPT-5 different from previous OpenAI models?

GPT-5 features a massive context window of 400,000 tokens and an output window of 128,000 tokens, allowing it to handle large, complex tasks in one go. It also boasts improved reasoning, coding abilities, and significantly lower hallucination rates, making it more reliable than earlier models.

Can GPT-5 write automated tests for both UI and APIs?

Yes, GPT-5 can generate automated UI tests using frameworks like Playwright and create comprehensive API test suites from Postman collections. While API test generation is robust, UI testing can still require human refinement, especially for complex interactions.

Does GPT-5 support multimodal inputs?

GPT-5 can process images alongside text, enabling it to generate tests based on screenshots. However, this feature is still developing and may not always produce fully accurate or valuable tests without manual review.

Is GPT-5 cost-effective for developers?

GPT-5 offers competitive pricing compared to other pro AI licenses, making it accessible for developers who need powerful AI capabilities without exorbitant costs. Platforms like Cursor provide access to GPT-5 without additional subscription fees.

How reliable is GPT-5 in fixing bugs and implementing new features?

GPT-5 excels at following instructions accurately and can fix complex bugs and implement new features effectively. However, it may struggle with intricate UI testing and some edge cases, so human oversight remains important.

Can GPT-5 design complete user interfaces?

Yes, GPT-5 can design responsive, modern landing pages with interactive elements. While the designs are clean and functional, they may require further enhancement and integration testing to ensure full application compatibility.

Free, JavaScript testing tips newsletter.

1 tip in your inbox every week.

Get Tips

The Engineer's Guide to Career Growth in the AI Era

Nikolay Advolodkin — Tue, 05 Aug 2025 16:03:58 +0000

The job market for tech talent is the most competitive we've seen. Simultaneously, AI is automating repetitive tasks, and it's happening at a breathtaking pace. For many engineers, this feels like a threat. But what if it's actually the single biggest career upskill opportunity available right now?

Instead of fighting this wave of change, you can learn to use it to your advantage. This isn't just about a productivity boost; it's a new way of working that turns AI complexity into your competitive advantage.

To help you navigate this shift, we've created the:
AI For Good Technical Workshop.

What You Will Learn: From Prompt to Deployment

This free, live workshop is designed to give you a definitive career advantage by teaching you how to leverage AI across the entire development lifecycle. You will learn exactly how to:

Build a web app in minutes using GitHub Spark AI. See firsthand how the latest innovation from Microsoft and GitHub can take you from an idea to a functional application with a single prompt.
Deploy the web app using GitHub. Master the steps to get your AI-generated application live and accessible.
Create a CI/CD pipeline using GitHub Copilot. Automate your integration and deployment workflow, making your development process more robust and efficient.
Create automated tests using GitHub Copilot. Learn how to use AI to write meaningful tests, ensuring your code is reliable without the manual grind.
Perform PR reviews using AI. Discover how AI can assist in code reviews, catching errors and improving quality before they merge.
Integrate everything. Tie all these skills together to form a seamless, modern, AI-powered development workflow.

To give you a glimpse of what you'll accomplish, we will be working with a dummy NextJs e-commerce app that includes an in-memory REST API backend for testing. You can even preview the application here:
https://nextjs-e-commerce-wo--nadvolod.github.app/

Secure Your Future: Don't Get Left Behind

The skills that got you here won't get you there. This workshop is your opportunity to stay ahead and turn AI into your biggest career asset. Don't let AI become a threat — make it your greatest tool.

🔥 Register for the free workshop today!

Date: Tuesday, August 12, 2025
Time: 9:00 AM EST | 6:00 AM PST | 3:00 PM CET
Link: https://bit.ly/ai4good-aug25

Repost this to help someone who needs a career advantage. Your journey to becoming an indispensable, AI-powered engineer starts now.

GitHub Spark - An Excellent AI Developer

Nikolay Advolodkin — Tue, 29 Jul 2025 14:44:02 +0000

Discovering new tools that accelerate web development is always exciting, especially when they harness the power of AI to simplify complex tasks. GitHub Spark, Microsoft’s latest AI code editor, is making waves by transforming a single prompt into a fully functional, production-ready web application in record time. In this article, we'll explore how GitHub Spark works, its standout features, and how it compares to other popular AI-powered development platforms, such as Replit, V0, and Lovable.

Getting Started with GitHub Spark

One of the most refreshing aspects of GitHub Spark is its accessibility. There’s no need to download or install anything—just navigate to github.com/spark and start coding right away through the web interface. This approach mirrors that of other no-code and low-code tools, but GitHub Spark stands out by offering a seamless, integrated experience reminiscent of popular code editors like VS Code.

To test its capabilities, I provided a single, detailed prompt asking GitHub Spark to build a beautiful, functional, and production-ready Next.js web application using TypeScript. The prompt specified requirements, including a modern, responsive UI, a RESTful API backend for CRUD operations, state management, and optimistic UI updates to facilitate smooth user interactions. Within moments, GitHub Spark generated an entire project structure, complete with all the necessary files and a working application preview.

💌 Weekly JavaScript Testing Tips Newsletter

Exploring the Features of GitHub Spark

Code and Preview Side-by-Side

The interface allows you to toggle between code view and a live preview of the application, offering a developer workflow similar to traditional IDEs. On the left, you can navigate and edit your code files, while on the right, you see the immediate impact of your changes in the UI. This dual-pane setup streamlines the development process, enabling quick iterations and testing without leaving the editor.

Interactive Application Demo

The app generated from the prompt included a to-do list with features such as adding items, marking them as completed, filtering by status (active, completed, all), and clearing completed tasks. The UI was clean and responsive, working smoothly both on desktop and mobile views. The mobile preview, although disabled during some iterations, showed the app’s adaptability to different screen sizes, which is crucial for modern web applications.

Theme Editor: A Unique Touch

One of GitHub Spark’s standout features is its built-in theme editor. Unlike other AI-driven coding tools, Spark allows you to switch themes easily, offering options like “Neo Brutalism” with just a few clicks. This capability to customize the app’s look and feel directly within the editor is a game-changer, providing developers with more control over UI design without needing to dive deep into styling code.

Data and Asset Management

GitHub Spark also allows you to view the underlying data structures that power your app, such as JSON representations of to-do items and their associated metadata. Additionally, you can upload assets, such as logos or menus, which the AI can incorporate into your application. This feature enhances the tool’s utility for building tailored applications that reflect brand identity or specific content requirements.

Prompt History and AI Suggestions

The editor maintains a history of your prompts, making it easy to track what instructions were given to the AI. Moreover, GitHub Spark provides AI-generated suggestions for additional features, enabling developers to expand their applications with minimal effort. When I tried to add a delete button for each to-do item using the selection tool, the AI attempted to process the request and provided feedback on its actions, although in this case, the change didn’t take effect, highlighting that while powerful, the tool isn’t flawless yet.

💌 Free, weekly Playwright Testing Tips

Publishing and Collaboration

Publishing your app from GitHub Spark is straightforward. With a single click, you can push your project to a public or private GitHub repository. The interface even lets you control who can view your app—limiting access to just yourself, all GitHub users, or specific organizations.

However, a notable limitation is the lack of a direct option to make the app publicly accessible beyond the GitHub ecosystem. For developers seeking to share their work with a broader audience, this is an area where GitHub Spark could be improved. Despite this, the generated applications are fully functional, and the source code can be shared and forked like any other GitHub project.

My Experience and Final Thoughts

After putting GitHub Spark to the test, I found it to be one of the best no-code/low-code platforms I’ve used for quickly generating production-ready web applications. The initial single-prompt creation was smooth and error-free, producing a clean, responsive UI paired with a robust backend.

That said, the tool is not without its quirks. Some feature additions via the AI’s selection-based editing didn’t work as expected, which might be due to the current limitations of the AI or how the prompt was applied. More complex scenarios—like integrating databases, authentication, and CI/CD pipelines—still pose challenges, which is common among AI-assisted coding platforms.

Where GitHub Spark truly stands out is in its user-friendly interface, live code preview, and especially the theme customization options. The ability to switch themes effortlessly is a unique and valuable feature that enhances creativity and speeds up the design process.

Is GitHub Spark the Right Tool for You?

If you’re looking for an AI-powered code editor that can rapidly build web applications from a single prompt, GitHub Spark is definitely worth exploring. Its seamless GitHub integration, intuitive UI, and innovative features like theme editing make it a strong competitor against tools like Lovable, Replit, and V0.

Whether you are an engineer preparing for AI workshops, a developer seeking to prototype ideas quickly, or just curious about the future of no-code solutions, GitHub Spark offers a compelling blend of automation and control.

Have you tried GitHub Spark yet? How do you think it stacks up against other AI code editors? Share your thoughts and experiences, and let’s keep the conversation going as these tools continue to evolve.

Explore the Source Code

To help you get started, I’ve published the source code of the Next.js e-commerce web app created with GitHub Spark on GitHub. Feel free to check it out, experiment with it, and build upon it.

🎥 Watch the Full Tutorial

Happy coding, and here’s to embracing the future of AI-assisted development!

Hiring: Senior Test Automation Engineer (CET support)

Nikolay Advolodkin — Sun, 11 May 2025 20:14:50 +0000

UltimateQA — Remote Position

UltimateQA seeks an exceptional Senior Test Automation Engineer to lead testing strategies for high-profile international projects supporting CET hours. This is a unique opportunity to make a significant impact while working alongside some of the leading engineers in the field.

About Us

At UltimateQA, we are revolutionizing how the world creates technology through our unparalleled expertise in automated software testing. We’re actively building the next generation of automated testing tools, redefining industry standards. By 2030, we aim to be the global pinnacle of automated software testing, driven by our core values of customer obsession, integrity, and insisting on the highest standards.

The Opportunity

This is not just another testing role. As our Senior Test Automation Engineer, you will:

Lead and define the entire testing strategy across multiple high-visibility projects
Support numerous international projects simultaneously, providing diverse challenges and exceptional learning opportunities
Collaborate with and be mentored by recognized leaders in the test automation field
Drive technical excellence and quality standards for mission-critical applications
Shape testing processes that impact millions of users worldwide

Key Responsibilities

Design, develop, and maintain automated test frameworks for web applications, APIs, and CI/CD pipelines
Lead test planning and strategy development for complex, high-stakes projects
Implement robust end-to-end testing solutions using modern frameworks and tools
Collaborate with international stakeholders to define quality standards and testing approaches
Identify and resolve complex technical issues with minimal supervision
Mentor junior team members and evangelize quality practices

Required Skills & Experience

Located in Europe with the ability to work during CET business hours
Strong experience with TypeScript for test automation
Expert-level knowledge of Playwright for end-to-end testing
Extensive experience with API testing methodologies and tools
Proficiency with Azure DevOps for project management and CI/CD implementation
Experience setting up and maintaining automated test pipelines
Excellent communication skills in English, both written and verbal
Proven ability to work independently and lead technical initiatives

Preferred Qualifications

Experience working on global health, financial, or other regulated industry projects
Knowledge of accessibility testing and WCAG compliance requirements
Experience with performance testing and monitoring
Familiarity with cloud infrastructure testing
Background in security testing principles

Why Join UltimateQA?

Growth & Learning: Unparalleled opportunities to expand your skills across diverse projects and technologies
Technical Excellence: Work with a team that insists on the highest standards and fanatic attention to detail
Stability: Work with established organizations on long-term, stable projects
Impact: Your work will directly influence critical systems used by major international organizations
Community: Be part of a company building the world’s most thrilling test automation community
Culture: Experience our “Constant and Never-ending Improvement” (CANI) philosophy in action

Application Process

👉 Apply Here

Our selection process includes:

Initial application review
Two technical assessments
Technical interview with our engineering team
Final interview with leadership

Resources for Learning Atomic Testing

Nikolay Advolodkin — Thu, 05 May 2022 15:11:20 +0000

We had an amazing turn out of engineers to my Comprehensive Testing with JavaScript Workshop from Sauce Con! We accomplished a number of amazing outcomes. I'll talk about those below. However, a major question that came from this was how to create tests that are more atomic. I'm going to provide my best resources to answer this.

First and foremost, the net profits from the workshop will be used to buy Trees that Empower Women from Ecosia. By my back of the napkin estimations, we will be able to buy and plant at least 1,000 trees👏🌳 (I will provide final numbers after I have them). Beyond the great environmental impact, we're also providing jobs to women in countries like Kenya, Brazil, and India 👏 (I'm passionate about the environment and equality, so this is important).

Second, we learned a ton of really cool topics such as
✅ API testing w/ Cypress
✅ how to test a React web app using different types of tests
✅ E2E ui tests w/ Cypress
✅ visual cross-browser + cross-platform tests
✅ CICD with Github Actions

Finally, a major question that came out of the workshop was how to deconstruct large UI tests into smaller atomic tests. This is a great and complicated topic. I'm going to provide my favorite resources to help you get some ideas.

1. Automated Atomic Tests Blog post

This is a blog post that I've worked on for years. It covers

What is an atomic automated test? (w/ code examples)
Case studies of atomic tests
How to break up giant end-to-end UI tests?
How to manipulate test data for UI automation?
How To Control App State Using JavaScript? (code and video included)
How To Coordinate API and UI Interactions In One Test?
Coordinating API and UI interactions in one test by Titus Fortner

2. Automated Atomic Tests (Definitive Guide)

Since I get this question so often, I tried to create a single source for all the information related to automated atomic tests.
Some topics covered here include

3. Building and testing a Github User Search Web App Youtube Tutorial

4. Software testing with java youtube tutorial

This is a Premiere that's coming up where I'll show you how to use Selenium + Java to bypass login authentication using Cookies and JavaScript injection for this web app

I'm not the only one talking about these topics. There are also a few great resources that are focused around programmatic authentication.

Forem: Nikolay Advolodkin

Decoupling Temporal Services with Nexus and the Java SDK

Secrets Behind 3 Years of Automation Success!

Table of Contents

Project overview 🧭

Choosing the right tools 🛠️

Building the API testing strategy 🔐

CI/CD and parallelization ⚡

Schema management: RAML → OpenAPI → Types 🔁

UI testing: challenges & lessons 🖥️

Mobile testing note 📱

ROI and metrics 📊

Developer experience and static code analysis 🧩

Lessons learned & culture 🤝

Lesson 1 — Collaborate, don’t silo

Lesson 2 — Expand your scope responsibly

Lesson 3 — Choose tools objectively

Lesson 4 — Automate the things that matter

Lesson 5 — Make schemas the source of truth

Lesson 6 — Fast feedback loops win

How to replicate this — a step-by-step plan 🛣️

FAQ ❓

Why did you choose Playwright with TypeScript?

Could you have used a different stack and still reached Automation Success?

How did you keep UI tests stable in a changing low-code platform?

What about flaky tests—how did you control them?

Did you involve the development team in test ownership?

Any advice for teams with no TypeScript experience?

How important was reporting and logging?

Conclusion ✅

Master Web Development with GitHub Spark AI

Table of Contents

🚀 What You'll Build and Why It Matters

🧭 Overview: Tools and Tech Stack

🛠️ Getting Started with GitHub Spark

💡 UI Mode, Code Mode, and Assets

🔧 Working Locally: Visual Studio Code & GitHub Copilot

🗂️ Project Setup & Running the App Locally

🧾 Copilot Instructions & Context Engineering

🧪 Automated Tests with Playwright (and How AI Helps)

🔁 Branches, Pull Requests, and AI-Powered Code Reviews

⚙️ Implementing CI/CD with GitHub Actions

🧭 Best Practices & Guidance for AI-Assisted Development

🎯 Exercises & Challenges (Hands-on Learning)

❓ FAQ

How do I get access to GitHub Spark?

Which Copilot model should I use for software development?

Can Copilot create tests reliably?

Should I trust Copilot's PR review suggestions?

How do I avoid flaky or nonsensical tests generated by AI?

Is this approach suitable for enterprise teams?

🔚 Final Thoughts and Next Steps

📣 Want Help or More Resources?

📱 Social Medias:

Revolutionizing Test Automation with Vibium AI: Jason Huggins

Table of Contents

🛠️ Is Selenium obsolete?

🚗 Beyond Selenium: The vision of Vibium AI

🗺️ How Vibium AI works: App maps and model‑based testing

♟️ Concrete demo: TestTrack and the 3D chess example

🔌 Developer experience: extension, include, and the dev loop

⚠️ Handling flakiness: green, orange, red

🌐 Where Vibium AI fits among browser automation killer apps

🗺️📹 User interface ideas: zoomable maps and live cams

👥 Jobs and the future of QA with Vibium AI

🧪 Practical advice: play with vibe‑coding tools today

❓ FAQ

Is Selenium dead?

Will Vibium AI replace QA engineers?

How does Vibium AI reduce test flakiness?

Do I have to add telemetry to my app?

How does Vibium AI choose which tests to run?

Where can I get involved?

🏗️ Legacy: what Jason hopes Vibium AI will leave behind

🔭 Final thoughts and next steps

How to Use v0 by Vercel for Beginners

Table of Contents

Free, JavaScript testing tips newsletter.

🚀 Getting Started with Vercel v0

🧠 Choosing the AI Model and Generating Code