Software Engineering is 90% repeatable patterns

Like many seasoned engineers, I’ve gradually come to realise just how much of our work is built on familiar repeatable structures, whether it’s planning, ceremonies, writing code or making decisions.

As programming languages have evolved, so have the abstractions we use to communicate intent. Each new layer makes it easier to instruct machines but always through clear structure.

Now, with prompt engineering, and more recently, context engineering , we’re stepping into a new abstraction entirely. One where we guide machines not just with syntax, but with intent, structure, and context.

So what is context engineering?
Recently many AI augmented engineers have shifted from using loose and open prompts, to generating structured inputs, with clarity around context, instructions, behaviour and tools so that the LLM is more likely to accomplish the task. The key to context engineering is establishing more structure.

..but we need more
I believe the path to truly effective AI assisted software delivery is through codifying and optimising the patterns we have (inconsistently) followed as humans for so long. And writing code is only a small part of that challenge.

We can find patterns wherever we look:

• Planning. We talk to with domain experts to identify ubiquitous language and domain boundaries. We break work down into structured user stories & acceptance criteria. We use repeatable techniques to prioritise and distribute work.

• Decision making is most effective when it’s structured. Evaluating options, identifying impact, determining what matters and were we can compromise. Tools like ADRs already exist to establish this structure. AI is a powerful tool to assist with ADRs and can draw on knowledge not within a team.

• Agile ceremonies no doubt feel repetitive for many. AI can help us to communicate more consistently, identify and highlight important and actionable information.

• Writing code. Most line of business applications can be implemented with just a handful of core patterns (commands, queries, event handling etc). With well defined libraries, rule sets and a standard way of describing system behaviour, it’s more than feasible for AI to generate these systems accurately.

What we do next isn’t about teaching AI to code, it’s about teaching it how we work.
And that starts with making our patterns explicit.

Which patterns do you think we need to codify first?