,

The Quality Alphabet: when moving from QA to QE, what about QB, QC and QD?

The Quality Alphabet: QA, QB, QC, QD and QE

Hello and welcome to a blog that kind of started as a wind-up. Over the years, whenever people spoke about their transition from QA to QE, I would usually ask: “But what about QB, QC and QD?”

Snag is, the more times I explain this, the more I embellish it, to the point where it has grown legs and now, with the advent of AI, it also seems to be starting to sprout wings into a concept that I will now refer to as The Quality Alphabet.

As AI is being used more and more, these letters are starting to look less like a joke and more like areas we actually need to consider.

So rather than going from QA to QE, let’s delve into the world of QB, QC and QD:

QA is Quality Assurance

I’m sure we’re all OK and familiar with this one.

Quality Assurance is about providing confidence in the quality of the product, and testing contributes to that by giving us information about the quality of what we are building.

One of the mantras of testing is that the best time to start testing is as early as possible. We don’t mean 8:30 in the morning but as early in the project as possible.

Approaches such as Test-Driven Development and Behaviour-Driven Development embrace this, build quality in, and make quality everyone’s responsibility.

It does raise the question: “How early is early?” And we may need to look at what happens before there is even a product to test, which takes me to QB.

QB is Quality Business

Decades ago, I used to ask the question: “How well does the business know the business?”

The main reason I would ask this is because a couple of times I have seen a “basic fundamental misunderstanding of the business” which killed those projects as they didn’t really understand what the organisation wanted in the first place.

Before we start building anything, does the business actually know what it wants? Does it understand its own rules? Does everybody agree how things are supposed to work?

A lot of approaches such as TDD and BDD are heavily dependent on the business being the foundation block that everything else is built upon.

As systems and applications become increasingly complex, non-deterministic and probabilistic, defining the business objectives and requirements becomes a massive challenge. Plus, AI systems can learn, evolve, adapt and respond rapidly to the real world they operate within, which makes defining their requirements even more of a challenge.

AI gives us the ability to create things considerably faster, including the ability to create the wrong thing considerably faster.

Do you retrofit the AI system requirements to fit in with the way the system works now, or should you define the requirements with that flexibility and those ranges already built in?

QB gives us an opportunity to really consider and lay down exactly how these systems should behave.

This takes me to QC.

QC is Quality Control

I know that Quality Control isn’t a new term, but when talking about AI this is the point I start to focus on the word control.

As AI becomes increasingly capable, we seem to be handing over more and more of the workload for it to handle, and therefore more of the control.

We appear to be increasingly creating AI systems and agents that make their own decisions and take actions themselves.

But handing some control over to AI doesn’t mean that we should hand over responsibility as well.

We still need to decide what the AI is allowed to do, what it isn’t allowed to do, when a human needs to become involved and what happens when something goes wrong.

We also need to think about how we get back to where we were before it went wrong.

For many years, systems were created with controls, backup plans, rollback procedures and people who approved and made the main decisions. When AI is building new functionality to go live, does it include these things too?

The more control we give to AI, the more important it becomes that we understand exactly what control we have kept for ourselves.

That, to me, is where Quality Control starts to mean something slightly different. It’s not just about controlling the quality. It’s also about making sure we haven’t given away the control.

QD is Quality Development

Developing code is, in many ways, a fairly logical and structured activity, which is probably one of the reasons why this is an area where AI is used more and more.

We are already seeing AI tools capable of producing surprisingly large amounts of working software from a relatively small number of prompts.

The snag is that generating something is not quite the same thing as developing and maintaining it yourself.

Developers have ownership of their own code. They have a good working knowledge of it, the changes they have made, areas of greater risk and how the requirements have been implemented.

They are also aware of the conscious and unconscious requirements and remember the issues, teething troubles and challenges from the past. They can also turn around and ask: why?

AI has no emotional attachment to the code. Rerun the prompt you ran yesterday to create the system again today and you may get a completely different system.

Also, I have heard of people using AI to update systems with new functionality only to discover that it changed everything, including areas that were working perfectly well before.

This starts to change where some of the hard work in development happens.

Traditionally, we might have a Definition of Ready before something starts development and a Definition of Done before it is considered complete.

But with AI, I think those two potentially start to get much closer together, and it becomes: Our Definition of Done increasingly needs to be AI’s Definition of Ready.

If AI can turn an idea into working software very quickly, we need to make sure we have done enough thinking before we ask it to do so.

Do we understand the business rules?

Have we considered everything before we build?

Do we know what good and what bad looks like?

Perhaps some of the time AI saves us in writing the code needs to be spent earlier, making sure that we know what we actually want it to write.

That’s where I think Quality Development fits.

QE is Quality Engineering

Which finally brings us to Quality Engineering.

I have seen places where the change from QA to QE appears to involve giving testers more development and automation skills.

There is nothing wrong with that. Testers are generally keen to learn new skills, although not everyone necessarily wants to become a developer.

But I think QE is bigger than adding developer skills and automation skills to a tester.

To genuinely engineer quality, quality needs to be everyone’s responsibility.

The business needs to understand what it wants.

We need appropriate controls around how things are created and used.

Development needs to start from something that has been properly thought through.

Testing and assurance need to give us confidence that what we have created is actually what we intended.

Put all of that together and perhaps we are getting closer to genuinely engineering quality.

Maybe we shouldn’t skip these letters

This is why something I always thought thrown into a conversation as a joke or a wind-up is now becoming an idea I take rather more seriously. AI has made me think that QB, QC and QD are not simply missing letters. They are areas we genuinely need to start considering.

I know none of this is particularly revolutionary. Quality Assurance isn’t new. Quality Control certainly isn’t new. Suggesting that the business should understand what it wants before somebody develops it isn’t exactly groundbreaking either.

I’m not suggesting that these should suddenly become formal stages in a development lifecycle. I’m using them more as different ways of asking whether we have thought about quality from the right angles.

What I find interesting is putting them together.

QB asks whether we understand what we want.
QC asks whether we understand what control we’re handing over.
QD asks whether we’re ready to build it.
QA asks whether we have confidence in what we’ve produced.
QE brings all of that together.

So perhaps instead of moving straight from QA to QE we need to move from QA to QB to QC to QD to QE?

It started as a joke or a wind-up.

I’m beginning to think it may soon start to fly.

John Kurowski has worked in software development, testing and quality for many years. He now runs Kurowski Consulting, delivering software testing and AI training, and occasionally writing about the things in our industry that make him stop and think.