u/Background-Donkey531

One thing I keep noticing in projects is how quickly QA starts drifting from the actual codebase as things scale.

Test cases get outdated, reports don’t always reflect what actually ran, and a lot of effort goes into maintaining tools and workflows instead of focusing on testing itself.

Recently I explored a setup where test cases live in Markdown, stay version-controlled in Git, execute through CI pipelines, and even use AI to help generate/update tests. What stood out was how much more connected everything felt compared to the usual “multiple tools stitched together” approach.

The idea of having execution results tied directly to real runs instead of manually updated statuses felt pretty interesting too.

We can do small demo while testing it out:
,https://calendly.com/qualityfolio2026/30min

Curious how others here are handling this — especially teams trying to keep QA aligned with rapid development changes.

Most QA workflows today still revolve around maintaining test cases, updating statuses, and generating reports. It works, but it often leaves a gap between what’s documented and what actually happened during execution.

There’s a growing shift toward a more evidence-driven approach — where test cases live closer to the code (in Markdown, versioned in Git), execution is tied directly to CI pipelines, and results are captured from real runs instead of manual updates.

On top of that, AI is starting to take over repetitive tasks like generating and updating test cases, making it easier to keep everything aligned as systems evolve. Instead of constantly maintaining QA artifacts, the focus moves toward validating real outcomes.

The result is a workflow that feels more connected, more traceable, and easier to trust — especially in fast-moving projects.

Curious — is QA ready to move from managing test cases to managing actual test evidence?

I have a lot of contacts, but when I really think about it, there are only a few people I can call and talk to comfortably without overthinking.

Quality vs quantity hits differently here.

Over time, I’ve picked up a bunch of hobbies with full motivation… but most of them faded after a while. It’s easy to start, but consistency is the hard part.

In most teams I’ve worked with, QA looks “done” on paper — test cases passed, reports updated — but there’s always that moment before release where you double-check things.

Are the test cases up to date?
Did anything change that wasn’t covered?
Do the reports actually reflect what ran?

A lot of the time, the issue isn’t effort — it’s how everything is structured. Test cases, execution, and results live in different places, so keeping them in sync takes constant work.

Lately I’ve been seeing setups where test cases live in Markdown (version-controlled in Git), execution is tied to pipelines, and results come directly from real runs. Add AI helping generate and update test cases, and it starts to reduce some of that manual upkeep.

It feels like a shift from “maintaining QA artifacts” to actually understanding what happened during testing.

Curious — do you fully trust your QA status today, or do you still verify things manually before every release?

Think about a typical QA setup — test cases in one tool, execution in another, reports somewhere else. It works, but it also means constantly jumping between places just to understand what’s actually going on.

Over time, things drift. Test cases don’t match the latest code, reports don’t fully reflect real runs, and a lot of effort goes into keeping everything aligned.

Now there’s a shift toward simpler, more connected workflows — test cases in Markdown, versioned in Git, executed through pipelines, with results coming directly from real execution. Add AI into the mix to help generate and update test cases, and suddenly a lot of the repetitive work starts to reduce.

It’s not about adding more tools, but about reducing the gaps between them.

Curious — is QA complexity coming from the problems we’re solving, or the way we’re structuring it?

A lot of QA workflows still rely on separate tools for test cases, execution, and reporting. It works, but over time things tend to drift — test cases get outdated, reports don’t always reflect actual runs, and maintaining everything takes effort.

There’s a shift toward more connected setups — keeping test cases in Markdown, version-controlled in Git, and executing them through CI pipelines so results come directly from real runs. This improves traceability and keeps QA closer to the development flow.

AI is also starting to play a role — helping generate test cases, update them as requirements change, and reduce some of the repetitive work involved in maintaining QA artifacts.

The combination of version control, automation, and AI feels like it could make QA more aligned with modern development — less manual upkeep, more clarity on what’s actually happening.

Curious — how do you see test management evolving with AI and automation in your team?

A lot of QA workflows still rely on separate tools for test cases, execution, and reporting. It works, but over time things tend to drift — test cases get outdated, reports don’t always reflect actual runs, and maintaining everything takes effort.

There’s a shift happening toward more connected setups — keeping test cases in Markdown, version-controlled in Git, and executing them through CI pipelines so results come directly from real runs. This improves traceability and keeps QA closer to the development flow.

AI is also starting to play a role — helping generate test cases, update them as requirements change, and reduce some of the repetitive work involved in maintaining QA artifacts.

The combination of version control, automation, and AI seems to be moving QA toward something more aligned with modern development practices — less manual upkeep, more visibility into what’s actually happening.

👉 https://qualityfolio.dev/

Curious — how do you see test management evolving with AI and automation in your team?

Qualityfolio, that tries to bring QA directly into the development workflow. Instead of external tools, it uses Markdown in the repo for tests, CI for execution, and generates dashboards from actual results.

If you have a few moments, I would really appreciate your thoughts.
https://qualityfolio.dev/

GitHub: https://github.com/opsfolio/Qualityfolio

We are looking for honest feedback from fellow QA professionals, any input from you would be hugely helpful. Thanks so much! 🙂

Between tools, updates, and keeping everything aligned, it sometimes feels like QA is more about management than testing.

Saw an approach where things are more connected version-controlled test cases, automated execution, and AI helping with updates. Less jumping between tools, more clarity on what actually ran.

👉 https://qualityfolio.dev/

Does it feel the same on your side?

Most QA setups end up being split across tools test cases, execution, and reports all living in different places. Over time, things drift, and it takes effort just to keep everything aligned.

An approach I’ve been exploring is keeping test cases in Markdown within Git, so they’re version-controlled like code. Changes go through PRs, reviews become part of the normal dev flow, and traceability improves without extra effort.

On top of that, AI can help generate and update test cases, reducing the need for constant manual maintenance. Instead of rewriting things repeatedly, the focus shifts more towards validating and refining.

Execution through pipelines ties everything back to actual runs, so results reflect what really happened rather than what was manually updated.

Curious does something like this actually simplify QA in the long run, or just move the complexity around?

Managing QA across multiple tools can get messy test cases go out of sync, reports don’t always reflect reality, and a lot of time goes into maintaining things rather than actually testing.

This approach keeps everything more connected test cases in Markdown, versioned in Git, executed through pipelines, and results based on what actually ran. With AI helping generate and update test cases, it also reduces a lot of repetitive effort.

Overall, it feels like a simpler way to keep QA aligned with the code and improve visibility without juggling multiple systems.

👉 https://qualityfolio.dev/

Would be great if you could check it out and share your thoughts curious to know how it feels from your side