On this page
One of the more interesting things about experience is that it can make difficult work appear deceptively simple.
I’ve spent more than three decades designing and developing software and systems. Over that time, I’ve become accustomed to looking at a problem and considering several aspects of it almost simultaneously.
What is the real objective? What assumptions are being made? Which dependencies matter? Where might the architecture become fragile? What will the people using the system actually need? How will we know whether the outcome is right?
Often, those questions arise naturally.
But that apparent ease is the product of experience, not evidence that the underlying work is easy.
What is visible, and what isn’t
When someone sees a working product, they usually see the result.
They may see a clean interface, a straightforward interaction or a system that appears to do exactly what was required.
What they don’t necessarily see are the alternatives considered, the assumptions challenged or the decisions that prevented problems from occurring.
The value of prevention
A great deal of engineering expertise lies in recognising what not to build.
Sometimes the most valuable decision is to avoid a complication before it becomes part of the architecture.
Sometimes it is identifying a misunderstood requirement before it leads to an expensive implementation.
Sometimes it is recognising that a seemingly small change has consequences elsewhere in the system.
None of these decisions necessarily produces a dramatic demonstration.
Often, the evidence of a good decision is simply that the resulting system is easier to understand, use and maintain.
Simplicity takes work
I value simplicity, but I don’t confuse it with the absence of complexity.
A well-designed system can be straightforward to use precisely because the complexity has been addressed elsewhere.
The interface doesn’t need to expose every technical consideration behind an action.
The user shouldn’t have to understand the architecture to accomplish a legitimate task.
The developer maintaining the system should not have to rediscover the reasoning behind every important decision.
Achieving that kind of simplicity requires deliberate design and engineering.
It involves understanding enough of the complete problem to make the right things simple.
The danger of underestimating the work
I have encountered situations where the apparent ease of an experienced person’s work led others to underestimate what was involved.
I think this is an understandable human tendency.
We learn by observation, and when someone makes a task look straightforward, it can be tempting to conclude that the task itself is straightforward.
The difficulty arises when that conclusion becomes a substitute for understanding.
Reproducing is not understanding
The ability to reproduce a visible result is not necessarily the same as understanding the decisions that make the result dependable.
In software development, that distinction can have significant consequences.
An implementation may appear successful while concealing weaknesses in its requirements, architecture, accessibility, maintainability or operational behaviour.
Those weaknesses frequently become apparent when the system needs to change, accommodate new demands or operate outside the conditions in which it was first demonstrated.
By then, correcting them may be considerably more expensive.
Experience should make us more curious
None of this means that expertise belongs exclusively to people who have spent decades in a profession.
I’ve worked with people at different stages of their careers who brought excellent ideas, sound judgement and perspectives I would not have reached alone.
Experience is valuable, but so are curiosity, openness and the willingness to learn.
I certainly don’t believe that having done something for a long time automatically means doing it well.
What experience can provide is a larger collection of patterns, mistakes, consequences and alternative approaches against which a new problem can be considered.
The value lies in using that knowledge thoughtfully.
And one of the responsibilities that comes with experience is making the reasoning accessible to others, rather than using knowledge as a barrier.
Why the lifecycle matters
This is where the Software Development Lifecycle becomes particularly important.
It helps make the less visible parts of engineering explicit.
Requirements establish what needs to be achieved. Design explains how the solution is intended to work. Implementation makes it real. Acceptance criteria and testing establish what can be demonstrated.
The lifecycle also provides opportunities to question decisions before their consequences become expensive.
It is not a guarantee of quality, but it gives engineering judgement a structure in which to operate.
Combined with design-led development, it helps maintain continuity between the original problem and the resulting system.
A new development environment
AI-assisted development adds an interesting dimension to this discussion.
GPT can contribute substantially to software implementation. I have experienced that directly, and I regard it as a powerful development.
But generating a plausible implementation is not the same as understanding whether it is appropriate.
As the mechanics of producing software become easier, the ability to recognise sound decisions, questionable assumptions and missing evidence becomes increasingly important.
There is a considerable difference between obtaining a working result and being able to take professional responsibility for that result.
Making the difficult look straightforward
I enjoy turning difficult ideas into working systems.
Part of that enjoyment comes from making something understandable that initially appeared complicated or uncertain.
The best results often feel natural. The system behaves as expected. The interface makes sense. The architecture supports what the product needs to do.
That is not an absence of engineering.
It is frequently the result of engineering done well.
The real value of experience is not making complexity disappear by pretending it isn’t there. It is learning how to understand it, manage it and prevent it from becoming somebody else’s problem.
Research context
Topic: Engineering judgement
Explore further
Further reading is listed below.