Equinox IT Blog

The human element of AI

by Jason Walker on 15 June 2026

The human element of AI
7:58

For decades, the software industry has pursued a familiar ambition: reducing the amount of human effort required to produce software.

From higher-level languages to frameworks, low-code platforms, cloud infrastructure, DevOps pipelines, and now generative AI, each wave has promised some variation of the same future — less friction, less repetition, less manual construction.The-Human-Element-of-AI

AI-generated image for illustrative purposes only.

The automation dream

From higher-level languages to frameworks, low-code platforms, cloud infrastructure, DevOps pipelines, and now generative AI, each wave has promised some variation of the same future — less friction, less repetition, less manual construction.

And in many ways, AI represents the most successful version of that dream yet.

Modern systems can already generate boilerplate, scaffold applications, write tests, explain APIs, transform data structures, summarise documents, and increasingly produce entire features from natural language prompts. The mechanical act of programming is becoming cheaper at a remarkable pace.

Yet something unexpected seems to be happening alongside this acceleration.

As implementation becomes easier, human understanding appears to become more valuable.

The return of human context

Much of the current discussion around AI focuses on reducing human involvement in software implementation. But many of the pressures emerging inside AI-assisted engineering environments point in the opposite direction.

Teams are beginning to experience:

  • review fatigue,
  • architectural drift,
  • context fragmentation,
  • increasing dependence on senior engineers,
  • and growing bottlenecks around trust, validation, and integration.

Code may be generated faster than ever, but understanding does not scale at the same rate.

In some organisations, the limiting factor is no longer writing software. It is maintaining coherence across an expanding volume of machine-assisted change.

Ironically, the more implementation is automated, the more important human relationships become.

Not simply communication in the abstract, but trust networks:

  • who understands the system,
  • who can validate intent,
  • who carries historical context,
  • who understands which inconsistencies are accidental and which are deliberate,
  • who people trust to say “no”.

As AI increases local productivity, human beings increasingly become the mechanism for global coherence.

A senior engineer may now review dozens of AI-assisted pull requests spanning systems they no longer directly authored. Architectural understanding increasingly becomes separated from implementation activity itself.

Programming as understanding

Decades before modern AI, Danish computer scientist Peter Naur argued that programming was fundamentally an act of “theory building”. The real system, he suggested, did not exist purely in source code, but in the shared understanding held by the people working on it.

Code was only one artifact of that understanding.

At the time, this stood somewhat against the industry's growing desire to industrialise software development through process, abstraction, and formalism.

Yet AI may unexpectedly reinforce Naur’s position.

Generative systems can produce implementation at astonishing speed, but they do not truly possess organisational memory, political context, operational intuition, or long-term ownership. They do not understand why one compromise survived three restructures, why a seemingly redundant validation exists, or why a team distrusts a particular dependency despite the documentation appearing sound.

The machine can increasingly produce syntax.

The human still carries intent.

Essential complexity remains

Similar ideas echo throughout older software engineering literature.

Fred Brooks famously distinguished between accidental complexity and essential complexity in The Mythical Man-Month. Tools could reduce the accidental difficulties of software construction, but the deeper problems — ambiguity, competing requirements, organisational coordination, human misunderstanding — remained stubbornly intact.

AI appears extraordinarily effective at removing accidental complexity.

But essential complexity remains deeply human.

Perhaps more importantly, it becomes concentrated.

Fewer people may now oversee larger systems, broader architectural surfaces, and increasingly accelerated delivery pipelines. The result is not necessarily less human involvement, but denser contextual responsibility.

Senior engineers, architects, reviewers, and technical leads increasingly operate as context integrators:

  • validating machine-generated output,
  • preserving consistency,
  • arbitrating tradeoffs,
  • and maintaining shared understanding across rapidly changing systems.

The bottleneck shifts upward.

Complexity and concentrated responsibility

Some of this may also reflect older ideas from complexity theory.

Frameworks like the Cynefin model distinguished between problems that are merely complicated and those that are genuinely complex — environments where outcomes emerge through interaction, where causality is only visible in retrospect, and where experimentation replaces deterministic planning.

AI appears highly effective at reducing many forms of complicated work. Boilerplate generation, transformation tasks, scaffolding, and implementation assistance increasingly become tractable to automation.

But as these activities accelerate, human responsibility may become concentrated in the complex domain instead:

  • integration,
  • governance,
  • organisational alignment,
  • architectural coherence,
  • and the management of competing contextual pressures.

The result is not necessarily less effort, but more concentrated responsibility.

Fewer people may now carry broader contextual responsibility across increasingly accelerated systems.

Governing accelerated systems

Even older ideas like Conway’s Law begin to feel newly relevant. As code generation accelerates, system structure may increasingly reflect communication pathways rather than implementation effort.

The people capable of maintaining high-context understanding become central coordination points inside the organisation.

And like all coordination points, they become both valuable and fragile.

This may partially explain why many experienced engineers already report a strange duality in AI-assisted environments:

  • individual productivity increases dramatically,
  • while review pressure and contextual burden rise alongside it.

The challenge moves from producing software to governing it.

Rediscovering older ideas

None of these ideas are entirely new.

Long before AI, software engineering thinkers explored tacit knowledge, craftsmanship, socio-technical systems, reflective practice, and the irreducibly human aspects of building complex systems. Many of those discussions faded beneath the industry's ongoing pursuit of scale, abstraction, and automation.

Yet they remain surprisingly relevant.

Possibly more relevant than expected.

In the rush toward intelligent systems, software engineering may be rediscovering something older: that the hardest part was never the code.

It was always the humans trying to understand it together.

A final caution

There is perhaps a final caution in this.

Complex systems do not become simple merely because implementation becomes easier. Accelerated delivery, machine-generated code, and rapidly expanding organisational throughput can create the illusion that complexity itself has been conquered.

But many systems fail precisely when local optimisation exceeds the human capacity to maintain shared understanding.

Older complexity models such as Cynefin warned against treating genuinely complex environments as if they were merely complicated ones — predictable, linear, and fully governable through process alone.

AI may tempt organisations toward exactly this mistake.

As software generation accelerates, the pressure placed upon human coordination, trust, judgement, and contextual understanding may grow faster still. The danger is not simply poor code. It is pushing teams beyond their ability to maintain coherence across the systems they collectively inhabit.

The challenge may not be learning how to scale AI.

It may be learning how to scale humans responsibly around it.

Further Reading
Topics: AI ✨

See all

See all

Subscribe by email