AI Testing with Java —
From Your First ML Model to Self-Healing Frameworks

Move from building a tiny model to commanding a state-of-the-art LLM. You get a free Gemini API key, learn the 7-element prompt structure that makes the difference between mediocre and great output, and build a chatbot that remembers context.

• Sign up to Google AI Studio (aistudio.google.com), generate a Gemini API key
• Add Google's Java SDK to your Maven pom.xml: com.google.cloud:google-cloud-vertexai
• The 7-element prompt framework: role · task · context · tone · format · constraints · question
• Single-turn requests: GenerativeModel.generateContent(prompt) → read response.getText()
• Stateful chatbot: ChatSession chat = model.startChat() + chat.sendMessage() — preserves conversation context
• System instructions: keep the model on-topic across a long session
• Trade-offs of cloud LLMs: cost · security / data leakage · internet dependence · version drift
• Why this matters: every other module in the course leans on prompts you write yourself

Cloud LLMs are great until cost, latency or data privacy stops you. Ollama lets you run a capable LLM entirely on your own laptop — no internet required, no tokens billed, no data leaving the machine. You'll use a 1.5 B model that's small enough to run anywhere.

• Install Ollama; verify it's running at http://localhost:11434
• Pull a model: ollama pull qwen2.5-coder:1.5b
• List, run and chat: ollama list · ollama run qwen2.5-coder:1.5b
• The 3 message roles every chat API uses: user · system · assistant
• Call Ollama from Java using the built-in Java 11 HttpClient — no external dependency needed
• Parse JSON responses with Jackson (or Gson) — the standard pattern you'll reuse for any LLM
• Install Open WebUI for a ChatGPT-style local interface
• When to choose local over cloud: data sensitivity, predictable latency, zero per-call cost

An LLM only knows what it was trained on. RAG (Retrieval-Augmented Generation) plugs in live information so the model can answer today's questions, not last year's. You'll build two RAG pipelines — one with a free search engine, one with Google's — and then automate Gmail-sending from Java.

• What RAG actually means: Retrieval (fetch fresh data) · Augmented (merge with prompt) · Generation (LLM answers with context)
• Free pipeline: call DuckDuckGo from Java HttpClient, feed search results to local qwen2
• Paid pipeline: SerpAPI Java client (com.serpapi:google-search-results-java) feeds Google results to Gemini
• Sign up at serpapi.com, copy API key, hit the same Google index Google itself uses
• Send Gmail from Java using JavaMail (jakarta.mail) — Java's classical email library
• Enable 2-factor auth, generate an App Password at myaccount.google.com/apppasswords
• SMTP send pattern via JavaMail — no third-party email service required
• When to choose which: DDG/Ollama for cost · SerpAPI/Gemini for quality and structured results

Two ways to build the same agent. First the Java version: read a question from Excel, ask AI, reply by email. Then the visual version on make.com: same agent in 15 minutes with zero custom code. You'll know when to reach for which.

• Java AI Agent: read questions from Excel with Apache POI (org.apache.poi:poi-ooxml), compose AI reply, send email
• Apache POI for .xlsx: Workbook · Sheet · Row · Cell — the standard Java Excel API
• Google Forms → Google Sheets: collect responses without writing a backend
• Publish a Sheet as a public CSV URL — instant data feed for any pipeline
• make.com scenarios: visual node editor for workflow automation
• "Watch new rows" Google Sheets trigger — fires automatically on new submissions
• Make AI module: drop-in LLM step inside the scenario
• Gmail action: send formatted reply email back to the user
• Decision rule: Java when you need control and integration; make.com when you need speed and zero ops

Connect everything from the previous modules into one self-running pipeline: push code → GitHub Actions runs the Maven build → Allure report deploys to GitHub Pages → an AI summarises results → email lands in your inbox. You leave this module with a workflow you can drop into any client repo on Monday.

