Thoughts on test automation, quality engineering, and lessons learned from two decades in QA.
I built a deliberately buggy e-commerce app with a hidden 41-fault answer key, then scored two different automated exploratory-testing architectures against it: a static deterministic-scan-then-AI-review pipeline, and a live agentic browser driven by Claude through the real Playwright MCP tools. The two methods disagree on 16 of the 41 bugs - and only 4 were missed by both.
Rule-based accessibility scanners check that markup is well-formed, not that it's true. I built a demo site engineered to pass axe-core with zero violations on every page, then built a second Playwright suite that uses Claude to judge alt-text accuracy, DOM-vs-visual reading order, real focus behaviour, and error-message clarity - and it failed on every seeded defect, including one in the demo's own 'control' case I hadn't noticed myself.
CorporateRAG already traces SQL Server impact-analysis questions through a deliberately tricky fixture database. I built OIA — a standalone CLI tool doing the same job for Oracle, from scratch — then ported that exact fixture to PL/SQL and used CorporateRAG's own already-fixed tools as ground truth to compare against. The discrepancies caught four real bugs: a lineage parser reading the wrong AST node (twice), invisible WHERE-clause eligibility rules, a missing 'read the real source' tool, and a self-referencing Mermaid diagram.
I asked Claude to write the prompt for a realistic SQL Server reporting database, engineered with deliberate blind spots, then used it to catch CorporateRAG giving a plausible-but-wrong answer to an impact-analysis question — and had Claude diagnose the root cause, plan three rounds of fixes, implement them, and verify each one against the live system rather than just the diff.
Six upgrades to CorporateRAG since the original post — query rewriting, cross-encoder reranking, multi-modal image captioning, a lightweight entity graph, a semantic response cache, and a confidence gate that declines to answer rather than guess — plus a full walkthrough of the request/response pipeline that ties them together.
Building a Python script that turns a Jira Epic's child tasks into a dependency matrix, a network diagram and a priority-aware build order - and why I replaced Mermaid's bundled layout engine with Graphviz along the way.
How I rebuilt a Playwright BDD demo mode - DOM overlay title cards, red/teal element highlights, and Examples-table field values - on top of Ruby, Cucumber and Selenium WebDriver, and had to build video recording myself with ffmpeg since Selenium has no equivalent of Playwright's built-in recorder.
How I added an opt-in demo mode to a Playwright BDD suite - DOM overlay title cards, red and teal element highlights, and named field-value pairs from the Gherkin Examples table read at runtime from the feature file.
A complete guide to all 82 tools exposed by the Playwright MCP server — grouped by function, with descriptions and concrete use cases. The planner, generator, and healer agents use fewer than 30 of them.
How I adapted the Playwright planner–generator–healer agent pipeline to produce Ruby + Cucumber + Capybara output instead of TypeScript — what stays the same, what changes, and where the locator translation table becomes critical.
I ran the same seven end-to-end tests against a live Oracle APEX e-commerce application in both Selenium Ruby and Playwright TypeScript, with Playwright at 1, 2, 3, and 4 workers. The results confirm some well-known theories, contradict others, and reveal exactly when parallelism stops helping and starts hurting.
How I wired up automatic Jira ticket creation and a Claude Code healer agent into a GitHub Actions Playwright workflow — and what five rounds of fixing taught me about the gap between 'passes tests' and 'good code'.
A walkthrough of a two-layer demo project that exposes a SQL Server database to Claude via a FastAPI REST API and an MCP stdio server — covering what each file does, where the API ends and the MCP begins, and what a production-ready version of this stack would look like.
How I built a six-agent CrewAI pipeline that researches any company from a URL and produces a 9-section interview preparation report — covering business model, tech stack, competitors, culture, and a tailored interview guide with specific questions to ask.
How I used Playwright's AI planner, generator and healer agents - driven by Claude Code - to build a maintainable end-to-end test suite for a real Oracle APEX e-commerce app, structured around a Page Component Object Model that makes self-healing actually work.
How a tiny custom Forge gadget fixed the alignment problem on a two-column Jira wallboard - and what I learned about building Jira Cloud apps along the way.
How I built a multi-source RAG system that indexes Jira, Confluence, SQL Server and GitHub into a single vector index and answers natural-language questions with grounded, cited answers.
How I built a lightweight Retrieval-Augmented Generation system that indexes a Confluence space, embeds the content locally, and answers natural-language questions with grounded citations back to the source pages.
How I built a complete observability stack using k6, Docker Compose, Prometheus, InfluxDB, Grafana and windows_exporter — running across two Windows 11 machines — to get real-time performance dashboards during load tests, and the challenges involved in making it all work.
How I built an end-to-end load testing solution using k6, Flask, psutil, pandas and Plotly — no Docker, Prometheus or Grafana required — that runs natively on two Windows 11 machines and generates a self-contained interactive dashboard.
A practical guide to running powerful LLMs without melting your daily driver — covering Ollama Cloud, LM Studio remote sharing via LM Link, and other strong alternatives for use with Roo Code and similar AI coding agents.
A single-pass SQL pattern using MERGE with OUTPUT to compare two tables and classify every difference as an insert, update or delete - with AI generating the query directly from the database schema.
A hands-on walkthrough of Playwright's AI-powered Test Agents — planner, generator and healer — and how using Grok to craft the right prompt made exploring this new technology effortless.
How I built a Playwright test project that connects directly to SQL Server using mssql and msnodesqlv8, enabling true end-to-end testing where UI actions are verified against the database - plus a look at alternative approaches.
A concise SQL pattern using CTEs and EXCEPT to compare two tables with the same schema and produce a clear change report showing inserts, updates and deletes - without writing column-by-column comparisons.
How I used SQL CTEs, LAG() window functions and UNION ALL to build a single query that stitches together change history from multiple tables - making it easy to verify that a reporting table stays in sync with its source data.