Text Is King

The visual era

In data integration, I lived through the period when everyone wanted to make everything visual.

Flows. Connectors. Transformations. Pipelines. Mapping screens. Drag-and-drop components.

Tools like Talend or NiFi promised to make complexity manageable through graphical interfaces. And to be fair, they were useful for getting started. A visual flow helps beginners understand what happens. It gives immediate feedback. It lowers the entry barrier.

For simple use cases, this works well.

But as soon as systems grow, the limits become obvious.

Visual tools do not scale well

The problem with visual tools is not that they are bad. The problem is that they often become heavy at the exact moment when engineering discipline matters most.

When a pipeline becomes critical, you need to answer basic questions:

• What changed?
• Who changed it?
• Why was it changed?
• Can we review the change before it reaches production?
• Can we test it automatically?
• Can we deploy it reliably across environments?
• Can we audit its behavior six months later?

With many visual tools, these questions are harder than they should be.

The logic is hidden inside screens. Versioning is awkward. Code review is weak or impossible. Diffing two versions becomes painful. Automation depends on the tool. Industrialization becomes a fight against the platform.

The interface that was supposed to simplify the system ends up becoming the system’s bottleneck.

Infrastructure as Code changed the center of gravity

Infrastructure as Code moved us in the opposite direction.

Instead of hiding configuration inside interfaces, we made it explicit.

Terraform. YAML. JSON. Shell scripts. CI pipelines. Kubernetes manifests. Dockerfiles. SQL migrations. Git repositories.

The result was not always pretty. YAML can be painful. Terraform can be verbose. Pipelines can become messy. But the move was still powerful because it made work explicit and inspectable.

Once something is text, it can enter the engineering workflow:

• It can be stored in Git.
• It can be reviewed in a pull request.
• It can be tested in CI.
• It can be searched.
• It can be templated.
• It can be generated.
• It can be audited over time.

This is why “as code” won. Not because code is elegant, but because text gives teams leverage.

AI reinforces the trend

AI does not take us back to an “all GUI” world.

On the contrary, AI makes text-based artifacts more valuable.

Large language models are extremely good at working with text. They can generate a Terraform module, explain a SQL query, rewrite a CI job, summarize a log, propose a migration script, or review a configuration file.

They are useful precisely because the artifact is textual.

If your system is defined in text, AI can help you:

• Produce a first version faster.
• Understand legacy configuration.
• Detect inconsistencies.
• Refactor repetitive definitions.
• Explain a pipeline to a new team member.
• Generate documentation from the source of truth.
• Fix errors without clicking through ten screens.

The more your organization relies on textual, explicit artifacts, the more AI can assist without requiring access to proprietary graphical state hidden in a vendor tool.

This is an important point: AI does not remove the need for engineering discipline. It amplifies the value of it.

Text is the common interface

Text is king because text sits at the intersection of everything we need.

It is readable by humans. It is usable by machines. It is generatable by AI. It is versionable in Git. It is searchable. It is diffable. It is portable. It is auditable over time.

That combination is hard to beat.

A graphical interface can be more comfortable for a first interaction. But a textual artifact is usually better for long-term ownership.

This does not mean every user should write code manually. It does not mean interfaces disappear. It means the durable output should be text.

A good UI can help you create a configuration. A good AI assistant can help you write it. But the result should still be something explicit that your team can inspect, version, and operate.

The practical rule

When evaluating a tool, I now ask a simple question:

Can I get the important parts out as text?

If the answer is yes, the tool can probably fit into a serious engineering workflow.

If the answer is no, I become careful. It may still be useful, but it will probably become harder to maintain, automate, review, and migrate later.

The future is not no-code versus code. It is not GUI versus terminal. It is not humans versus AI.

The future is explicit systems, represented in text, assisted by AI, and governed by solid engineering practices.

Text is not king because it is old.

Text is king because it is the format that survives.