• Trigger on push: when code lands on master, GitHub Actions kicks off a Maven build
• Ubuntu runner setup: install JDK (via actions/setup-java) · Maven · Allure CLI · Playwright + browsers
• Run tests with mvn test — TestNG produces testng-results.xml and Maven Surefire produces TEST-*.xml
• Generate Allure HTML report from results
• Deploy report to GitHub Pages via peaceiris/actions-gh-pages
• Parse Surefire / TestNG XML inline for total / passed / failed / skipped counts
• POST JSON payload to a make.com webhook URL stored in MAKE_WEBHOOK_URL secret
• make.com receives the payload, feeds it to "You are a Senior QA Automation Lead" prompt, sends email
• Upload videos/ artifact so failures are debuggable later

Manual testing is not going away — but it is changing. This module shows the manual-tester end of the pipeline: feed a requirements doc to an LLM and generate scenarios, steps, data and defect reports. You also learn the two parameters (temperature, top_p) that decide whether AI sounds robotic or unpredictable, and how to spot when it's hallucinating.

• Temperature (0 = robotic / 0.3 = controlled / 0.8 = creative / 1.0 = unpredictable)
• top_p: word-probability cutoff — pairs with temperature to shape output
• Why markdown beats .doc / .pdf / .xlsx as AI input
• Convert .docx requirements to .md by calling pandoc as a CLI from Java using ProcessBuilder
• Prompts to generate: test scenarios · test steps · test data · review comments · defect reports
• Realistic vs scale-generated test data — when to write each by hand
• AI Bias — Representation Bias from skewed training data
• Hallucination — AI confidently producing data that doesn't exist
• QA habits to catch bad output before it ships

Where AI changes test-automation writing the most. You'll use GitHub Copilot for vibe coding inside IntelliJ IDEA, swap it for a free local LLM via the Continue plugin and Ollama, then connect Microsoft's Playwright MCP so an AI agent can drive a real browser as it generates the Java Playwright script.

• Vibe coding: describe what you want in plain English, AI writes the Java code
• IntelliJ IDEA setup: install GitHub Copilot plugin
• The 6 daily uses: write · explain · refactor · debug · MTC → automation · code migration (Selenium ↔ Playwright)
• Convert Selenium Java to Playwright Java (or the reverse) with one prompt
• Use a local LLM inside the IDE — install Continue plugin, point it at localhost:11434
• MCP — Model Context Protocol: standardised way AI tools talk to applications
• Install Microsoft's Playwright MCP: requires Node.js → npm install @playwright/mcp@latest
• Wire up mcp.json in IntelliJ; enable MCP Server in settings
• Use Copilot in Agent mode + Playwright MCP: AI opens a real browser, finds locators, writes verified Java Playwright code

The final module is the headline result of the course. You install Antigravity (Google's agentic IDE), describe the framework you want in English, watch it generate a working Java + Playwright + TestNG + Maven + POM framework, then upgrade it with an AI-healing mechanism that auto-fixes broken locators — caching the fixes so you only pay the AI tax once per locator.

• Agentic AI: AI manager → AI tools → real-world actions (the conceptual map)
• Install Antigravity from antigravity.google/, sign in with Gmail
• Generate a Java + Playwright + TestNG + Maven framework via prompt: pom.xml, BaseTest, page objects, sample test
• Approve plan → Antigravity writes the files → run the sample test with mvn test → it just works
• Standard layout: src/main/java/pages/, src/test/java/tests/, generic/BaseTest.java
• TestNG conventions: @BeforeMethod setup, @AfterMethod teardown, testng.xml suite file
• Convert an Excel manual test case (OSPOS) to a Page Object Model script via prompt
• Configure config.properties + framework conventions so AI follows your structure
• Add an AI-based self-healing locator mechanism using Gemini:
• Try original locator → on failure, call Gemini for a new working locator → use it
• Log both attempts; expose a single utility findElementWithHealing(Page page, String locator)
• Cache healed locators in locator_db.json (read/write via Jackson or Gson) — try original → check DB → call AI only on cache miss
• Result: the locator-breaking UI change that used to kill your suite is now a logged warning