🚀 I Built an AI-Native QA System That Automates the Entire STLC Using MCP, Cursor IDE, Figma MCP & Playwright

Traditional QA automation is breaking.

❌ Test scripts become flaky ❌ Locators fail constantly ❌ Requirements drift from automation ❌ Teams spend more time maintaining tests than building them ❌ AI copilots generate generic outputs without understanding the product

Meanwhile, AI models are becoming insanely powerful.

But there’s still one major problem:

AI doesn’t understand enterprise context.

So I started building something different.

I built an AI-native QA ecosystem that automates almost the entire Software Testing Life Cycle (STLC) using:

✅ Freshrelease MCP (Project Management tool like jira) ✅ Cursor IDE ✅ Claude ✅ .md contextual memory files ✅ .skill engineering rules ✅ Figma MCP ✅ Playwright MCP ✅ Self-healing automation

The result feels less like a test framework…

and more like having an autonomous QA engineer inside the IDE 🤯

🧠 The Core Problem with Modern QA

Most QA teams today struggle with:

• Massive manual testcase effort
• Constant automation maintenance
• Fragile locators
• Weak traceability
• Knowledge silos
• Duplicate automation
• Generic AI-generated testcases

Even the best LLMs fail because they lack:

• Product understanding
• Business rules
• Existing automation awareness
• Framework standards
• Design intelligence

Without context, AI produces:

• generic testcases
• inconsistent scripts
• duplicated automation
• poor edge-case coverage

That’s where MCP changed everything.

⚡ What is MCP?

MCP (Model Context Protocol) allows LLMs to communicate with enterprise systems using structured workflows.

Instead of treating AI like a chatbot…

MCP transforms AI into a:

🧠 Context-aware engineering agent

Through MCP, AI can:

• read user stories
• fetch test artifacts
• understand hierarchy
• create workflows
• connect enterprise systems

So I built my own MCP server for Freshrelease(Project Management tool like jira).

🔧 Freshrelease MCP

🔗 GitHub: https://github.com/dasscoax/freshrelease_mcp

The Freshrelease MCP exposes Freshrelease APIs directly to AI systems.

The AI can now: ✅ Fetch epics and stories ✅ Analyze requirements ✅ Generate QA insights ✅ Fetch/Create testcases ✅ Link releases/sprints ✅ Track automation coverage

This became the foundation of my AI-native QA system.

🤖 Cursor IDE + MCP = Autonomous QA Workflows

The breakthrough happened when I combined:

• Cursor IDE
• Claude
• Freshrelease MCP
• Figma MCP
• Playwright MCP

Suddenly the AI could:

✅ Read requirements ✅ Understand designs ✅ Follow testing standards ✅ Analyze existing automation ✅ Generate testcases ✅ Generate Playwright scripts ✅ Self-heal locators

It started behaving less like a chatbot…

and more like a senior SDET 😅

📚 Using .md Files as Long-Term QA Memory

I started storing business knowledge in markdown files.

These .md files contain:

• business rules
• workflows
• authentication logic
• regression strategy
• API contracts structure
• reference automation scripts

Example:

# Login Rules

- MFA mandatory for admins
- Password expires every 90 days
- Lock account after 5 failed attempts
- Session timeout after 15 mins inactivity

This changed the quality of AI outputs dramatically.

Instead of generic testcases…

the AI started generating domain-aware scenarios 🧠

🛠️ .skill Files Became AI Engineering Standards

This was one of the most powerful ideas.

I created .skill files that teach the AI:

• framework architecture
• test pyramid/test trophy standards
• locator strategy
• naming conventions
• assertion patterns
• retry handling
• reporting standards
• security validation rules

Example:

Playwright Rules:

- Prefer getByRole()
- Use data-testid
- Avoid XPath
- Avoid hard waits
- Use retry assertions
- Reuse existing page objects

Now AI generates automation like a trained QA architect 👨‍💻

🎨 Figma MCP Completely Changed Test Design

One huge problem in QA is converting UI designs into test scenarios.

Figma MCP solved this beautifully.

The AI can now: ✅ Read Figma designs ✅ Understand UI hierarchy ✅ Detect forms/buttons/modals ✅ Infer workflows ✅ Identify validations ✅ Generate UI test coverage automatically

Workflow:

Figma Design
      ↓
AI UI Analysis
      ↓
Scenario Generation
      ↓
Automation Skeletons

This massively reduced manual testcase effort 🚀

🔥 Playwright MCP + Self-Healing Locators

Locator maintenance is one of the biggest automation nightmares.

Traditional selectors fail because:

• CSS changes
• DOM hierarchy changes
• Dynamic rendering shifts elements

