So I see a great future for testing and QA.
I was writing a React application at work based on React Flow[3] and I was mucking about with state management libraries (because that's what the React Flow manual recommends). Maybe it was a skill issue on my part, but I had a hard time with the Zustand library. Then I read up on reducers in React and everything was perfectly clear. A reducer is just a pure function, it takes an existing state and an action and returns the new state. That's simple, I can wrap my brain around that. Plus, I know how to test a pure function, there is nothing to mock, stub or wrap. States and actions are just plain JavaScript objects, there is no history, no side effects, no executable code.
And this is where property-based testing comes in: if history does not matter it means I can randomly generate any valid state and any valid action, then apply the reducer function and verify that the resulting state has all the required properties. Only a formal proof would give me more certainty.
I fully understand people who want to use LLMs to write tests for them. Writing test cases is boring and tedious. There are many edge cases a human might miss. But relying on a guessing machine and praying it does not write nonsense is just plain irresponsible for someone who calls himself an engineer. People rely on the quality of our software for their work and personal safety. Property-based testing frees us from the tedium and will generate many more tests and we could write by hand, but it does so in a predictable manner that can be fully reasoned about.
[1] https://en.wikipedia.org/wiki/Software_testing#Property_test... [2] https://fsharpforfunandprofit.com/series/property-based-test... [3] https://reactflow.dev/
One nuance though: property-based testing shines when the domain is already well-modeled. A lot of real QA pain comes where purity breaks down—distributed systems, async flows, partial failures, UI↔backend boundaries. At that point, the hard part isn’t generating tests, it’s reconstructing context.
On LLMs: I don’t think they should be trusted as correctness oracles either. Their real value isn’t guessing answers, but helping surface assumptions, generate counter-examples, and expose gaps in our mental model.
So the future of QA isn’t humans vs LLMs. It’s better system design + explicit invariants + tools that help engineers doubt their own certainty faster. Most serious bugs come from being sure we understood the system when we didn’t.
Today’s situation of developers shitting out software with low to none sense of quality would reach thanks to llms some critical tipping point some day.
And LLMs are not a good fit for most of the QA job. Because it’s mainly about actions (testing) rather than texts anf conversations.
Beyond that is dependent types
AI will kill flaky UI scripts, and “click-and-verify” roles. That’s overdue. What won’t disappear is the need to understand how systems actually behave under stress, failure, and ambiguity.
The future of QA is upstream: • defining invariants, not writing scenarios • modeling state and failure modes, not chasing bugs • debugging distributed, async, messy real-world systems
AI will generate tests faster than humans ever can. But it won’t know what matters or what assumption is wrong. That judgment still belongs to engineers.
If you’re in QA and want to stay relevant: stop being a test executor. Become the person who explains why the system broke, not just how to reproduce it.
I've heard this theory a lot - and it's been around a while now. But only seen them made redundant, or forced to become normal software devs.
Do you know of any companies that have converted a large chunk of legacy QA teams to this proposed model?
It may be worth trying to ignore the feeling of "AI taking over the field". There's so much noise around this stuff as, personally, it's very difficult to differentiate hype and utility at the moment.
See Microsoft and Google: That's why they have users for.
Learn AI.