<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Dasun Eranthika on Medium]]></title>
        <description><![CDATA[Stories by Dasun Eranthika on Medium]]></description>
        <link>https://medium.com/@dasuner?source=rss-641724e93ac8------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*V-MoIxWXjPrVPblvaNZ9-g.jpeg</url>
            <title>Stories by Dasun Eranthika on Medium</title>
            <link>https://medium.com/@dasuner?source=rss-641724e93ac8------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 06:25:47 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@dasuner/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Your Manual QA Team Is Resisting Automation. Here’s How to Lead the Transformation.]]></title>
            <link>https://medium.com/@dasuner/your-manual-qa-team-is-resisting-automation-heres-how-to-lead-the-transformation-a1766498d853?source=rss-641724e93ac8------2</link>
            <guid isPermaLink="false">https://medium.com/p/a1766498d853</guid>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[transformation]]></category>
            <dc:creator><![CDATA[Dasun Eranthika]]></dc:creator>
            <pubDate>Tue, 13 Oct 2026 06:16:04 GMT</pubDate>
            <atom:updated>2026-10-13T06:16:04.823Z</atom:updated>
            <content:encoded><![CDATA[<p>Moving a QA team toward automation isn’t just a technical challenge. It’s a leadership challenge involving skills, trust, ownership, and the way teams define quality.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vJIjbg8sqzFI3ecYBlWTSw.png" /><figcaption>From Manual Testing to Automated Testing</figcaption></figure><p>Imagine this.</p><p>Management announces a new direction: every QA engineer must start automating tests. The company invests in training, selects a modern automation framework, and sets ambitious targets for automation coverage.</p><p>A few engineers get excited. They start experimenting, write their first automated tests, and explore what the framework can do.</p><p>Others continue testing manually. Some avoid the new tools. A few openly question whether automation is necessary for their projects.</p><p>Management starts asking uncomfortable questions:</p><p>• Why aren’t we seeing more automated tests?<br>• Why are experienced testers resisting the change?<br>• When will we achieve our automation targets?<br>• Do we have the right people on the team?</p><p>At this point, it’s tempting to conclude that the problem is the team’s attitude.</p><p>But after working with QA teams, one thing becomes clear: when an automation transformation struggles, the problem is rarely just the technology — or the people. It’s often the way the transformation is being led.</p><p>If you’re a QA Lead, QA Manager, or Head of Quality Engineering, your responsibility isn’t simply to introduce automation tools. It’s to build a team that can deliver quality more efficiently, consistently, and confidently.</p><p>Here’s how I’d approach that transformation.</p><h3>1. Stop Treating Resistance as a Performance Problem</h3><p>The first mistake is assuming that everyone who resists automation is unwilling to learn.</p><p>Resistance can have several causes.</p><p>An experienced manual tester may have spent years developing strong analytical skills, understanding complex business workflows, and identifying defects that automated tests would miss. They might worry that their existing expertise is becoming irrelevant.</p><p>Another engineer may genuinely want to learn automation but lack confidence in programming. Someone else may have attended training without ever getting an opportunity to apply it to a real project.</p><p>And sometimes, resistance is simply a preference for familiar work.</p><p>These situations require different responses.</p><p>Before setting automation targets, I would have individual conversations with team members to understand their concerns, current skills, and willingness to learn.</p><p>Questions I’d ask include:</p><p>• What makes automation difficult for you today?<br>• Which parts of your current testing work could benefit from automation?<br>• What technical skills would you need help developing?<br>• What would make you more confident about contributing to automation?</p><p>The objective isn’t to negotiate away the transformation. It’s to understand the obstacles preventing people from participating.</p><p><strong>Leadership principle: Hold the direction firmly, but remain flexible about how people get there.</strong></p><h3>2. Explain Why the Transformation Matters</h3><p>Telling people to automate more tests isn’t a strategy.</p><p>People need to understand what the organization is trying to achieve and why the change matters.</p><p>For example, consider a product where testers repeatedly execute the same regression scenarios before every release. Requirements change frequently, environments are unstable, and testing time is limited.</p><p>The problem isn’t necessarily that the team lacks automated tests. The real problem is that repetitive regression work consumes time that could be spent exploring new functionality, investigating risks, and testing complex business scenarios.</p><p>That distinction matters.</p><p>Instead of saying:</p><blockquote>“We need to automate 80% of our test cases.”</blockquote><p>I’d explain the objective this way:</p><blockquote>“We want to reduce repetitive regression effort, identify critical defects earlier, and give the team more time for risk-based and exploratory testing. Automation is one of the ways we’ll achieve that.”</blockquote><p>Now the transformation has a purpose beyond increasing a metric.</p><p>I’d also make it clear that automation is not about eliminating manual testing. It’s about using human judgment where it adds the most value and automation where repeatability, speed, and consistency matter.</p><p>Manual testing remains essential for exploratory testing, usability evaluation, investigating unexpected behavior, and assessing scenarios that are difficult to automate reliably.</p><p>The goal is a stronger Quality Engineering capability — not simply a larger collection of scripts.</p><h3>3. Assess the Team Before Choosing the Approach</h3><p>A common mistake is treating every QA engineer as if they have the same starting point.</p><p>They don’t.</p><p>Some people may already be strong in automation but need to improve their test analysis. Others may be excellent functional testers with limited programming experience. Some may be capable in both areas but lack experience designing maintainable frameworks.</p><p>I would begin with a simple skills assessment covering four areas:</p><p>1. <strong>Testing fundamentals:</strong> Test design, risk analysis, exploratory testing, and defect investigation.<br>2. <strong>Technical foundations:</strong> Programming fundamentals, debugging, Git, APIs, and basic CI/CD concepts.<br>3. <strong>Automation capability:</strong> Writing tests, managing test data, using assertions, debugging failures, and maintaining test suites.<br>4. <strong>Engineering practices: </strong>Reusability, code reviews, framework design, reliability, and collaboration.</p><p>The assessment should guide development, not label people permanently.</p><p>For example, an experienced functional tester who understands complex business rules might need a structured introduction to TypeScript and Playwright. An automation engineer might need support with exploratory testing and identifying meaningful scenarios.</p><p>Both can improve, but their learning paths should differ.</p><p>I would use the results to create individual development plans with realistic milestones.</p><p>The important point is simple: <strong>equal expectations do not require identical training plans.</strong></p><h3>4. Start With Real Problems, Not Training Completion</h3><p>Training is useful, but completing a course doesn’t prove that someone can automate a real business workflow.</p><p>I’ve seen how easily organizations can confuse training activity with engineering progress. Teams attend workshops, complete exercises, and demonstrate sample scripts, yet the work doesn’t translate into production projects.</p><p>To avoid this, I’d introduce a practical, project-based learning approach.</p><p>Suppose the team uses Playwright with TypeScript.</p><p>Instead of asking everyone to complete a long course before contributing, I’d break the learning process into stages.</p><p><strong>Stage 1: Understand the basics.</strong></p><p>Team members learn TypeScript fundamentals, locators, assertions, auto-waiting, and how to run tests.</p><p><strong>Stage 2: Automate a small, stable workflow.</strong></p><p>Start with a login flow, a search function, or a straightforward business transaction. The goal is to produce a reliable test, not a sophisticated framework.</p><p><strong>Stage 3: Improve maintainability.</strong></p><p>Introduce fixtures, reusable functions, page objects where appropriate, test-data management, and debugging practices.</p><p><strong>Stage 4: Integrate with delivery.</strong></p><p>Run selected tests in CI/CD, publish reports, and learn how to investigate failures.</p><p>Each stage should produce something useful to the project.</p><p>I’d also pair less experienced engineers with stronger automation practitioners. Pairing helps transfer practical knowledge that formal training often misses: why a test is flaky, when an abstraction is unnecessary, and how to distinguish a product defect from a test-script problem.</p><p>The best training program is one that gradually makes the team more capable of delivering real work.</p><h3>5. Choose Automation Opportunities Based on Value</h3><p>Not every test deserves to be automated.</p><p>If management measures progress by the number of scripts created, teams can easily produce hundreds of tests that provide little confidence or require constant maintenance.</p><p>I’d evaluate potential automation candidates using questions such as:</p><p>• Is the scenario executed frequently?<br>• Is it important to the business?<br>• Is the workflow reasonably stable?<br>• Can the result be verified reliably?<br>• How much time does manual execution consume?<br>• What will it cost to develop and maintain the automated test?</p><p>Consider a critical payment workflow that must be verified before every release. Automating its stable, high-risk regression scenarios may provide significant value.</p><p>Compare that with a one-off scenario involving a frequently changing user interface. Automating it immediately might create more maintenance work than it saves.</p><p>This doesn’t mean unstable functionality should never be tested automatically. It means the approach must fit the problem.</p><p>For example, API tests may be more appropriate than UI tests for validating business rules that don’t depend on the user interface.</p><p>A practical starting point is to select a small number of high-value workflows, establish a baseline, and demonstrate measurable improvement.</p><p>I’d rather have 20 reliable tests protecting critical functionality than 200 flaky tests that the team has stopped trusting.</p><h3>6. Give Automation Clear Ownership</h3><p>Automation often fails to scale when everyone is expected to contribute but nobody is accountable for the outcome.</p><p>One engineer creates the framework. Another writes a few scripts. A third runs them occasionally. When tests start failing, the team isn’t sure who should investigate.</p><p>I’d establish clear ownership across three levels.</p><p><strong>Team level:</strong> The QA team is collectively responsible for improving automation coverage, reliability, and maintainability.</p><p><strong>Individual level:</strong> Engineers own agreed automation deliverables, including implementation, debugging, and maintenance.</p><p><strong>Leadership level:</strong> QA leads establish standards, review progress, remove blockers, and ensure automation aligns with delivery priorities.</p><p>Ownership should not mean assigning automation work without considering capacity. If testers are already overloaded with manual regression, changing their job expectations without adjusting priorities will simply create another bottleneck.</p><p>I’d work with project managers and engineering leads to allocate time for automation and agree on which existing activities can be reduced or improved.</p><p>I’d also establish practical standards for code reviews, naming conventions, test-data management, failure analysis, and CI/CD execution.</p><p>Automation should be treated as a software engineering responsibility, not a side project performed whenever someone has spare time.</p><h3>7. Measure Outcomes, Not Just Activity</h3><p>A leaderboard showing who wrote the most scripts may create short-term excitement, but it can also encourage poor engineering decisions.</p><p>People may automate easy scenarios simply to increase their numbers, while complex, high-risk workflows remain unprotected.</p><p>I’d measure progress using a balanced set of indicators.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/746/1*lizHLO58fQRI6jJXyp3V8g.png" /><figcaption>Automation Metrics</figcaption></figure><p>These metrics should be interpreted together.</p><p>For example, a growing number of automated tests combined with a rising flaky-test rate is not necessarily progress.</p><p>Likewise, an increase in escaped defects doesn’t automatically mean QA is underperforming. Changes in requirements, release pressure, environment instability, and development practices can all contribute.</p><p>The purpose of measurement is to identify where the system needs improvement — not to create a simplistic ranking of individuals.</p><p>I’d review these indicators regularly with the team and use the findings to adjust the transformation plan.</p><h3>8. Make the First 90 Days Practical</h3><p>A transformation becomes easier to manage when it’s broken into achievable milestones.</p><p>Here’s a practical 90-day approach.</p><p><strong>Days 1–30: Understand and establish the foundation</strong></p><p>Assess skills, identify resistance, review existing automation, and select high-value workflows. Agree on tooling, standards, ownership, and realistic capacity.</p><p>Deliverable: A baseline assessment, prioritized automation backlog, and individual learning plans.</p><p><strong>Days 31–60: Build and demonstrate value</strong></p><p>Provide hands-on mentoring, automate selected workflows, introduce code reviews, and integrate initial tests into CI/CD where appropriate.</p><p>Track execution reliability, time saved, and blockers.</p><p>Deliverable: A working automation suite that addresses real project needs.</p><p><strong>Days 61–90: Expand and improve</strong></p><p>Extend coverage based on risk and return on investment. Improve test reliability, distribute ownership, review results, and address remaining skills gaps.</p><p>Deliverable: A sustainable operating model with clear responsibilities, measurable outcomes, and a prioritized roadmap.</p><p>These milestones aren’t a promise that every team will reach the same automation level in 90 days. Team size, product complexity, technical debt, and delivery constraints will affect the pace.</p><p>The objective is to demonstrate progress while building the capability to continue improving.</p><h3>9. What If Someone Still Refuses to Change?</h3><p>Not every concern will disappear through coaching.</p><p>After providing clear expectations, relevant training, mentoring, and reasonable opportunities to practise, some individuals may continue refusing agreed responsibilities.</p><p>At that point, I’d separate capability problems from commitment problems.</p><p>A capability problem means the person is trying but still needs support. The appropriate response is targeted coaching, clearer milestones, and time to improve.</p><p>A commitment problem means the person understands the expectations, has received reasonable support, and repeatedly refuses to participate without a valid reason.</p><p>That situation requires a direct performance conversation.</p><p>I’d document the agreed expectations, evidence of progress or non-progress, support provided, and the next review date. Any formal performance action should follow company policy and be handled fairly.</p><p>The key is consistency. Automation should not be an optional preference if it is a legitimate requirement of the role, but neither should employees be judged against expectations they were never given a fair opportunity to meet.</p><p>Leadership means supporting people through change while remaining accountable for the outcome.</p><h3>Final Thoughts: Transform the Team, Not Just the Toolset</h3><p>Introducing an automation framework is relatively straightforward compared with changing how a QA team works.</p><p>The harder work involves helping people develop new skills, establishing accountability, creating time for engineering, aligning management expectations, and building trust in the new approach.</p><p>If I were leading this transformation, I wouldn’t begin by asking how many test cases the team could automate next month.</p><p>I’d begin by asking three questions:</p><p>1. Which quality problems are we trying to solve?<br>2. What prevents our team from solving them more effectively today?<br>3. What measurable improvement can we demonstrate in the next 30 days?</p><p>Those answers would shape the roadmap, training, ownership model, and metrics.</p><p>The real success of a QA transformation isn’t that every tester suddenly becomes an automation expert. It’s that the team becomes more effective at protecting quality, delivering feedback quickly, and adapting to the demands of modern software development.</p><p><strong>Automation is a technical capability. Building a team that embraces continuous improvement is a leadership achievement.</strong></p><p>And I’d like to hear from other QA leaders:</p><p><strong>When you’ve tried to move a manual QA team toward automation, what was the biggest obstacle — technical skills, resistance to change, lack of management support, or unrealistic delivery expectations? What worked for you?</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a1766498d853" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Is Making Developers Faster. Is QA Becoming the Bottleneck?]]></title>
            <link>https://medium.com/@dasuner/ai-is-making-developers-faster-is-qa-becoming-the-bottleneck-6bf9593ef040?source=rss-641724e93ac8------2</link>
            <guid isPermaLink="false">https://medium.com/p/6bf9593ef040</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[quality-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Dasun Eranthika]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 10:41:04 GMT</pubDate>
            <atom:updated>2026-09-28T10:41:04.072Z</atom:updated>
            <content:encoded><![CDATA[<p>As AI accelerates software development, the traditional QA process is struggling to keep up. The solution isn’t simply to automate more tests — it’s to rethink how quality is built, validated, and delivered.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o6u6uhA2c2Krb9jVD9ncJA.png" /><figcaption>AI is making faster development, has QA adopted?</figcaption></figure><h3><strong>The productivity paradox of AI-powered development</strong></h3><p>Software development is changing faster than ever.<br>With AI-powered coding assistants, developers can generate code, build features, write unit tests, and fix bugs in a fraction of the time it used to take. Tasks that once required hours of implementation can now be completed in minutes.<br>But there’s a problem hiding behind this productivity boost.<br>The faster we produce software, the more pressure we put on the systems responsible for validating its quality.<br>Imagine a development team that previously delivered five features per sprint. With AI-assisted development, the same team can now deliver ten or fifteen.<br>Has the QA team’s capacity doubled or tripled?<br>Usually, it hasn’t.<br>Test planning, exploratory testing, regression testing, integration validation, and release sign-off still require time, coordination, and reliable environments.<br>The result is a growing imbalance: development accelerates, but quality validation struggles to keep pace.<br>QA becomes the bottleneck — not because testers are working slowly, but because the delivery system is generating work faster than its validation process can absorb it.<br>And this is not just a testing problem. It is a software delivery problem.</p><h3><strong>1. The real problem: AI accelerates code creation, not necessarily quality validation</strong></h3><p>AI is changing the economics of software development. But faster code generation does not automatically translate into faster, reliable software delivery.<br>A <a href="https://www.blackduck.com/resources/analyst-reports/state-of-ai-powered-software-development.html">2026 survey</a> of 831 software engineering and DevOps professionals found that 90% of teams encountered issues with AI-generated code. Manual review, security testing, and code rework were among the most frequently reported bottlenecks. <br>This is the emerging challenge for Quality Engineering.<br>Consider a typical delivery pipeline:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/753/1*FYrmU91E4hk76yhr4v8wmg.png" /><figcaption>Delivery Pipeline with AI-assisted development</figcaption></figure><p>The bottleneck is not necessarily the number of testers. It is the mismatch between the rate of change entering the delivery pipeline and the capacity to validate those changes.<br>This is why simply asking QA engineers to work harder, execute more test cases, or extend their working hours is not a sustainable solution.</p><h3><strong>2. Why traditional QA processes struggle in the AI era</strong></h3><p><strong>A. More code means more things to validate</strong><br>AI can generate entire features, API endpoints, database queries, and UI components. But every new change introduces potential risks.<br>A seemingly small feature can affect:<br>• Existing business workflows.<br>• API contracts and integrations.<br>• Data integrity and database operations.<br>• Security and access control.<br>• Performance and system stability.<br>The challenge is not just testing the new feature. It is understanding what else the feature might break.</p><p><strong>B. AI-generated tests can create a false sense of confidence</strong><br>One tempting response to AI-generated code is to use AI to generate more test cases.<br>However, generating a test is not the same as validating its effectiveness.<br>AI-generated tests may:<br>• Repeat existing coverage without identifying new risks.<br>• Encode incorrect assumptions about business requirements.<br>• Assert implementation details rather than meaningful outcomes.<br>• Pass while the underlying feature is still incorrect.<br>• Become fragile when the application changes.<br><a href="https://www.sciencedirect.com/science/article/abs/pii/S0950584924002155">AI-assisted testing research</a> has identified challenges involving coverage quality, explainability, and generated tests that can adapt to incorrect behavior instead of exposing it. <br><strong>The objective should not be to generate more tests. It should be to increase meaningful risk coverage.</strong></p><p><strong>C. Manual regression testing becomes increasingly expensive</strong><br>Many teams still depend on manual regression testing before every release.<br>When release frequency increases, the same regression suite may need to be executed repeatedly, creating a growing demand for QA capacity.<br>Even with automation, maintenance can become a problem if tests are tightly coupled to implementation details or depend on unstable environments.<br><a href="https://www.sciencedirect.com/science/article/abs/pii/S0950584925001387">A review of AI-assisted test automation</a> literature identified test development and maintenance as major challenges in automation, while AI-generated tests and self-healing scripts emerged as common approaches to addressing them.</p><p><strong>D. QA becomes a downstream inspection function</strong><br>In traditional delivery models, developers finish implementation and then hand the work over to QA.<br>This creates a queue.<br>QA discovers defects late, developers switch back to fix them, and testers repeat validation. As the volume of changes grows, the queue becomes more difficult to manage.<br>Quality cannot be treated as the final stage of development when development itself is accelerating.</p><h3>3. How do we reduce the QA bottleneck?</h3><p>The answer is not to eliminate testing or replace testers with AI.<br>The answer is to redesign the delivery process so that quality validation scales with development.<br>Here are six practical strategies.</p><p><strong>Strategy 1: Shift quality ownership to the entire engineering team</strong><br>The first change is cultural.<br>Quality should not be the sole responsibility of the QA team. Developers, QA engineers, product managers, architects, and operations teams all contribute to software quality.<br>Developers should own the quality of the code they create, including AI-generated code.<br>This means:<br>• Unit tests are written and executed alongside implementation.<br>• Developers validate acceptance criteria before handing over work.<br>• Code reviews include testability, security, and maintainability.<br>• API contracts are validated before integration.<br>• QA engineers focus on risk, system behavior, and independent validation.<br>QA evolves from being the final inspection team into a quality engineering function that helps the entire organization build quality into the delivery process.<br>This does not remove QA accountability. It distributes quality ownership while preserving independent testing where it matters.</p><p><strong>Strategy 2: Introduce risk-based testing instead of testing everything equally</strong><br>When development speed increases, running every possible test for every change becomes impractical.<br>Not every change carries the same risk.<br>A minor UI text change does not require the same validation depth as a change to financial calculations, authentication, or customer data processing.<br>A risk-based approach considers:<br>1. Business impact: What happens if this feature fails?<br>2. Technical complexity: How many components or services are affected?<br>3. Change scope: What existing functionality might be impacted?<br>4. Historical reliability: Has this component experienced recurring defects?<br>5. Security and compliance: Could the change expose sensitive data or violate a requirement?<br>Based on these factors, testing can be prioritized.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/713/1*t6ncRfLln489BaeD08LHqA.png" /><figcaption>Risk-based prioritization</figcaption></figure><p>The goal is to spend testing effort where failures would have the greatest impact.<br>Risk-based testing should be supported by evidence and clear escalation rules, not used as an excuse to skip necessary testing.</p><p><strong>Strategy 3: Build an intelligent, layered automation strategy</strong></p><p>Automation is essential, but automation alone is not the answer.</p><p>The most effective approach is a layered testing architecture in which each layer provides fast, reliable feedback at the appropriate level.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/754/1*1LtrhqNsmIyQf-lgK0bLfQ.png" /><figcaption>Layered Testing Architecture</figcaption></figure><p>A practical implementation could use:</p><p>• Playwright for UI and API automation.</p><p>•Contract testing for service integrations.</p><p>•k6 for performance and load testing.</p><p>•Static analysis and security scanning in CI/CD.</p><p>•AI-assisted test generation and maintenance where it provides measurable value.</p><p>The key is to keep the fastest and most reliable checks close to code changes, while reserving slower, more expensive testing for the appropriate stages.</p><p><strong>Strategy 4: Use AI to accelerate QA — but keep human judgment in the loop</strong></p><p>AI can help reduce repetitive work across the testing lifecycle.</p><p>The opportunity is much broader than automatically generating test scripts.</p><pre>|QA Activity | How AI can help |<br>|--------|--------|<br>|Requirement analysis|Identify ambiguities, missing acceptance criteria, and edge cases|<br>|Test design|Suggest scenarios, boundary values, and risk-based test ideas|<br>|Test automation|Generate initial scripts and reusable automation components|<br>|Regression testing|Recommend relevant tests based on code changes|<br>|Defect analysis|Summarize logs, cluster similar defects, and suggest potential causes|<br>|Test maintenance|Identify outdated locators and suggest script updates|<br>|Test data|Generate synthetic data and propose useful data combinations|</pre><p>But there is an important principle:</p><p>AI can accelerate the creation and execution of tests. It cannot independently establish that the system is correct.</p><p>Human review remains essential for business-critical logic, expected outcomes, security-sensitive workflows, and ambiguous requirements.</p><p>AI-generated tests should be reviewed, executed, and assessed for meaningful coverage before they become part of a trusted regression suite.</p><p><strong>Strategy 5: Embed quality gates into CI/CD pipelines</strong></p><p>A quality gate is an automated checkpoint that evaluates whether a change meets defined quality criteria before progressing through the delivery pipeline.</p><p>Instead of waiting for a QA team to complete all testing at the end, teams can validate changes continuously.</p><p>A practical pipeline might look like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*r9Ybx6KCm8lPqS1GIHCeGw.png" /><figcaption>Quality gates in CI/CD pipeline</figcaption></figure><p>Quality gates should be based on meaningful criteria, such as:</p><p>•Critical test failures.</p><p>•Security vulnerabilities above an agreed severity threshold.</p><p>•API contract violations.</p><p>•Required business-critical test coverage.</p><p>•Performance thresholds for critical workflows.</p><p>The pipeline should also distinguish between blocking failures and issues that can be tracked without stopping every release.</p><p>A quality gate is only useful when its criteria are reliable, relevant, and consistently enforced.</p><p><strong>Strategy 6: Make test environments and test data reliable</strong></p><p>Even the best automation framework cannot deliver fast feedback when test environments are unstable.</p><p>Common sources of delay include:</p><p>•Shared environments with conflicting deployments.</p><p>•Unreliable test data.</p><p>•Dependencies on unavailable third-party services.</p><p>•Slow environment provisioning.</p><p>•Tests that depend on execution order.</p><p>•Uncontrolled changes to test configurations.</p><p>To reduce these delays, teams should invest in:</p><p>1.On-demand test environments where practical.</p><p>2.API mocks and service virtualization for unavailable dependencies.</p><p>3.Synthetic and reusable test data.</p><p>4.Isolated test execution and cleanup.</p><p>5.Environment health checks and observability.</p><p>6.Automated setup and teardown of test infrastructure.</p><p>Reliable infrastructure reduces the time testers spend investigating environmental failures instead of validating product behavior.</p><h3>4. What should QA leaders measure in the AI era?</h3><p>Traditional QA metrics such as test case counts, number of defects found, and automation percentage do not fully explain whether quality is keeping up with development.</p><p>A team may have thousands of automated tests and still release unreliable software.</p><p>QA leaders should measure the performance of the entire delivery system.</p><pre>|Metric|What it tells us|<br>|----|-----|<br>|Change lead time|How long a code change takes to reach production|<br>|Validation cycle time|How long testing and quality checks take|<br>|Escaped defect rate|How often defects reach customers or production|<br>|Change failure rate|How often deployments cause failures or require remediation|<br>|Automated test reliability|How consistently automated tests produce trustworthy results|<br>|Flaky test rate|How often tests fail inconsistently without a product defect|<br>|Rework rate|How much engineering effort is spent correcting previously delivered work|<br>|Risk coverage|Whether critical business and technical risks are adequately validated|</pre><p>The most important question is not:</p><blockquote>“How many test cases did we automate this month?”</blockquote><p>It is:</p><blockquote>“Are we delivering software faster while maintaining or improving quality and reliability?”</blockquote><h3>5. A practical 90-day roadmap to reduce the QA bottleneck</h3><p>Organizations do not need to transform their entire QA function overnight.</p><p>A structured 90-day approach can help identify bottlenecks, introduce improvements, and measure the impact.</p><p><strong>Days 1–30<br>Phase 1: Identify and measure</strong></p><p>•Map the delivery pipeline and identify where work accumulates.</p><p>•Measure validation cycle time, regression duration, and escaped defects.</p><p>•Identify repetitive manual testing and unstable automation.</p><p>•Assess AI usage across development and QA.</p><p>•Select one product or team for a pilot.</p><p><strong>Days 31–60<br>Phase 2: Automate and integrate</strong></p><p>•Introduce risk-based test selection.</p><p>•Add reliable API and component-level automation.</p><p>•Integrate quality gates into CI/CD.</p><p>•Pilot AI-assisted test design and defect analysis.</p><p>•Improve test data and environment reliability.</p><p><strong>Days 61–90<br>Phase 3: Optimize and scale</strong></p><p>•Compare delivery and quality metrics against the baseline.</p><p>•Reduce flaky tests and unnecessary regression execution.</p><p>•Expand successful practices to additional teams.</p><p>•Establish quality ownership across engineering.</p><p>•Review AI-generated test quality and automation ROI.</p><p>The purpose of this roadmap is not to maximize automation in 90 days. It is to establish a repeatable delivery process in which quality validation can scale without sacrificing confidence.</p><h3>6. The role of the modern QA engineer</h3><p>As AI takes on more repetitive testing activities, the role of the QA engineer will continue to evolve.</p><p>The value of a QA professional will increasingly come from their ability to:</p><p>•Understand business risk and customer impact.</p><p>•Design effective testing strategies.</p><p>•Challenge assumptions in AI-generated code and tests.</p><p>•Identify complex failure scenarios.</p><p>•Build and maintain reliable automation.</p><p>•Analyze system behavior across distributed services.</p><p>•Influence engineering practices and quality decisions.</p><p>This is not the end of QA.</p><p>It is a shift from executing predefined test cases toward engineering quality into the entire software delivery process.</p><p>The modern QA engineer is not simply a person who verifies whether a feature works.</p><p>They are a quality risk specialist, a systems thinker, an automation engineer, and a partner in delivering reliable software.</p><h3>7. The real bottleneck is not QA. It is the way we deliver software.</h3><p>AI is exposing weaknesses that have existed in software delivery for years.</p><p>Siloed teams, late testing, fragile automation, unstable environments, unclear requirements, and quality ownership concentrated in one department were already creating friction.</p><p>AI is simply making those weaknesses more visible.</p><p>The organizations that respond by asking QA teams to execute more tests will continue to struggle.</p><p>The organizations that redesign their delivery systems around continuous validation, risk-based testing, reliable automation, and shared quality ownership can turn faster development into faster, more dependable delivery.</p><p>AI should not be measured by how much code it generates. It should be measured by how much reliable software the entire engineering organization can deliver.</p><p>That is the real opportunity for Quality Engineering.</p><p><strong>Final thoughts</strong></p><p>The future of QA is not about competing with AI or trying to keep pace with the volume of code it generates.</p><p>It is about building a delivery system where quality validation happens continuously, intelligently, and collaboratively.</p><p>AI can accelerate development. Automation can accelerate validation. But engineering judgment, risk awareness, and accountability are what turn those capabilities into reliable software.</p><p>The goal is not to make QA faster at testing everything.</p><p><strong>The goal is to make quality a continuous engineering capability, so QA never becomes the reason innovation has to wait.</strong></p><p><strong>Sources and further reading</strong></p><p>•<a href="https://www.blackduck.com/resources/analyst-reports/state-of-ai-powered-software-development.html">The State of AI-Powered Software Development — Black Duck, 2026</a></p><p>•<a href="https://www.sciencedirect.com/science/article/abs/pii/S0950584924002155">Using AI-based coding assistants in practice — Information and Software Technology, 2025</a></p><p>•<a href="https://www.sciencedirect.com/science/article/abs/pii/S0950584925001387">A multi-year grey literature review on AI-assisted test automation — 2025</a></p><p>•<a href="https://dl.acm.org/doi/10.1145/3772318.3791176">When Help Hurts: Verification Load and Fatigue with AI Coding Assistants — CHI 2026</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6bf9593ef040" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Hidden Cost of Flaky Tests Nobody Talks About]]></title>
            <link>https://medium.com/@dasuner/the-hidden-cost-of-flaky-tests-nobody-talks-about-8ca2c4eb17f7?source=rss-641724e93ac8------2</link>
            <guid isPermaLink="false">https://medium.com/p/8ca2c4eb17f7</guid>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[quality-engineering]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[flaky-tests]]></category>
            <dc:creator><![CDATA[Dasun Eranthika]]></dc:creator>
            <pubDate>Tue, 08 Sep 2026 06:28:10 GMT</pubDate>
            <atom:updated>2026-09-08T06:28:10.640Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hNcfoKTShNa-MO9WDPqwPw.png" /><figcaption>The Hidden cost of Flaky Tests</figcaption></figure><p>A test fails.</p><p>The developer checks the failure.</p><p><em>“Probably flaky.”</em></p><p>They rerun it.</p><p>It passes.</p><p>Everyone moves on.</p><p>A few days later, the same thing happens.</p><p>Rerun &gt; Pass</p><p>Again.</p><p>Rerun &gt; Pass</p><p>Eventually, something dangerous happens.</p><p><strong>Nobody trusts the test anymore.</strong></p><p>The test still exists. <br>The pipeline still runs. <br>The dashboard still shows results.</p><p>But the organization has quietly stopped listening.</p><p>That is the real cost of flaky tests.</p><p>It isn’t just a red pipeline.</p><p>It is <strong><em>lost trust in the entire quality engineering system.</em></strong></p><h3>What exactly is a flaky test?</h3><blockquote>A flaky test is a test that produces inconsistent results without a corresponding change in the application under test.</blockquote><p>For example:</p><pre>Build #101 → Test failed<br>Build #102 → Test passed<br>Build #103 → Test failed<br>Build #104 → Test passed</pre><p>The application hasn’t meaningfully changed.</p><p>The test outcome changed.</p><p>Common causes include:</p><p>- Race conditions<br>- Poor synchronization<br>- Hard-coded waits<br>- Unstable test data<br>- Shared state between tests<br>- Environment instability<br>- Network dependency<br>- Third-party service dependency<br>- Time/date dependencies<br>- Parallel execution issues<br>- Poor cleanup<br>- Browser or infrastructure issues</p><p>But identifying the technical cause is only half the problem.</p><p>The bigger problem is what happens after the organization experiences repeated flaky failures.</p><h4>1. Flaky Tests Destroy Developer Trust</h4><p>Imagine a developer opens a pull request.</p><p>The CI pipeline reports:</p><p>❌ 7 tests failed</p><p>The developer investigates.</p><p>Six of them are known flaky tests.</p><p>They rerun the pipeline.</p><p>✅ All tests passed.</p><p>What did the developer learn?</p><p>Not whether the application is healthy.</p><p>They learned:</p><blockquote>“If the pipeline fails, just rerun it.”</blockquote><p>That’s a serious problem.</p><p>The pipeline was designed to provide a quality signal.</p><p>Instead, it became an obstacle that developers know how to bypass.</p><p>Over time, developers develop a mental classification:</p><pre>Pipeline failure<br> ↓<br>Is it a real failure?<br> ↓<br>Maybe<br> ↓<br>Check test name<br> ↓<br>Known flaky?<br> ↓<br>Rerun<br> ↓<br>Pass<br> ↓<br>Ignore</pre><p>The test may still technically be part of the quality gate.</p><p>But psychologically, it isn’t.</p><p><strong>Trust is binary</strong></p><p>A developer doesn’t need to believe that 99% of your tests are reliable.</p><p>They need confidence that:</p><blockquote>When the pipeline says something is broken, I should investigate it.</blockquote><p>Once developers stop believing that, your automation suite loses much of its value.</p><h4>2. Flaky Tests Create “Boy Who Cried Wolf” Syndrome</h4><p>One flaky test isn’t usually a disaster.</p><p>Ten flaky tests are annoying.</p><p>Hundreds of flaky tests can make your automation suite almost useless.</p><p>Consider a pipeline with 1,000 automated tests.</p><p>Suppose:</p><p>- 950 are stable<br>- 50 are flaky</p><p>A pipeline failure doesn’t immediately tell you whether the application has a defect.</p><p>You now have to investigate the test result first.</p><p>That’s additional cognitive load.</p><p>Instead of:</p><pre>Failure → Investigate application</pre><p>you get:</p><pre>Failure<br> ↓<br>Investigate test<br> ↓<br>Is the test flaky?<br> ↓<br>Rerun<br> ↓<br>Check logs<br> ↓<br>Check environment<br> ↓<br>Check test data<br> ↓<br>Finally investigate application</pre><p>Automation was supposed to reduce feedback time.</p><p>Flakiness can do the opposite.</p><h4>3. The Pipeline Becomes Background Noise</h4><p>This is one of the most dangerous outcomes.</p><p>A team starts seeing red pipelines every day.</p><p>Initially:</p><blockquote>“Why did the pipeline fail?”</blockquote><p>Then:</p><blockquote>“Probably automation.”</blockquote><p>Eventually:</p><blockquote>“The pipeline is always red.”</blockquote><p>And finally:</p><blockquote>“Nobody looks at it anymore.”</blockquote><p>This is how a quality gate becomes decoration.</p><p>A red pipeline that everyone ignores is worse than having no pipeline at all.</p><p>Why?</p><p>Because it creates a false perception of quality control.</p><p>The organization believes automated testing is protecting them.</p><p>But the team has already learned not to trust its results.</p><h4>4. False Failures Have a Real Business Cost</h4><p>Flaky tests don’t just waste QA time.</p><p>They consume engineering capacity.</p><p>Consider a simplified example.</p><p>A team has:</p><p>- 20 developers<br>- 10 CI pipelines per developer per week<br>- 200 pipeline runs per week</p><p>If 10% of pipeline failures are caused by flaky tests, that’s potentially dozens of investigations or reruns every week.</p><p>Even if each incident costs only 10 minutes:</p><pre>30 flaky failures × 10 minutes<br>= 300 minutes<br>= 5 engineering hours/week</pre><p>Over a year:</p><pre>5 hours × 52 weeks<br>= 260 engineering hours</pre><p>That’s more than six full working weeks of engineering time.</p><p>And that’s a very conservative example.</p><p>The cost becomes much larger when you include:</p><p>- Developer context switching<br>- QA investigation<br>- CI infrastructure usage<br>- Delayed deployments<br>- Blocked pull requests<br>- Delayed releases<br>- Production incidents caused by ignored failures<br>- Management time spent investigating unreliable metrics</p><p>The biggest cost is often invisible:</p><p>lost engineering attention.</p><h4>5. Flakiness Can Hide Real Defects</h4><p>This is where flaky tests become particularly dangerous.</p><p>Imagine a team has a test that frequently fails because of timing issues.</p><p>The pipeline fails.</p><p>The team sees:</p><pre>CheckoutTest failed</pre><p>Someone reruns it.</p><p>It passes.</p><p>The failure is classified as flaky.</p><p>A week later, the checkout service genuinely breaks.</p><p>The same test fails.</p><p>What happens?</p><p>Someone says:</p><blockquote>“That’s probably the flaky checkout test again.”</blockquote><p>They rerun it.</p><p>Maybe it passes because the defect is intermittent.</p><p>The real defect gets buried underneath historical noise.</p><p>This is the hidden danger:</p><p>Flakiness reduces the signal-to-noise ratio of your test suite.</p><p>When everything looks suspicious, nothing gets urgent attention.</p><h4>6. Retry Is Not a Flakiness Strategy</h4><p>One of the most common responses to flaky tests is:</p><blockquote>“Let’s add retries.”</blockquote><p>Retries have a legitimate use.</p><p>For example, a temporary infrastructure problem might justify retrying a test.</p><p>But retries should not be used to hide an unreliable test.</p><p>Consider:</p><pre>Attempt 1 → Fail<br>Attempt 2 → Pass</pre><p>Your dashboard may report:</p><p>Test Passed</p><p>But the reality is:</p><p>The test failed once and passed once.</p><p>That’s important information.</p><p>Retries can improve pipeline resilience.</p><p>They should not improve your flakiness statistics by hiding failures.</p><p><strong>A better approach</strong></p><p>Track both:</p><pre>Final result: PASS<br>Attempts:<br>1 → FAIL<br>2 → PASS<br>Classification:<br>FLAKY</pre><p>That gives engineering teams visibility into the real problem.</p><h4>7. How Do You Measure Flakiness?</h4><p>If you don’t measure it, you will eventually normalize it.</p><p>A simple metric is:</p><p><strong>Flakiness Rate</strong></p><pre>Flakiness Rate =<br>Flaky Test Executions / Total Test Executions × 100</pre><p>For example:</p><pre>10,000 test executions<br>150 identified flaky executions<br>Flakiness Rate = 1.5%</pre><p>But a single percentage isn’t enough.</p><p>You should also track:</p><p><strong>Flaky Test Count</strong></p><p>How many unique tests are currently flaky?</p><pre>Total automated tests: 2,500<br>Flaky tests: 37</pre><p><strong>Flaky Failure Frequency</strong></p><p>How often does each test fail intermittently?</p><p>A test that flakes once a month is different from one that flakes every day.</p><p><strong>Mean Time to Repair Flaky Tests</strong></p><p>How long does it take to fix a flaky test after identification?</p><pre>Identified → Fixed<br>Day 0 → Day 3</pre><p><strong>Rerun Rate</strong></p><p>How frequently are failed tests rerun?</p><p>A high rerun rate can be a warning sign.</p><pre>Pipeline failures: 500<br>Reruns: 420<br>Rerun rate = 84%</pre><p>That deserves investigation.</p><p><strong>Flaky Test Age</strong></p><p>This is a metric I particularly like.</p><p>Track how long a test remains known to be flaky.</p><pre>Test A → 2 days<br>Test B → 14 days<br>Test C → 67 days<br>Test D → 180 days</pre><p>A flaky test that survives for six months isn’t a testing problem anymore.</p><p>It’s a process problem.</p><h4>8. Create a Flakiness Budget</h4><p>Just like teams think about technical debt, reliability, and error budgets, automation teams can establish a flakiness budget.</p><p>For example:</p><blockquote>No more than 1% of automated executions should be classified as flaky.</blockquote><p>And:</p><blockquote>Any test identified as flaky must have an owner and remediation plan.</blockquote><p>This changes the conversation.</p><p>Instead of:</p><blockquote>“Our tests are sometimes flaky.”</blockquote><p>You can say:</p><blockquote>“Our flakiness rate increased from 0.8% to 2.1% this month.”</blockquote><p>Now you have something measurable.</p><p>And measurable problems can be managed.</p><h4>9. Don’t Treat All Flaky Tests Equally</h4><p>Not every flaky test deserves the same response.</p><p>I recommend categorizing them.</p><p><strong>Category 1 — Critical journey</strong></p><p>Examples:</p><p>- Login<br>- Payment<br>- Checkout<br>- Account creation<br>- Data submission</p><p>These should receive immediate attention.</p><p><strong>Category 2 — Frequently executed</strong></p><p>A test that runs 5,000 times per month and flakes 20 times can create more disruption than a test that runs once a month and flakes once.</p><p>C<strong>ategory 3 — Low-value test</strong></p><p>If a test has low business value and high maintenance cost, consider removing or redesigning it.</p><p>This is an important lesson:</p><blockquote>The goal isn’t to preserve every automated test.</blockquote><p>The goal is to maintain a trustworthy test suite.</p><p>Sometimes deleting a bad test is better than continuously repairing it.</p><h4>10. Find the Root Cause Instead of Adding Sleeps</h4><p>A classic example:</p><pre>await page.waitForTimeout(5000);</pre><p>It might make the test pass today.</p><p>But it doesn’t solve synchronization.</p><p>The application might need:</p><p>- An API response<br>- A specific UI state<br>- An element to become enabled<br>- A background process to complete<br>- A database transaction to finish</p><p>A better approach is to synchronize against a meaningful condition.</p><p>For example:</p><pre>await expect(page.getByRole(&#39;button&#39;, {<br> name: &#39;Submit&#39;<br>})).toBeEnabled();</pre><p>The principle is simple:</p><blockquote>Wait for a condition, not a duration.</blockquote><p>Hard waits are often a symptom that the test doesn’t understand the system it’s testing.</p><h4>11. Investigate Flakiness Systematically</h4><p>When a test becomes flaky, don’t immediately modify the assertion.</p><p>Investigate it.</p><p>Ask:</p><blockquote>Is the test isolated?</blockquote><p>Can another test change its state?</p><blockquote>Is test data deterministic?</blockquote><p>Does the test depend on shared or randomly generated data?</p><blockquote>Is there a race condition?</blockquote><p>Could the test be executing before the application finishes an operation?</p><blockquote>Is the environment stable?</blockquote><p>Are services, databases, containers, or browsers behaving consistently?</p><blockquote>Is there an external dependency?</blockquote><p>Does the test depend on:</p><p>- Payment providers<br>- Email services<br>- Third-party APIs<br>- Authentication providers<br>- External databases</p><blockquote>Does parallel execution expose the problem?</blockquote><p>A test that passes consistently in isolation but fails under parallel execution is telling you something.</p><p>Don’t simply reduce parallelism.</p><p>Understand why parallel execution breaks it.</p><h4>12. Build a Flaky Test Lifecycle</h4><p>Flaky tests should have a lifecycle.</p><p>For example:</p><pre>Detected<br> ↓<br>Classified<br> ↓<br>Assigned<br> ↓<br>Investigated<br> ↓<br>Fixed<br> ↓<br>Monitored<br> ↓<br>Stable</pre><p>And importantly:</p><pre>Detected<br> ↓<br>No owner<br> ↓<br>Ignored</pre><p>should not be an acceptable lifecycle.</p><p>Every flaky test should have an owner.</p><p>That owner might be:</p><p>- QA engineer<br>- SDET<br>- Developer<br>- Feature team<br>- Platform team</p><p>depending on the root cause.</p><h4>13. Quarantine Can Be Useful — If It’s Temporary</h4><p>Sometimes you cannot fix a flaky test immediately.</p><p>Perhaps the team is in the middle of a release.</p><p>Perhaps the issue requires infrastructure changes.</p><p>In those situations, quarantine can be useful.</p><p>But quarantine should mean:</p><blockquote>Temporarily removed from the quality gate while being actively remediated.</blockquote><p>It should not mean:</p><blockquote>Put it in a folder nobody remembers.</blockquote><p>A good quarantine system should track:</p><p>- Test name<br>- Reason<br>- Owner<br>- Date quarantined<br>- Root cause<br>- Target fix date<br>- Current status</p><p>And ideally, automatically alert when quarantine exceeds an agreed threshold.</p><h4>14. Prevention Is Better Than Cleanup</h4><p>The best flaky-test strategy is not fixing hundreds of flaky tests.</p><p>It’s preventing them from being created.</p><p>During test development, teams should establish standards around:</p><p>- Test isolation<br>- Deterministic test data<br>- Reliable selectors<br>- Proper synchronization<br>- API mocking where appropriate<br>- Independent test environments<br>- Cleanup and teardown<br>- Parallel execution safety<br>- Dependency management<br>- Observability and logging</p><p>Code review should ask:</p><blockquote>“Could this test become flaky?”</blockquote><p>Not only:</p><blockquote>“Does this test pass?”</blockquote><p>That’s a significant shift in mindset.</p><h4>15. The Ultimate Metric Is Trust</h4><p>You can create beautiful automation dashboards.</p><p>You can track:</p><p>- Test execution count<br>- Pass rate<br>- Failure rate<br>- Automation coverage<br>- Execution duration<br>- Flakiness rate</p><p>But there is one metric that is harder to put on a dashboard:</p><p>Do developers trust the pipeline?</p><p>Ask your engineering team:</p><blockquote>“When the CI pipeline fails, do you immediately investigate it?”</blockquote><p>If the answer is no, you have a quality problem.</p><p>Ask:</p><blockquote>“How often do you rerun a failed pipeline before investigating?”</blockquote><p>If the answer is “almost every time,” investigate why.</p><p>Ask:</p><blockquote>“Which tests do you consider unreliable?”</blockquote><p>The answers will often reveal more than your automation dashboard.</p><h3>A Practical Flakiness Dashboard</h3><p>A useful dashboard could look something like this:</p><pre>| Metric   | Current | Target |<br>| -------- | ------- | ------- |<br>| Automated tests | 2,500 | - |<br>| Flaky tests | 37 | &lt;10 |<br>| Flakiness rate | 1.8% | &lt;1% |<br>| Rerun rate | 24% | &lt;10% |<br>| Avg. flaky-test age | 21 days | &lt;7 days |<br>| Tests quarantined | 12 | &lt;5 |<br>| MTTR for flaky tests | 9 days | &lt;3 days |</pre><p>More importantly, trend these metrics over time.</p><p>Because:</p><p>A snapshot tells you where you are.</p><p>A trend tells you whether you’re improving.</p><h3>The Goal Isn’t Zero Red Builds</h3><p>This might sound controversial.</p><p>Your goal shouldn’t be:</p><blockquote>“Never have a red pipeline.”</blockquote><p>Your goal should be:</p><blockquote>Make every red pipeline meaningful.</blockquote><p>A healthy engineering organization will have failures.</p><p>Applications break.</p><p>Tests find defects.</p><p>Infrastructure occasionally fails.</p><p>That’s normal.</p><p>The problem is when you can no longer distinguish:</p><pre>Real defect<br> ↓<br>from<br> ↓<br>Test problem<br> ↓<br>from<br> ↓<br>Environment problem</pre><p>A trustworthy automation system makes that distinction quickly.</p><h3>Final Thought</h3><p>Flaky tests are often treated as a technical nuisance.</p><p>They’re much more than that.</p><p>They affect:</p><p>— Engineering productivity.<br> — Developer confidence.<br> — Release velocity. <br> — CI/CD adoption. <br> — Quality culture. <br> — And ultimately, customer risk.</p><p>The most dangerous flaky test isn’t the one that fails.</p><p>It’s the one that fails so often that people stop caring.</p><p>If your team has started saying:</p><blockquote>“Just rerun it.”</blockquote><p>Stop.</p><p>That sentence may be a symptom of a much bigger problem.</p><p>Don’t measure automation success by how many tests you have.</p><p>Measure it by how much you trust the results.</p><p>Because in quality engineering:</p><blockquote><strong>A test suite nobody trusts is just expensive noise.</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8ca2c4eb17f7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Shift-Right Testing: Quality Doesn’t End at Deployment]]></title>
            <link>https://medium.com/@dasuner/shift-right-testing-quality-doesnt-end-at-deployment-544f129dd1ab?source=rss-641724e93ac8------2</link>
            <guid isPermaLink="false">https://medium.com/p/544f129dd1ab</guid>
            <category><![CDATA[quality-engineering]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[shift-right-testing]]></category>
            <dc:creator><![CDATA[Dasun Eranthika]]></dc:creator>
            <pubDate>Mon, 17 Aug 2026 07:01:14 GMT</pubDate>
            <atom:updated>2026-08-17T07:01:14.049Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HMPJMt9ucRxtbDJ3a_XqHQ.png" /><figcaption>Shift-Right Testing</figcaption></figure><p>For years, software testing has largely been associated with one question:</p><blockquote>“Is this application ready to be released?”</blockquote><p>Testers validate requirements, automate regression suites, perform API and UI testing, execute performance tests, and provide a quality assessment before production.</p><p>Then the deployment happens.</p><p>And the testing mindset often stops.</p><p>But production is where software faces its most unpredictable environment: <strong>real users, real traffic, real devices, real data, and real-world behavior.</strong></p><p>This is where <strong>Shift-Right Testing </strong>comes in.</p><p>Shift-Right Testing extends quality engineering beyond the traditional pre-production testing phase and brings quality practices into production and post-release activities.</p><p>It changes the question from:</p><blockquote><strong>“Did we test it before release?”</strong></blockquote><p>to:</p><blockquote><strong>“How do we continuously understand and improve quality after release?”</strong></blockquote><h3>What Is Shift-Right Testing?</h3><p>Shift-Right Testing is the practice of validating, monitoring, and learning from software after it has been deployed to production or production-like environments.</p><p>Traditional testing focuses heavily on the left side of the software delivery lifecycle:</p><p>Requirements → Development → Testing → Deployment</p><p>Shift-Right adds another dimension:</p><p><strong>Deployment → Monitoring → Validation → Feedback → Improvemen</strong>t</p><p>It doesn’t mean that testing before production becomes less important.</p><p>Instead, it means quality becomes a continuous activity across the entire software lifecycle.</p><p>A modern quality engineering model therefore looks more like:</p><p><strong>Shift Left + Shift Right = Continuous Quality</strong></p><h3>Why Do We Need Shift-Right Testing?</h3><p>No matter how comprehensive your test suite is, you cannot reproduce every production scenario in a test environment.</p><p>Consider a simple e-commerce application.</p><p>You may test:</p><ul><li>Login</li><li>Product search</li><li>Add to cart</li><li>Checkout</li><li>Payment</li><li>Order confirmation</li></ul><p>Your automation suite may contain thousands of tests.</p><p>But production introduces variables that your test environment may never fully reproduce.</p><p>For example:</p><ul><li>A sudden traffic spike</li><li>A specific browser/device combination</li><li>Network instability</li><li>Unexpected user behavior</li><li>Third-party API failures</li><li>Database performance degradation</li><li>Memory leaks</li><li>Infrastructure issues</li><li>Feature interactions</li><li>Real-world data patterns</li></ul><p>A test can tell you:</p><blockquote>“This scenario passed.”</blockquote><p>Production monitoring can tell you:</p><blockquote>“This is what is actually happening.”</blockquote><p>Both are necessary.</p><h3>Shift-Right Is Not Just Monitoring</h3><p>One common misconception is:</p><blockquote>“We already have monitoring and observability, so we are doing Shift-Right Testing.”</blockquote><p>Not necessarily.</p><p>Monitoring answers questions such as:</p><ul><li>Is the service available?</li><li>Is CPU usage high?\</li><li>Is response time increasing?</li><li>Are error rates increasing?</li></ul><p>Shift-Right Testing goes further.</p><p>It asks:</p><ul><li>Are users successfully completing critical journeys?</li><li>Is a new feature behaving correctly for real users?</li><li>Did the latest release introduce unexpected behavior?</li><li>Are certain user segments experiencing failures?</li><li>Is the system degrading under real traffic?</li><li>What did production teach us that our test suite didn’t catch?</li></ul><p>The key difference is the <strong>quality feedback loop</strong>.</p><h3>Key Shift-Right Testing Practices</h3><p>There isn’t one single technique called Shift-Right Testing.</p><p>Instead, it is a collection of practices that allow engineering teams to validate software continuously after deployment.</p><h4>1. Production Monitoring</h4><p>The first layer is understanding the health of your application.</p><p>Typical metrics include:</p><ul><li>Availability</li><li>Response time</li><li>Error rate</li><li>Throughput</li><li>Resource utilization</li><li>Failed requests</li><li>Database performance</li></ul><p>For Quality Engineers, these metrics provide valuable information about production quality.</p><p>For example:</p><p>A regression test may pass with an API response time of 300 ms.</p><p>But production monitoring might reveal that the same API reaches 3 seconds during peak traffic.</p><p>The test passed.</p><p>The user experience didn’t.</p><h4>2. Real User Monitoring</h4><p>Synthetic tests can simulate user journeys.</p><p>Real User Monitoring (RUM) tells you what actual users are experiencing.</p><p>You can collect information such as:</p><ul><li>Page load performance</li><li>JavaScript errors</li><li>Browser information</li><li>Device types</li><li>Geographic performance</li><li>Failed user interactions</li><li>Core Web Vitals</li></ul><p>This is especially valuable for applications with a large and diverse user base.</p><p>A website might perform perfectly on the development team’s laptops but behave differently on:</p><ul><li>Low-end mobile devices</li><li>Older browsers</li><li>Slow networks</li><li>Different geographic regions</li></ul><p>Real users provide a much broader test environment than your QA lab.</p><h4>3. Synthetic Monitoring</h4><p>Interestingly, Shift-Right Testing doesn’t always require real users.</p><p>Synthetic monitoring uses automated scripts to continuously execute critical journeys against a production environment.</p><p>For example:</p><p><em>Login → Search → Add Product → Checkout</em></p><p>A synthetic test can run every few minutes.</p><p>If the checkout journey fails, the engineering team can detect the issue before thousands of customers report it.</p><p>This is essentially <strong>continuous production validation.</strong></p><p>Your existing Playwright automation can often be adapted for this purpose.</p><p><strong>4. Canary Testing</strong></p><p>Imagine releasing a new version to 100% of your customers.</p><p>If something goes wrong, the blast radius can be huge.</p><p>Canary releases reduce that risk.</p><p>Instead of releasing to everyone:</p><p>New Version → 5% users → Monitor → 25% → Monitor → 100%</p><p>The initial group acts as an early feedback mechanism.</p><p>Teams can monitor:</p><ul><li>Error rates</li><li>Performance</li><li>Conversion rates</li><li>Business transactions</li><li>User behavior</li><li>Application stability</li></ul><p>If the new version performs poorly, the rollout can be stopped or rolled back.</p><p>This transforms production into a <strong>controlled validation environment.</strong></p><h4>5. Feature Flags</h4><p>Feature flags allow teams to deploy code without necessarily exposing the feature to everyone.</p><p>For example:</p><pre>New Checkout = OFF</pre><p>The code can be deployed safely.</p><p>Then the feature can be enabled for:</p><pre>Internal users → 5% users → 25% users → 100% users</pre><p>Feature flags allow engineering and QE teams to validate functionality progressively.</p><p>They also provide an important safety mechanism:</p><p><strong>If something goes wrong, disable the feature instead of rolling back the entire deployment.</strong></p><h4>6. A/B Testing</h4><p>A/B testing can also contribute to Shift-Right quality practices.</p><p>Suppose you’re testing two versions of a checkout experience.</p><p><strong>Version A</strong></p><p>Traditional checkout.</p><p><strong>Version B</strong></p><p>New simplified checkout.</p><p>Instead of relying solely on pre-production testing, you can evaluate how real users interact with both versions.</p><p>You might measure:</p><ul><li>Conversion rate</li><li>Checkout completion</li><li>Drop-off rate</li><li>Errors</li><li>Session duration</li></ul><p>This introduces an important concept:</p><blockquote>Quality is not always just the absence of defects.</blockquote><p>A feature can be technically correct but still produce a poor user experience.</p><h4>7. Chaos Engineering</h4><p>What happens if a critical service suddenly becomes unavailable?</p><p>Have you tested that?</p><p>Chaos Engineering intentionally introduces controlled failures into systems to understand how resilient they are.</p><p>Examples include:</p><ul><li>Terminating instances</li><li>Introducing network latency</li><li>Simulating service failures</li><li>Increasing resource pressure</li><li>Disrupting dependencies</li></ul><p>The goal isn’t to break production randomly.</p><p>The goal is to answer:</p><blockquote>“Can our system survive failure?”</blockquote><p>This is especially important for distributed architectures and microservices.</p><h4>8. Production Performance Testing</h4><p>Traditional performance testing often happens before release.</p><p>For example:</p><p>Load Test → Analyze → Fix → Release</p><p>But production provides the most realistic traffic patterns.</p><p>Shift-Right performance practices can include:</p><ul><li>Production telemetry analysis</li><li>Capacity monitoring</li><li>Traffic pattern analysis</li><li>Performance regression detection</li><li>Controlled load testing</li><li>Stress testing in safe environments</li></ul><p>Tools such as k6 can be useful for building repeatable performance validation into the engineering lifecycle.</p><p>The objective isn’t simply:</p><blockquote>“Can the system handle 10,000 requests per second?”</blockquote><p>Instead:</p><blockquote>“How does system performance behave under real-world conditions?”</blockquote><h4>9. Error Tracking and Observability</h4><p>Logs alone are not enough.</p><p>Modern systems need observability across:</p><p><strong>Logs + Metrics + Traces</strong></p><p>Suppose a user reports:</p><blockquote>“Checkout is failing.”</blockquote><p>Traditional debugging might require searching through thousands of logs.</p><p>With distributed tracing, teams can follow the request across:</p><p>Frontend → API Gateway → Checkout Service → Payment Service → Database</p><p>This dramatically improves the ability to identify production defects.</p><p>For QE teams, observability also creates another opportunity:</p><p><strong>Use production failures to improve automated tests.</strong></p><h4>10. Production Bugs Should Become Test Cases</h4><p>This is one of the most important Shift-Right principles.</p><p>Imagine a customer discovers a defect that your test suite didn’t catch.</p><p>The traditional response is:</p><p>Fix the bug → Close the ticket</p><p>A stronger QE response is:</p><p>Fix the bug → Understand why it escaped → Add a regression test → Improve the test strategy</p><p>The production incident becomes a permanent improvement to the quality system.</p><p>This creates a continuous learning loop:</p><pre>Production Failure<br>         ↓<br>Root Cause Analysis<br>         ↓<br>Test Gap Identified<br>         ↓<br>Automated Test Added<br>         ↓<br>Regression Prevention</pre><p>This is how Shift-Right feeds Shift-Left.</p><h3>Shift-Right and Shift-Left Should Work Together</h3><p>Shift-Left and Shift-Right are not competing philosophies.</p><p>They complement each other.</p><pre>| Shift Left | Shift Right |<br>|---|---|<br>| Prevent defects | Detect real-world issues |<br>| Unit testing | Production monitoring |<br>| API testing | Real user monitoring |<br>| UI automation | Synthetic monitoring |<br>| Contract testing | Canary testing |<br>| Performance testing | Production performance analysis |<br>| Security testing | Runtime security monitoring |<br>| Static analysis | Production observability |<br>| Test environments | Real-world environments |</pre><p>The goal isn’t to choose one.</p><p>The goal is to build a <strong>continuous quality feedback loop.</strong></p><h3>The QE Role in Shift-Right Testing</h3><p>This is where Quality Engineering becomes significantly more strategic.</p><p>A traditional QA role might end with:</p><blockquote>“All tests passed. We can release.”</blockquote><p>A Quality Engineer should also be asking:</p><ul><li>What happens after release?</li><li>How will we know if users experience problems?</li><li>What production signals indicate degradation?</li><li>What critical journeys should we monitor?</li><li>What happens if the feature fails?</li><li>Can we automatically detect the failure?</li><li>How quickly can we recover?</li><li>What did production teach us?</li></ul><p>QE therefore becomes a bridge between:</p><p>Testing + Observability + Reliability + Customer Experience</p><h3>Building a Shift-Right Strategy</h3><p>You don’t need to implement everything at once.</p><p>Start with your most critical business journeys.</p><h4>Step 1 — Identify Critical User Journeys</h4><p>For example:</p><ul><li>Login</li><li>Registration</li><li>Search</li><li>Checkout</li><li>Payment</li><li>Booking</li><li>Document submission</li></ul><h4>Step 2 — Define Quality Signals</h4><p>For every journey, identify:</p><ul><li>Availability</li><li>Response time</li><li>Error rate</li><li>Success rate</li><li>Business KPI</li></ul><h4>Step 3 — Automate Synthetic Checks</h4><p>Use automation tools such as Playwright to continuously validate critical journeys.</p><p>For APIs, create lightweight API health checks.</p><h4>Step 4 — Add Observability</h4><p>Ensure your application exposes useful:</p><ul><li>Logs</li><li>Metrics</li><li>Traces</li><li>Error information</li></ul><h4>Step 5 — Introduce Progressive Delivery</h4><p>Use:</p><ul><li>Feature flags</li><li>Canary releases</li><li>Gradual rollouts</li></ul><h4>Step 6 — Create Automated Alerts</h4><p>Don’t wait for customers to report problems.</p><p>Alert teams when important thresholds are exceeded.</p><p>For example:</p><pre>Checkout success rate &lt; 98%<br> ↓<br>Alert<br> ↓<br>QE + Development + SRE<br> ↓<br>Investigate<br> ↓<br>Rollback / Fix</pre><h4>Step 7 — Close the Feedback Loop</h4><p>Every significant production incident should trigger the question:</p><blockquote>“What should we change in our quality strategy so this doesn’t happen again?”</blockquote><p>That change might be:</p><ul><li>A new automated test</li><li>Better monitoring</li><li>Improved test data</li><li>A new performance test</li><li>A contract test</li><li>Better observability</li><li>A change in deployment strategy</li></ul><h3>Measuring Shift-Right Testing</h3><p>If you cannot measure it, it’s difficult to know whether your strategy is working.</p><p>Useful metrics include:</p><h4>Production Defect Escape Rate</h4><p><strong>Escaped Defects / Total Defects × 100</strong></p><p>This helps understand how many defects reach production.</p><h4>Mean Time to Detect (MTTD)</h4><p>How long does it take to identify a production problem?</p><p><strong>Lower is generally better.</strong></p><h4>Mean Time to Recovery (MTTR)</h4><p>How long does it take to restore the service?</p><p><strong>Lower is generally better.</strong></p><h4>Automated Production Check Success Rate</h4><p>For example:</p><p><strong>Synthetic journey passes / Total executions × 100</strong></p><h4>Customer Impact</h4><p>Measure:</p><ul><li>Number of affected users</li><li>Failed transactions</li><li>Revenue impact</li><li>Support tickets</li><li>Business conversion impact</li></ul><p>These metrics help connect technical quality with actual business outcomes.</p><h3>The Biggest Mistake: Treating Production as Someone Else’s Problem</h3><p>One of the biggest organizational problems is the separation between teams.</p><p>Developers build.</p><p>QA tests.</p><p>DevOps deploys.</p><p>SRE monitors.</p><p>Support handles customers.</p><p>But customers don’t experience these organizational boundaries.</p><p>They experience <strong>one product.</strong></p><p>A modern QE model should therefore encourage shared ownership:</p><p>Developers + QA/QE + DevOps/SRE + Product</p><p>working together to maintain quality throughout the lifecycle.</p><h3>Shift-Right Doesn’t Mean “Test in Production”</h3><p>This distinction is important.</p><p>Shift-Right does <strong>not </strong>mean:</p><blockquote>“Let’s release broken software and test it with customers.”</blockquote><p>Instead, it means:</p><blockquote><strong>“Let’s use production feedback, observability, controlled experimentation, and progressive delivery to continuously validate and improve software quality.”</strong></blockquote><p>Risk must be controlled.</p><p>Techniques such as feature flags, canary releases, monitoring, automated rollback, synthetic testing, and controlled experiments make this possible.</p><h3>The Future of Quality Engineering</h3><p>As organizations move toward:</p><ul><li>Continuous delivery</li><li>Microservices</li><li>Cloud-native systems</li><li>AI-powered applications</li><li>Distributed architectures</li><li>High-frequency releases</li></ul><p>traditional testing alone becomes insufficient.</p><p>A test suite can tell us what we expected to happen.</p><p>Production tells us what actually happened.</p><p>The strongest Quality Engineering organizations use both.</p><p>The future is not:</p><p>Testing → Release → Done</p><p>It is:</p><p><strong>Build → Test → Release → Observe → Learn → Improve → Repeat</strong></p><p>That is the real power of Shift-Right Testing.</p><h3>Final Thought</h3><p>Quality is not a phase.</p><p>It is not something that happens only during testing.</p><p>And it certainly doesn’t end when the deployment pipeline turns green.</p><p><strong>Quality continues when real users start using the software.</strong></p><p>Shift-Right Testing gives Quality Engineers the ability to learn from that reality, detect problems faster, reduce customer impact, and continuously improve the product.</p><p>The ultimate goal isn’t simply to release software with fewer bugs.</p><p>It is to build systems that are:</p><ul><li>Observable.</li><li>Resilient.</li><li>Reliable.</li><li>Recoverable.</li><li>And continuously improving.</li></ul><p>That is where Quality Engineering is heading.</p><p><strong>Quality doesn’t end at deployment. <br>That’s where the next feedback loop begins.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=544f129dd1ab" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Stop Measuring QA by the Number of Bugs Found: It’s Time to Rethink Quality Metrics]]></title>
            <link>https://medium.com/@dasuner/stop-measuring-qa-by-the-number-of-bugs-found-its-time-to-rethink-quality-metrics-9027bc97fe37?source=rss-641724e93ac8------2</link>
            <guid isPermaLink="false">https://medium.com/p/9027bc97fe37</guid>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[kpi]]></category>
            <category><![CDATA[quality-metrics]]></category>
            <category><![CDATA[quality-engineering]]></category>
            <dc:creator><![CDATA[Dasun Eranthika]]></dc:creator>
            <pubDate>Wed, 05 Aug 2026 12:51:34 GMT</pubDate>
            <atom:updated>2026-08-05T12:51:34.097Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ap6GstW8MWCGHFF2oexxmg.png" /><figcaption>New Quality Metrics</figcaption></figure><p>For decades, one question has echoed through QA teams during performance reviews and sprint retrospectives:</p><blockquote>“How many bugs did QA find?”</blockquote><p>It sounds like a reasonable metric. After all, finding defects is part of testing.</p><p>But here’s the uncomfortable truth:</p><p><strong>The number of bugs found says very little about the quality of your product — or the effectiveness of your QA team.</strong></p><p>Imagine hiring a security guard and measuring success by the number of thieves they catch. If they catch many thieves, does that mean they’re doing a great job? Or does it mean the building has terrible security?</p><p>Software quality works the same way.</p><p>Modern Quality Engineering is no longer about counting defects. It’s about preventing them, minimizing business risk, and helping teams deliver reliable software faster.</p><p>Let’s explore why bug count is an outdated KPI — and what successful engineering organizations measure instead.</p><h3>The Problem with Measuring Bug Count</h3><p>Many organizations still reward QA engineers based on the number of bugs they report.</p><p>It appears objective.</p><p>It’s easy to track.</p><p>It fits nicely into a spreadsheet.</p><p>Unfortunately, it creates the wrong incentives.</p><p><strong>More Bugs Doesn’t Mean Better QA</strong></p><p>Suppose Team A reports <strong>250 bugs</strong> during a sprint.</p><p>Team B reports <strong>40 bugs</strong>.</p><p>Which team performed better?</p><p>Without context, nobody knows.</p><p>Perhaps Team A tested an unstable application with poor development practices.</p><p>Perhaps Team B worked closely with developers, reviewed requirements early, and prevented most defects before coding even began.</p><p>Ironically, Team B may have delivered far greater value.</p><p><strong>Bug Count Depends on Many Factors</strong></p><p>The number of defects discovered depends on variables that QA often cannot control:</p><ul><li>Code complexity</li><li>Developer experience</li><li>Requirement quality</li><li>Sprint scope</li><li>Application maturity</li><li>Technical debt</li><li>Environment stability</li></ul><p>Using bug count to evaluate QA is like judging firefighters based on the number of fires they extinguish rather than how well a city prevents fires.</p><p><strong>It Encourages the Wrong Behavior</strong></p><p>When bug count becomes a performance metric, unintended consequences follow.</p><p>Teams may begin to:</p><ul><li>Log duplicate bugs</li><li>Split one issue into multiple tickets</li><li>Prioritize minor cosmetic defects over business-critical risks</li><li>Delay collaboration because finding bugs becomes more valuable than preventing them</li></ul><p>Instead of working toward shared quality goals, QA and development can become adversaries.</p><p>Quality suffers.</p><p>Trust declines.</p><p>Customers gain nothing.</p><h3>Quality Is About Business Outcomes</h3><p>Customers don’t care how many defects QA found.</p><p>They care whether the application works.</p><p>Business leaders don’t celebrate large bug reports.</p><p>They celebrate:</p><ul><li>Successful releases</li><li>Happy customers</li><li>Stable systems</li><li>Faster delivery</li><li>Lower operational costs</li></ul><p>That’s why modern organizations focus on **quality outcomes**, not testing activity.</p><h3><strong>Better Metrics for Modern Quality Engineering</strong></h3><p>Instead of counting bugs, measure how effectively your engineering process delivers reliable software.</p><p>Here are several metrics that provide significantly more insight.</p><p><strong>1. Defect Escape Rate</strong></p><p>One of the strongest indicators of product quality.</p><p><strong>Formula</strong></p><pre>Escaped Defects<br>--------------- * 100<br>Total Defects</pre><p>If customers continue finding defects after release, something is missing in your quality process.</p><p>A low escape rate indicates effective prevention and validation.</p><p><strong>2. Automation Coverage</strong></p><p>Rather than asking:</p><blockquote>“How many tests do we have?”</blockquote><p>Ask:</p><blockquote>“How much business-critical functionality is automatically protected?”</blockquote><p>Coverage should prioritize:</p><ul><li>Critical user journeys</li><li>Revenue-generating workflows</li><li>High-risk features</li><li>APIs</li><li>Regression suites</li></ul><p>Quality automation is about protecting value — not maximizing script counts.</p><p><strong>3. Flaky Test Rate</strong></p><p>Flaky tests waste engineering time and reduce confidence in CI/CD pipelines.</p><p>Track:</p><ul><li>Percentage of unstable tests</li><li>Failed reruns</li><li>False positives</li><li>Pipeline interruptions</li></ul><p>A stable automation suite is more valuable than a large one.</p><p><strong>4. Mean Time to Detect (MTTD)</strong></p><p>How quickly does the team identify problems?</p><p>Earlier detection means:</p><ul><li>Lower fixing costs</li><li>Less rework</li><li>Faster releases</li></ul><p><strong>5. Mean Time to Recover (MTTR)</strong></p><p>Failures happen.</p><p>Great engineering teams recover quickly.</p><p>Track:</p><ul><li>Production incident duration</li><li>Time required to restore services</li><li>Time until deployment resumes</li></ul><p><strong>6. Deployment Success Rate</strong></p><p>Quality isn’t measured only before release.</p><p>Successful organizations ask:</p><ul><li>How many deployments succeeded?</li><li>How many required rollback?</li><li>How many caused incidents?</li></ul><p>Reliable deployment is a quality metric.</p><p><strong>7. Customer-Reported Defects</strong></p><p>This metric matters because customers experience real business impact.</p><p>Questions worth asking include:</p><ul><li>Which defects affected revenue?</li><li>Which customers were impacted?</li><li>Could they have been prevented?</li></ul><p>Customer trust is one of the most valuable quality indicators.</p><h3>Measuring Business-Focused Quality</h3><p>The purpose of QA isn’t to produce bug reports.</p><p>It’s to reduce business risk.</p><p>Consider these examples.</p><p><strong>Traditional QA Goal</strong></p><p>“Find as many defects as possible.”</p><p><strong>Business Goal</strong></p><p>“Ensure customers can complete purchases without issues.”</p><p>Those are fundamentally different objectives.</p><p>One measures activity.</p><p>The other measures value.</p><p><strong>Ask Better Questions</strong></p><p>Instead of asking:</p><ul><li>How many bugs were reported?</li></ul><p>Ask:</p><ul><li>Did customers experience fewer issues?</li><li>Did releases become more reliable?</li><li>Did automation reduce regression effort?</li><li>Did cycle time improve?</li><li>Did production incidents decrease?</li><li>Did customer satisfaction increase?</li></ul><p>Those answers matter to leadership.</p><p><strong>Shift Left: Prevent Defects Earlier</strong></p><p>One of the biggest transformations in Quality Engineering is shifting quality earlier in the software development lifecycle.</p><p>The cheapest defect is the one that never gets written.</p><p>Quality teams can contribute before coding begins by:</p><ul><li>Reviewing requirements</li><li>Identifying ambiguous acceptance criteria</li><li>Participating in design discussions</li><li>Creating risk assessments</li><li>Defining test scenarios early</li></ul><p>When QA joins conversations instead of waiting for completed features, many defects disappear before development even starts.</p><p>This saves time for everyone.</p><p><strong>Shift Right: Learn from Production</strong></p><p>Quality doesn’t end after deployment.</p><p>Production provides valuable feedback that test environments cannot replicate.</p><p>Modern teams monitor:</p><ul><li>Application logs</li><li>User behavior</li><li>Performance metrics</li><li>Feature adoption</li><li>Production incidents</li><li>Error tracking</li><li>Customer support trends</li></ul><p>Shift-right practices help teams continuously improve quality based on real-world usage.</p><p>Testing validates assumptions.</p><p>Production validates reality.</p><h3>A Better Quality Mindset</h3><p>Imagine two QA teams.</p><p><strong>Team A</strong></p><ul><li>Reports 300 bugs</li><li>Manual regression takes five days</li><li>Frequent production incidents</li><li>High customer complaints</li></ul><p><strong>Team B</strong></p><ul><li>Reports only 40 bugs</li><li>Reviews requirements early</li><li>Has strong automation coverage</li><li>Releases multiple times per week</li><li>Almost no escaped defects</li></ul><p>Which team creates more business value?</p><p>Most engineering leaders would choose Team B.</p><p>Because preventing defects is far more valuable than documenting them.</p><h3>Final Thoughts</h3><p>Quality Engineering has evolved dramatically.</p><p>Success is no longer defined by the number of defects discovered.</p><p>It is defined by how effectively teams build confidence in every release.</p><p>Instead of measuring:</p><ul><li>Bug count</li><li>Test cases executed</li><li>Hours spent testing</li></ul><p>Measure outcomes that matter:</p><ul><li>Defect Escape Rate</li><li>Automation Coverage</li><li>Deployment Success Rate</li><li>Customer-Reported Issues</li><li>MTTR</li><li>Flaky Test Rate</li><li>Business Risk Reduction</li></ul><p>The best QA teams aren’t remembered because they found the most bugs.</p><p>They’re remembered because users never noticed the bugs at all.</p><p><strong>Key Takeaways</strong></p><ul><li>Bug count is an activity metric, not a quality metric.</li><li>Modern QA focuses on preventing defects rather than finding them.</li><li>Business outcomes matter more than testing outputs.</li><li>Shift-left practices reduce defects before coding begins.</li><li>Shift-right practices improve quality through production insights.</li><li>Measure quality using customer impact, reliability, and engineering effectiveness — not the size of the bug backlog.</li></ul><p><strong>What metrics does your organization use to measure QA success?</strong></p><p>Do you still track bug count, or have you adopted more outcome-focused KPIs? Share your experience in the comments — I’d love to hear how your team defines quality.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9027bc97fe37" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Quality Engineering Beyond Testing: How QE Drives Better DORA Metrics]]></title>
            <link>https://medium.com/@dasuner/quality-engineering-beyond-testing-how-qe-drives-better-dora-metrics-a2431932898f?source=rss-641724e93ac8------2</link>
            <guid isPermaLink="false">https://medium.com/p/a2431932898f</guid>
            <category><![CDATA[quality-engineering]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[dora-metrics]]></category>
            <category><![CDATA[delivery-software]]></category>
            <category><![CDATA[testing]]></category>
            <dc:creator><![CDATA[Dasun Eranthika]]></dc:creator>
            <pubDate>Sat, 01 Aug 2026 17:08:12 GMT</pubDate>
            <atom:updated>2026-08-01T17:08:12.817Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VbTDoR3X4TcZA0LYhhh81A.png" /><figcaption>Quality Engineering drives better DORA</figcaption></figure><p>Quality Engineering isn’t just about finding bugs — it’s about enabling faster, safer, and more reliable software delivery.</p><p>For years, QA teams have measured success through metrics such as:</p><ul><li>Number of test cases executed</li><li>Number of defects found</li><li>Test execution pass rate</li><li>Automation coverage</li><li>Regression completion</li></ul><p>While these metrics help evaluate testing activities, they don’t answer the question that matters most to engineering leadership:</p><blockquote>“How does Quality Engineering contribute to delivering better software faster?”</blockquote><p>This is where DORA metrics provide a game-changing perspective.</p><p>Instead of measuring testing in isolation, DORA measures how effectively the entire engineering organization delivers software. Modern Quality Engineering teams have a significant influence on each of these metrics.</p><p>In this article, we’ll explore how QE can become a strategic driver of software delivery performance through DORA.</p><h3><strong>What Are DORA Metrics?</strong></h3><p>DORA (DevOps Research and Assessment) introduced four key metrics that predict software delivery performance.</p><p>These metrics focus on both <strong>speed </strong>and <strong>stability</strong>, ensuring organizations don’t sacrifice quality for faster releases.</p><p>The four DORA metrics are:</p><pre>| Metric                      | Measures                                              |<br>| --------------------------- | ----------------------------------------------------- |<br>| Deployment Frequency        | How often software is successfully deployed           |<br>| Lead Time for Changes       | Time from code commit to production                   |<br>| Change Failure Rate         | Percentage of deployments causing production failures |<br>| Mean Time to Restore (MTTR) | Time required to recover from production incidents    |</pre><p>Unlike traditional QA metrics, DORA reflects business outcomes rather than testing outputs.</p><h3><strong>Why Quality Engineering Should Care</strong></h3><p>Many organizations still view QA as the final checkpoint before deployment.</p><p>Modern Quality Engineering is very different.</p><p>Today’s QE teams:</p><ul><li>Build automation frameworks</li><li>Design quality gates</li><li>Support CI/CD pipelines</li><li>Shift testing left</li><li>Monitor production quality</li><li>Enable continuous delivery</li><li>Collaborate across engineering teams</li></ul><p>When QE matures, it directly improves every DORA metric.</p><h3><strong>1. Increasing Deployment Frequency</strong></h3><p>Deployment Frequency measures how often software reaches production successfully.</p><p>Organizations aiming for continuous delivery cannot depend on lengthy manual regression cycles.</p><p><strong>How QE Helps</strong></p><p>A mature QE organization enables frequent deployments by:</p><ul><li>Automating regression suites</li><li>Running smoke tests in CI pipelines</li><li>Building stable Playwright or Selenium frameworks</li><li>Implementing API automation</li><li>Reducing flaky tests</li><li>Executing tests in parallel</li><li>Applying risk-based testing</li></ul><p><strong>Example</strong></p><p>Before automation:</p><ul><li>Manual regression: 6 hours</li><li>Weekly releases</li></ul><p>After automation:</p><ul><li>Regression: 45 minutes</li><li>Daily deployments</li></ul><p>The result isn’t simply “faster testing.”</p><p>It’s <strong>more frequent software delivery.</strong></p><h3><strong>2. Reducing Lead Time for Changes</strong></h3><p>Lead Time measures the duration between a developer committing code and customers receiving that change.</p><p>Many organizations unintentionally increase lead time because testing becomes the bottleneck.</p><p>Common causes include:</p><ul><li>Waiting for environments</li><li>Slow manual regression</li><li>Test data preparation</li><li>Sequential testing</li><li>Approval delays</li></ul><p><strong>How QE Helps</strong></p><p>Quality Engineering reduces lead time by introducing:</p><ul><li>Test automation</li><li>Environment automation</li><li>Test data management</li><li>Parallel execution</li><li>API-first testing</li><li>Service virtualization</li><li>Intelligent regression selection</li></ul><p>The objective isn’t simply executing tests faster.</p><p>It’s reducing the total time required to deliver customer value.</p><h3><strong>3. Lowering Change Failure Rate</strong></h3><p>Perhaps the most important DORA metric for Quality Engineering.</p><p>Change Failure Rate represents the percentage of deployments that lead to:</p><ul><li>Production incidents</li><li>Rollbacks</li><li>Emergency fixes</li><li>Service degradation</li><li>Customer-impacting defects</li></ul><p>A low deployment frequency means little if every release introduces production problems.</p><p><strong>How QE Helps</strong></p><p>Modern QE teams reduce Change Failure Rate through:</p><p><strong>Shift Left Testing</strong></p><p>Finding issues during development rather than production.</p><p><strong>Better Test Design</strong></p><p>Testing critical business journeys instead of maximizing test case counts.</p><p><strong>API Testing</strong></p><p>Detecting failures before UI testing begins.</p><p><strong>Performance Testing</strong></p><p>Preventing scalability issues before release.</p><p><strong>Security Testing</strong></p><p>Reducing production vulnerabilities.</p><p><strong>Exploratory Testing</strong></p><p>Identifying edge cases automation may overlook.</p><p><strong>Quality Gates</strong></p><p>Preventing risky deployments when quality thresholds are not met.</p><p>The outcome is fewer production failures and increased customer confidence.</p><h3><strong>4. Improving Mean Time to Restore (MTTR)</strong></h3><p>Failures will occur.</p><p>High-performing organizations recover quickly.</p><p>MTTR measures how long it takes to restore normal service after a production issue.</p><p><strong>How QE Helps</strong></p><p>Quality Engineering accelerates recovery by:</p><ul><li>Quickly reproducing production defects</li><li>Providing detailed defect evidence</li><li>Verifying hotfixes rapidly</li><li>Running automated regression after fixes</li><li>Maintaining reliable test environments</li><li>Supporting release validation</li></ul><p>Automation significantly shortens the validation cycle, enabling engineering teams to deploy fixes with confidence.</p><h3><strong>Moving Beyond Traditional QA Metrics</strong></h3><p>Traditional QA metrics remain valuable but should not be the primary indicators of engineering success.</p><p>Instead of asking:</p><ul><li>How many defects did QA find?</li><li>How many test cases were executed?</li><li>What is our automation percentage?</li></ul><p>Engineering leaders should ask:</p><ul><li>Did QE enable faster deployments?</li><li>Did automation reduce lead time?</li><li>Did testing lower production failures?</li><li>Did QE accelerate recovery after incidents?</li></ul><p>These questions connect quality directly to business outcomes.</p><h3><strong>Mapping QE Activities to DORA Metrics</strong></h3><pre>| DORA Metric          | QE Contribution                                                    |<br>| -------------------- | ------------------------------------------------------------------ |<br>| Deployment Frequency | Automated regression, CI/CD validation, smoke testing              |<br>| Lead Time            | Parallel execution, API testing, environment automation            |<br>| Change Failure Rate  | Risk-based testing, quality gates, performance testing             |<br>| MTTR                 | Fast defect reproduction, automated validation, production support |</pre><p>Every improvement in Quality Engineering should ultimately strengthen one or more DORA metrics.</p><h3><strong>Building a DORA-Driven QE Strategy</strong></h3><p>Organizations can align Quality Engineering with DORA by focusing on a few key initiatives:</p><p><strong>Automate Critical User Journeys</strong></p><p>Prioritize business-critical scenarios over chasing 100% automation coverage.</p><p><strong>Shift Testing Left</strong></p><p>Integrate quality activities into development rather than waiting for feature completion.</p><p><strong>Build Reliable CI/CD Pipelines</strong></p><p>Ensure automated tests provide fast and trustworthy feedback.</p><p><strong>Measure Pipeline Health</strong></p><p>Track flaky tests, execution duration, and pipeline stability.</p><p><strong>Invest in Observability</strong></p><p>Use logs, monitoring, and production telemetry to improve issue detection and recovery.</p><p><strong>Continuously Improve</strong></p><p>Treat every incident as an opportunity to strengthen automation, improve test coverage, and refine engineering practices.</p><h3><strong>The Evolution of Quality Engineering</strong></h3><p>Quality Engineering has evolved beyond validating software before release.</p><p>Today’s QE teams influence:</p><ul><li>Delivery speed</li><li>Software reliability</li><li>Engineering productivity</li><li>Customer experience</li><li>Business agility</li></ul><p>The organizations achieving elite software delivery performance don’t ask QA to test faster.</p><p>They empower Quality Engineering to build systems, automation, and processes that enable engineering teams to release software quickly and confidently.</p><p>When Quality Engineering aligns with DORA metrics, quality becomes a measurable business advantage rather than a checkpoint at the end of development.</p><h3><strong>Final Thoughts</strong></h3><p>DORA metrics remind us that quality is not the responsibility of a single team — it is the outcome of an effective engineering system.</p><p>Quality Engineering plays a pivotal role in shaping that system. By investing in automation, intelligent testing strategies, robust CI/CD pipelines, and fast feedback loops, QE teams can directly improve deployment frequency, shorten lead time, reduce change failure rates, and accelerate recovery when issues occur.</p><p>The next time someone asks, “What value does Quality Engineering bring?”, the answer shouldn’t be a count of executed test cases or defects logged. It should be measurable improvements in the organization’s ability to deliver software <strong>faster, safer, and with greater confidence</strong>.</p><p>Because in modern software development, <strong>great Quality Engineering doesn’t slow delivery — it accelerates it.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a2431932898f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Stop Asking AI Bad Questions: The Co-Star Prompting Framework That Produces Better Results]]></title>
            <link>https://medium.com/@dasuner/stop-asking-ai-bad-questions-the-co-star-prompting-framework-that-produces-better-results-f0ef4631f5da?source=rss-641724e93ac8------2</link>
            <guid isPermaLink="false">https://medium.com/p/f0ef4631f5da</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[prompt-engineering]]></category>
            <category><![CDATA[prompt-engineering-guide]]></category>
            <category><![CDATA[generative-ai]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Dasun Eranthika]]></dc:creator>
            <pubDate>Tue, 28 Jul 2026 06:41:46 GMT</pubDate>
            <atom:updated>2026-07-28T06:41:46.019Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9EBEZ5qRZ9J5Fr-mFq-myg.png" /><figcaption>Co-Star Framework Overview</figcaption></figure><p>Artificial Intelligence has become a daily companion for software engineers, QA professionals, business analysts, product managers, and content creators. Yet many people walk away disappointed with the responses they receive.</p><p>You’ve probably heard someone say:</p><blockquote>“ChatGPT isn’t very accurate.”</blockquote><p>Most of the time, the issue isn’t the AI.</p><p>It’s the prompt.</p><p>Just as a search engine can’t read your mind, AI can only work with the information you provide. A vague prompt usually leads to a vague answer.</p><p>One of the simplest ways to consistently improve your AI conversations is by using the <strong>Co-Star Prompting Framework</strong>.</p><p>In this article, we’ll explore what Co-Star is, why it works, and how you can apply it in your everyday work — especially if you’re a QA Engineer, Software Engineer, or Technical Leader.</p><p><strong>What is the Co-Star Framework?</strong></p><p>Co-Star is a structured prompting technique that helps you communicate with AI more effectively.</p><p>Instead of writing whatever comes to mind, you provide six key pieces of information that guide the model toward the outcome you actually want.</p><p>Co-Star stands for:</p><ul><li>C — Context</li><li>O — Objective</li><li>S — Style</li><li>T — Tone</li><li>A — Audience</li><li>R — Response Format</li></ul><p>Think of it as writing a clear project requirement instead of a one-line request.</p><p>The more specific your instructions, the more useful the AI becomes.</p><h3><strong>C — Context</strong></h3><p>Context tells AI what’s happening.</p><p>Imagine someone walked into your office and asked:</p><blockquote>“Can you help me?”</blockquote><p>You’d immediately ask:</p><blockquote>”Help with what?”</blockquote><p>AI works the same way.</p><p>Instead of writing:</p><blockquote>Explain Playwright.</blockquote><p>Provide context:</p><blockquote>I’m a QA Lead building an enterprise Playwright automation framework using TypeScript for a banking application. The framework follows the Page Object Model and runs in GitHub Actions.</blockquote><p>Now the AI understands your environment before answering.</p><p>Good context often includes:</p><ul><li>Your role</li><li>Your industry</li><li>Your project</li><li>Technologies involved</li><li>Constraints</li><li>Experience level</li></ul><p>The more relevant context you provide, the less the AI has to guess.</p><h3><strong>O — Objective</strong></h3><p>Context explains the situation.</p><p>Objective explains the destination.</p><p>Many prompts fail because they never clearly state what success looks like.</p><p>Instead of saying:</p><blockquote>Help me with Playwright.</blockquote><p>Say exactly what you need.</p><p>Examples:</p><ul><li>Generate login test cases.</li><li>Review this TypeScript code.</li><li>Create a Test Strategy.</li><li>Optimize this SQL query.</li><li>Explain this error.</li><li>Prepare interview questions.</li></ul><p>A single clear objective almost always produces a stronger answer than multiple unrelated requests.</p><h3><strong>S — Style</strong></h3><p>Style defines *how* the information should be presented.</p><p>For example, you might want:</p><ul><li>Technical</li><li>Beginner-friendly</li><li>Professional</li><li>Conversational</li><li>Step-by-step</li><li>Bullet points</li><li>Storytelling</li><li>Academic</li></ul><p>These instructions dramatically change how the AI structures its answer.</p><h3><strong>T — Tone</strong></h3><p>Tone defines the personality of the response.</p><p>Examples include:</p><ul><li>Friendly</li><li>Formal</li><li>Professional</li><li>Confident</li><li>Persuasive</li><li>Humorous</li><li>Motivational</li></ul><p>Consider these two requests:</p><blockquote>Explain API testing in a humorous tone.</blockquote><p>versus</p><blockquote>Explain API testing in a formal enterprise tone.</blockquote><p>The technical information remains similar, but the delivery changes completely.</p><h3><strong>A — Audience</strong></h3><p>Who will read the output?</p><p>AI can simplify or increase technical depth depending on the audience.</p><p>Examples:</p><ul><li>Beginners</li><li>University students</li><li>QA Engineers</li><li>Developers</li><li>Project Managers</li><li>Executives</li><li>Customers</li></ul><p>For example:</p><p>Explaining Playwright to a junior tester looks very different from explaining it to a CTO.</p><p>Always identify your audience.</p><h3><strong>R — Response Format</strong></h3><p>Never leave the format to chance.</p><p>Tell AI exactly how you’d like the information returned.</p><p>Examples:</p><ul><li>Markdown</li><li>Table</li><li>JSON</li><li>Checklist</li><li>Email</li><li>Blog article</li><li>PowerPoint outline</li><li>User stories</li><li>Test cases</li><li>Bug reports</li></ul><p>This is one of the most overlooked parts of prompting.</p><p>A simple instruction like:</p><blockquote>Return the answer as a table.</blockquote><p>can save you several minutes of manual formatting.</p><h3><strong>Before and After</strong></h3><p>Let’s compare two prompts.</p><h4><strong>Weak Prompt</strong></h4><blockquote>Write Playwright test cases.</blockquote><p>The AI has to guess:</p><ul><li>Which application?</li><li>Which feature?</li><li>Which audience?</li><li>Which format?</li><li>Which programming language?</li></ul><p>Now compare that with this.</p><h4><strong>Co-Star Prompt</strong></h4><p><strong>Context</strong></p><p>I’m building an enterprise Playwright automation framework using TypeScript for an e-commerce website.</p><p><strong>Objective</strong></p><p>Generate comprehensive login test cases.</p><p><strong>Style</strong></p><p>Technical.</p><p><strong>Tone</strong></p><p>Professional.</p><p><strong>Audience</strong></p><p>Senior QA Engineers.</p><p><strong>Response</strong></p><p>Return a Markdown table with Test ID, Preconditions, Test Steps, Expected Results, Priority, and Automation Feasibility.</p><p>Notice how every element removes ambiguity.</p><p>Instead of guessing, AI can focus on producing quality output.</p><h3><strong>Applying Co-Star in Software Testing</strong></h3><p>Here are a few practical examples.</p><p><strong>Generate Test Cases</strong></p><p>Provide the application’s purpose, module details, expected output, and request a structured table.</p><p><strong>Review Automation Code</strong></p><p>Mention the framework, programming language, coding standards, and ask for performance or maintainability improvements.</p><p><strong>Create Test Strategies</strong></p><p>Describe the product, architecture, release process, team size, and testing objectives before asking AI to draft a strategy.</p><p><strong>Bug Analysis</strong></p><p>Paste the error message, logs, environment, and reproduction steps before requesting root cause analysis.</p><p><strong>Interview Preparation</strong></p><p>Mention your experience level, target role, technology stack, and preferred interview difficulty.</p><p>The richer the context, the more valuable the answer becomes.</p><h3><strong>Common Prompting Mistakes</strong></h3><p>Avoid these common pitfalls:</p><ul><li>Being too vague</li><li>Asking multiple unrelated questions in one prompt</li><li>Forgetting to specify the audience</li><li>Ignoring the desired output format</li><li>Expecting AI to understand unstated assumptions</li></ul><p>Think of AI as an intelligent colleague — not someone who can read your mind.</p><h3><strong>Final Thoughts</strong></h3><p>Prompt engineering isn’t about learning complicated tricks.</p><p>It’s about communicating clearly.</p><p>The Co-Star framework provides a simple structure that anyone can remember:</p><ul><li>Context</li><li>Objective</li><li>Style</li><li>Tone</li><li>Audience</li><li>Response</li></ul><p>Whether you’re generating test cases, reviewing code, writing documentation, preparing presentations, or learning a new technology, this framework can significantly improve the quality and consistency of AI-generated responses.</p><p>The next time you’re about to ask AI a question, pause for a moment and ask yourself:</p><p><strong>Have I provided enough Context?</strong></p><p>That one question alone can transform an average prompt into an exceptional one.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f0ef4631f5da" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>