With Playwright MCP + semantic AI understanding:

The system can: ✅ Understand UI intent ✅ Re-identify elements ✅ Heal broken locators ✅ Suggest stable selectors ✅ Adapt to DOM changes

Instead of:

.page > div:nth-child(2) > button

The AI generates:

getByRole('button', { name: 'Submit' })

or:

getByTestId('submit-btn')

This dramatically reduced flaky automation 🎯

🧪 AI-Generated Testcases Directly from User Stories

This became my favorite workflow.

Example Story:

“As a user, I should be able to reset my password using email verification.”

The AI now automatically:

1️⃣ Reads the User story 2️⃣ Analyzes Figma screens 3️⃣ Applies .md business rules 4️⃣ Follows .skill standards 5️⃣ Generates:

• functional scenarios
• negative cases
• edge cases
• API validations
• accessibility tests
• security checks
• automation scripts

The output quality became shockingly good 🤯

📝 Auto-Creating Testcases in Freshrelease(PM tool)

The AI doesn’t just generate testcases anymore.

It directly creates them inside project management tool.

The system now: ✅ Creates testcase entities ✅ Links stories ✅ Assigns priorities ✅ Maps regression suites ✅ Tracks automation coverage

Workflow:

Requirement
    ↓
AI Analysis
    ↓
Scenario Generation
    ↓
Freshrelease MCP
    ↓
Automatic Testcase Creation

No spreadsheets. No manual testcase management. No disconnected QA docs.

⚙️ AI-Generated Automation Using Existing Framework Standards

One massive issue with AI-generated automation is duplication.

To solve this, the AI first analyzes:

• existing scripts
• page objects
• helper utilities
• fixtures
• reporting hooks
• framework architecture

before generating code.

This enables: ✅ Reuse-first automation ✅ Framework consistency ✅ Reduced duplication ✅ Better maintainability

💻 Example AI-Generated Playwright Script

import { test, expect } from '@playwright/test';
import { LoginPage } from '../pages/LoginPage';
import { ForgotPasswordPage } from '../pages/ForgotPasswordPage';

test('Verify user can reset password successfully', async ({ page }) => {

const loginPage = new LoginPage(page);
    const forgotPasswordPage = new ForgotPasswordPage(page);

await loginPage.navigate();

await loginPage.clickForgotPassword();

await forgotPasswordPage.requestPasswordReset(
        'testuser@example.com'
    );

await expect(
        forgotPasswordPage.successMessage
    ).toBeVisible();
});

The AI already follows: ✅ Existing framework patterns ✅ Locator strategy ✅ Reporting integrations ✅ Retry handling ✅ Shared utilities

🔄 Automating the Entire STLC

This system now automates:

✅ Requirement Analysis ✅ Test Planning ✅ Scenario Design ✅ Testcase Generation ✅ Traceability ✅ Automation Development ✅ Locator Healing ✅ Test Execution ✅ Failure Analysis ✅ Regression Optimization ✅ Defect Insights

This is no longer just “automation”.

It’s becoming:

🤖 AI-native STLC engineering

🏗️ Final Architecture

Freshrelease(Project management tool)
        ↓
Freshrelease MCP
        ↓
Cursor IDE + Claude
        ↓
.md Business Context
        ↓
.skill QA Standards
        ↓
Figma MCP Analysis
        ↓
AI Requirement Understanding
        ↓
Test Scenario Generation
        ↓
Freshrelease Testcase Creation
        ↓
Playwright Automation Generation
        ↓
Self-Healing Execution
        ↓
AI Defect Analysis
        ↓
Regression Optimization

💡 Key Learnings

1️⃣ Context > Prompting

The biggest improvements came from:

• structured memory
• engineering standards
• business context
• framework awareness

not prompt engineering alone.

2️⃣ AI Needs Governance

Without standards, AI creates chaos.

.skill files became critical for: ✅ consistency ✅ maintainability ✅ scalability ✅ framework quality

3️⃣ MCP is the Missing Enterprise AI Layer

MCP transforms AI from:

“assistant”

into:

“engineering system”

4️⃣ QA Engineers Are Evolving

The future role of QA is shifting from: ❌ writing scripts

to: ✅ designing intelligent validation ecosystems

🚀 Final Thoughts

Building this ecosystem completely changed how I think about automation.

The combination of:

• Freshrelease MCP
• Cursor IDE
• .md contextual memory
• .skill engineering rules
• Figma MCP
• Playwright MCP
• Self-healing automation

created a workflow where AI behaves like an experienced SDET teammate.

This is no longer traditional automation.

This is the beginning of:

🤖 AI-Native QA Engineering

And honestly…

we’re only getting started 🔥