Cyber attacks in November 2026: what they teach businesses about AI agents and secure software
Optimizely, Maileva, AI agents: what the cyber attacks of November 2026 teach about third-party scripts, suppliers and AI in production.
Published on Updated on 8 min read
Sébastien Nobour
Founder of DEVEDANOS
Has your provider promised you a high-quality application, or has your team told you its code is clean? You don’t read code yourself, so what does “quality” actually cover, and how can you check it?
Quality code is code that is easy to change.
Code is what developers write to make your application work. The definition is about what it costs to keep that application evolving.
An application built on its users’ feedback changes all the time. Every piece of feedback calls for a change. If every change is expensive, or breaks something else, the loop slows down, and a growing share of the budget goes on repairs instead of on improving the application.
Martin Fowler, one of the signatories of the Agile Manifesto and Chief Scientist at Thoughtworks, distinguishes two kinds of quality. External quality is what users see: the interface, the errors. Internal quality is the quality of the code’s architecture, which nobody sees when using the application. In “Is High Quality Software Worth the Cost?”, he writes that high internal quality reduces the cost of future features. He adds that developers find that poor-quality code slows them down significantly after just a few weeks.
To keep the cost of change low, a team needs to know as early as possible that a change has broken something. That is what Continuous Delivery is for: the approach its pioneers, Jez Humble and Dave Farley, described in the book Continuous Delivery. Every small change goes through a deployment pipeline, often called a CI/CD pipeline. The pipeline checks the change automatically and keeps the application ready to go into production at any time. So a mistake is caught before it reaches your users, while it is still easy to fix.
DORA, Google Cloud’s research programme on how software is built and released to production, links Continuous Delivery to code quality. Its 2017 “State of DevOps” report finds that Continuous Delivery depends above all on a team’s ability to change the design of its application without waiting for other teams: so it requires code that is easy to change. The same report compares the highest-performing organisations in software delivery with the lowest-performing. The highest performers spend 44% more time on new features, and 21% less time on unplanned work and rework. For your budget, that means fewer hours spent on repairs. Ask your team what share of its time is allocated to developing new features.
Before changing code, a developer has to find the place where the change belongs. Then they read the code at that place, and work out what it does. Every step where you get stuck holds you up before you can move on to the next. Code only becomes easy to change when those earlier steps go smoothly.
In Modern Software Engineering, Farley writes that code is, first of all, a way of communicating with other people.
In Modern Software Engineering, Farley describes the properties that make code easy to change. A developer checks them by reading the code:
You don’t have to check them yourself: they show from the outside, in two measures described below.
Four design practices come up again and again when people talk about code quality. Each one separates two things that are better kept apart:
Behaviour-driven development (BDD), formulated by Dan North, also turns tests into a design guide. Each feature starts from examples of what the application must do, and those examples become automated acceptance tests (ATDD). These tests in turn guide finer-grained tests, each written just before a small piece of code (TDD, described by Kent Beck, the creator of Extreme Programming).
You choose a tool because you know exactly why you need it. Here, the need is code that is easy to change: all these practices exist to keep code easy to find, read and understand, and therefore easy to change. Applied without that reason in mind, they lead teams astray, as we explain further on.
To tell whether code is good quality without reading it, look at two measures together: throughput and stability.
DORA first tracked them through four metrics, which its researchers presented in the book Accelerate (2018). Two measure throughput: the time it takes for a change to reach production, and how often releases happen. Two measure stability: the share of changes that cause problems once in production, and the time it takes to restore service after an outage.
The two measures pull against each other. A team can gain throughput by cutting corners, and stability drops. It can also lock everything down so that nothing breaks, and throughput collapses. Yet DORA’s research shows that the highest-performing teams do better on all four metrics at once. That is where code quality shows: holding both at the same time requires code that is easy to change. As of 2026, these results remain correlations observed in surveys, which do not on their own prove that the code is the cause.
Ask your team or your provider for these four figures, and look at them together. Frequent releases followed by frequent outages, or stability achieved by hardly ever releasing: both point to code that resists change.
Farley defines software engineering as the application of an empirical, scientific approach to finding efficient, economic solutions to practical problems in software.
He sums up the engineer’s method: form a hypothesis, work out how to confirm or refute it, run the experiment, observe the result, start again, and do all of this by the shortest route.
He credits software craftsmanship with bringing skill, creativity and learning back to the fore, but writes that it is not enough. In his video “Software Craftsmanship vs Software Engineering”, he explains that craftsmanship judges code on subjective criteria, and he gives the engineer’s criterion: quality code can be changed easily and safely.
Without that criterion, DDD, hexagonal architecture or test-driven development become ends in themselves. Design turns into a contest for the most beautiful code: the business gains nothing from it, and only the developers’ egos do.
The standard we apply to every project rests on two things. Real agility, the kind that comes from an adaptive approach: adapting the product to its users’ needs and keeping them at the centre. And Continuous Delivery (Dave Farley, Jez Humble): quality code that is easy to change. One does not work without the other. The best ideas are useless if the code is hard to change: that is a Formula One champion behind the wheel of a Morris Minor. And code that is easy to change (and therefore quality code) is useless if the people who use it are not at the centre of decisions: that is a Formula One car handed to someone who has just passed their driving test.
We practise, among other things, DDD, hexagonal architecture, command-query separation, and behaviour-driven and test-driven development. We pay attention to the modularity, cohesion, separation of concerns, levels of abstraction and testability of our code. These properties are what let us release at a steady pace, without regressions or malfunctions, and keep costs under control, without having to pick up the pieces later. We judge whether the code stays easy to change by looking at the throughput and the stability of our releases together.
For bespoke software development, we work to a fixed budget, invoiced at the end of each month for the work done. Your application is usable within a month, with a few essential features: your users start working with it straight away, and how they use it determines which features come next.
And to make sure that what worked last month still works this month, we apply a zero-regression guarantee: every regression is fixed and covered by an automated test so that it does not come back, at no extra cost.
Why fix the budget rather than the feature list? The adaptive approach lets that list evolve as your users work with the application.
Want to know whether your application’s code stays easy to change? Shall we talk?
Optimizely, Maileva, AI agents: what the cyber attacks of November 2026 teach about third-party scripts, suppliers and AI in production.
Big bang software projects: months of development away from users, then “this is no use to me”. How to explore their needs and measure real use.
What is shadow IT? The definition from the UK's National Cyber Security Centre, examples (Excel, AI tools) and the risks to the business.