Artificial intelligence has changed the economics of software development. For the first time in decades, the marginal cost of producing code is collapsing. A small team equipped with modern LLM tools can generate APIs, user interfaces, integration layers, and test suites in days instead of weeks.

This creates a powerful illusion:

If AI can generate most of the implementation, perhaps architecture no longer matters.

Perhaps we can simply let the team build it.

That assumption is where many future failures begin.

The Linux Moment of Custom Software

We have seen similar shifts before.

 – Linux reduced infrastructure costs.
 – Kubernetes reduced the cost of scaling.
 – PostgreSQL reduced the cost of enterprise-grade data storage.

None of them succeeded because they were “cheap.” They succeeded because they were architecturally sound. 

Open standards reduced barriers. Professional engineering preserved sustainability.

AI is now playing a similar role in custom software development. It reduces the cost of writing code.It does not automatically reduce the cost of building systems.

Those are fundamentally different problems.

What AI Actually Makes Cheap

Let’s be precise. AI dramatically reduces the cost of:

    • boilerplate code

    • CRUD services

    • API scaffolding

    • frontend components

    • test generation

    • refactoring

    • documentation

In a structured environment, AI can double or triple delivery velocity.

But velocity in implementation is not the same as clarity in architecture.

AI optimizes execution.
It does not define direction.

When headlines say:

Coding agents can ship 10,000 lines of code per day to production.

What it actually means:

Coding agents are very productive… according to a very dumb metric.

Lines of code are not a proxy for value.They are often a proxy for complexity.

 

Enterprise systems fail because of poorly designed boundaries, not because too few lines were written.

What AI Does Not Make Cheap

AI does not reduce the cost of:

    • defining system boundaries

    • modeling complex domains

    • establishing data ownership

    • designing multi-tenancy

    • implementing IAM correctly

    • performing threat modeling

    • aligning with compliance frameworks

    • planning operational resilience

    • managing long-term evolution

 

Architecture is not about code volume. It is about constraint management and risk allocation.

 

AI can generate a microservice ⇒ It cannot decide whether your organization should have that microservice.

 

AI can implement authentication ⇒It does not design accountability.

 

AI reduces the marginal cost of code ⇒ Architecture determines the total cost of ownership.

 

Confusing the two is expensive.

Architecture as a Multiplier

 

When architecture is deliberate, AI becomes a force multiplier.

For example, in the maritime domain, we are developing SeaTech as an open-source initiative designed around modular, interoperable port systems — not just isolated features, but well-defined operational building blocks.
(SeaTech repository: https://github.com/inero-software/seatech)

⇒ The goal is not to produce code faster.

⇒The goal is to define reusable architectural patterns that AI can then accelerate safely.

The same applies in security.

A small extension such as a Keycloak SMS-based password reset module
(https://github.com/inero-software/keycloak-reset-password-sms-extension)
may look simple on the surface, but it addresses a very specific enterprise need: secure, production-ready password reset flows via SMS integrated directly into Keycloak’s authentication lifecycle.

Similarly, AuthM8
(https://github.com/inero-software/AuthM8)
focuses on authentication orchestration patterns that help structure IAM logic in a way that remains maintainable and auditable over time.

AI can generate portions of these solutions.

But without understanding IAM flows, lifecycle hooks, and security implications, generated code quickly becomes fragile.

Architecture enables reuse ⇒ AI accelerates it.

Two Futures

As AI tools become more powerful, organizations face a strategic fork.

Future A: AI Without Architecture

Development accelerates.
Features multiply because they are easy to imagine.
Integration points grow and grow.
Security is postponed because rest is more simple and interesting.
Governance is informal.

 

Within 18 months You get:

    • inconsistencies emerge

    • technical debt compounds

    • audit exposure increases

    • re-platforming discussions begin

 
AI accelerated output but it also accelerated entropy.

 

Future B: AI Under Professional Architecture

Boundaries are defined early.
Security is designed from day one.
Data ownership is explicit.
Observability is intentional.
Compliance constraints are integrated.

 

AI is used aggressively — but within a defined framework.

AI amplifies your architecture.

 

If it is weak, it amplifies weakness. If it is strong, it amplifies leverage.

Long-Lived Systems Are Different

Fast prototypes and long-lived systems operate under different laws.

Prototypes optimize for speed.

Production systems optimize for survivability.

Long-lived systems accumulate:

    • unpredictable edge cases

    • integration dependencies

    • security pressures

    • evolving requirements

    • institutional accountability

 

Consider a municipal food delivery coordination platform (Gorący Posiłek) operating for the City of Warsaw.

For over four years, it has coordinated more than two million meals. It supports real beneficiaries, real logistics, and real public-sector workflows. It must operate reliably across seasonal demand shifts, resist abuse attempts, integrate with administrative processes, and remain secure under continuous exposure.

Could AI generate parts of such a system today? Yes.

Could it accelerate modules? Absolutely.

But AI would not independently design:

    • a domain model aligned with municipal realities

    • safeguards tailored to public-sector risk

    • resilience strategies for years of operation

    • governance mechanisms that survive audits

 

AI accelerates construction.
It does not generate institutional understanding.
It does not assume responsibility.

 

Systems that coordinate millions of real-world operations are not clever codebases.

They are engineered ecosystems.

And rememeber, when headlines say:

Company X has won the AI race.

What it actually means:

No one has won anything.
The race is far from over.
We are only hitting the first corner of a marathon.

AI progress is real. But we are nowhere finish line.

It is a moving target (at least for today).