Last year I explored the idea of FLUID software as a design philosophy. This piece explores the next layer of that shift: how AI changes the software delivery model itself.

For decades, software engineering assumed one fundamental constraint:

Humans had to write the code.

Entire design philosophies grew from that assumption. Principles like SOLID helped engineers structure systems that were easier for people to understand, extend, and maintain.

But that assumption is breaking.

AI can now generate, refactor, and reshape large amounts of code faster than humans ever could. Implementation is no longer the scarce resource it once was.

And when implementation becomes abundant, the entire software delivery system begins to reorganize itself.

The bottleneck moves.

It moves away from writing code and toward something else: intent, evaluation, and operational judgment.
In that environment, code stops behaving like stone.
It starts behaving like water.

When Code Becomes Fluid

Historically, code was treated as a durable artifact.

Developers wrote it carefully.
Teams reviewed it line by line.
Processes were designed to protect the codebase.

This made sense when writing software required significant human effort.

AI changes the economics of implementation.

When code can be generated quickly, regenerated when needed, and reshaped through collaboration with machines, the stable parts of the system shift elsewhere.

Instead of protecting code itself, engineering organizations increasingly stabilize around:

• architecture and system boundaries
• evaluation harnesses and validation pipelines
• deployment systems and runtime environments
• telemetry and operational feedback loops

Code itself becomes the most fluid layer of the stack.

It flows through the system.

Generated.
Validated.
Deployed.
Observed.
Replaced.
Generated again.

The durable parts of the system move away from the implementation and toward the systems that govern how implementation evolves.

The Real Delivery Shift

Much of the current discussion around AI in software focuses on coding productivity.

Can AI write code faster?
Can it replace developers?
Will code review disappear?

These questions miss the deeper shift.
The real change is not how fast code can be written.

It is how software is delivered.

For most of the history of software engineering, delivery was constrained by implementation capacity. More features required more developers writing more code.

AI dramatically expands that capacity.

But increased implementation capacity does not mean organizations can safely ship software faster without limits.

The constraint moves to something else.

Validation and judgment.

Teams now need reliable ways to answer questions like:

• Does this change maintain architectural coherence?
• Does it pass evaluation and regression checks?
• Does telemetry show unexpected behavior?
• Does this change move the product forward?

Delivery becomes constrained not by writing code, but by verifying it safely.

This elevates a different kind of engineering work:

• harness engineering
• evaluation pipelines
• CI validation systems
• observability and operational feedback

The craft of engineering begins shifting toward governing the flow of generated software.

From SOLID to FLUID

SOLID helped engineers manage complexity in systems where humans wrote most of the implementation.

But in a world where software can be generated and reshaped rapidly, systems need to embrace change rather than resist it.

FLUID reflects a different set of priorities for an AI-assisted environment:

Flexible composition
Systems are structured so components can be reshaped easily.

Live systems
Software evolves continuously rather than through static releases.

Unified context
Humans and AI operate within shared understanding of the system.

Intent-driven structure
Code reflects product intent rather than just mechanical implementation.

Dynamic refactorability
Refactoring becomes an expected and continuous part of system evolution.

FLUID does not replace the lessons of SOLID.

It extends these principles into an environment where software is expected to change constantly and safely. SOLID stops being something you manually enforce and becomes something you encode into the system through skills and guardrails. That foundation is what allows code to behave as a fluid medium instead of a fixed artifact.

The AI-Native Delivery Team

When implementation becomes fluid, team structure evolves as well.

Traditional software teams were optimized around producing code. A typical team might include:

• a product manager
• a tech lead
• several feature engineers
• QA and DevOps support

These teams were built around implementation capacity.

In AI-assisted environments, implementation becomes abundant.

What matters instead is intent, validation, and operational reliability.

Teams reorganize around governing the systems that generate and validate software.

A modern product pod often looks more like this:

• 1 technical product lead driving intent and architectural direction. Think mini CPTO driving strategy and helping shape the solution.
• 2–3 engineers focused on evaluation, deployment, and system reliability
• 1 designer shaping the user experience

The agentic systems produces large portions of the implementation.

The team governs the environment in which that implementation is generated, evaluated, and deployed.

The role of engineers shifts from producing implementation to designing the systems that generate, evaluate, and deploy implementation safely.

Intent, Execution, Verification

One useful way to understand this shift is through three layers:

Intent
What should exist.

Execution
How it gets built. Increasingly handled by machines.

Verification
Whether it should exist at all.

Execution scales with machines.
Human expertise concentrates at the edges.

Humans define intent.
Machines execute.
Humans verify outcomes.

The systems between those layers become the critical infrastructure of modern software delivery.

These include:

• evaluation harnesses
• CI validation pipelines
• deployment automation
• telemetry and monitoring systems

The value of engineering moves upward, from producing code to governing how software evolves within a system.

Designing the Plumbing

If code becomes fluid, engineering shifts to designing the plumbing and validating that it flows where it should, at the right pressure, when it matters.

Architecture defines the pipes.
Evaluation harnesses validate the flow.
Deployment systems govern how changes move through environments.
Telemetry forms the sensor network that monitors the system.

These systems do not operate independently. They form a continuous loop that governs how software is generated, evaluated, deployed, and evolved.

The goal is not to handcraft every line of code.
The goal is to design a system where the flow remains safe, useful, and continuously improving.

The Future of Software Delivery

Many organizations are experimenting with AI coding tools while keeping delivery systems designed for a world where humans wrote every line of code.

That mismatch will not hold.
Software delivery is moving from: writing code
to designing systems that generate and validate software.

In that world, code becomes FLUID.

And the core discipline of engineering becomes guiding how that fluid flows through the system.