Skip to main content
Tech
#AI

Why Salesforce, Workday, and Uber Are Removing the Screen

The real shift in the AI era is not the “screen,” but the “runtime.” Developers may ultimately return to fundamentals like POSIX and domain knowledge.

· 8Minutes

🚀 And Why AI-Era Developers Are Returning to POSIX

Over the past few years,
we’ve been witnessing a surprisingly important shift.

  • Salesforce is pushing “Headless 360,” where AI Agents directly interact with CRM backends.
  • Workday is talking about “Headless HR,” centered around Slack and AI Agents.
  • Uber is exposing its ride-hailing runtime outside of its own app.
  • Next-generation commerce platforms like commercetools are treating “Headless Commerce” as the new standard.

What’s interesting is that this trend is not simply about “adding AI features.”

The deeper change is that industries are moving away from systems where humans manually click through screens, toward systems where APIs and workflows directly invoke runtimes.

In other words:

  • UI layers are becoming thinner,
  • APIs and workflow runtimes are becoming the core,
  • and AI Agents and external workflows are increasingly calling backends directly.

And this is not just another web development trend.

It’s happening across nearly every industry:

  • CRM
  • HR
  • e-commerce
  • finance
  • mobility
  • retail
  • enterprise workflow systems

Many people view the AI era as a new race around things like:

  • prompt engineering
  • MCP
  • tool wrappers
  • harness engineering

But in the long run,
the industry may actually converge in the opposite direction.

As AI advances,
developers may end up returning to the fundamentals.

And at the center of that shift lies a surprisingly old concept:

POSIX.

🧩 1. The Entire Industry Is Moving Toward “Headless”

The most important shift today is not AI code generation.

The deeper transformation is that services are being rebuilt around APIs and runtimes instead of UI-centric architectures.

In the past, most systems were built around human-operated interfaces.

  • Users opened websites,
  • clicked buttons,
  • and manually filled out forms.

That model used to be the default.

But today, both enterprise and consumer industries are rapidly moving toward headless architectures. Across all of these areas, UI layers are becoming thinner while APIs and workflow runtimes are becoming the true center of the system.

This shift matters because the industry itself is moving away from “humans operating screens” toward “runtime and workflow orchestration.”

⚙️ 2. The Headless Era Is Ultimately a Runtime Era

The essence of headless is not frontend optimization.

What’s really happening is a structural transition like this:

UI-centric services
↓
API-centric services
↓
Workflow-centric services
↓
Agent-centric services

We are moving from a world where humans click interfaces to a world where AI and workflows directly invoke runtimes.

And underneath that runtime world,
the foundation is still built on Unix philosophy.

  • POSIX
  • Shell
  • Process
  • Filesystem
  • Pipe

These concepts still underpin most runtime environments today.

Ironically, as AI evolves,
the importance of these “old fundamentals” may grow again.

🤖 3. AI Agents Understand Runtimes Better Than GUIs

AI Agents are not actually very good at understanding GUIs.

They interact far more naturally with CLI-based runtimes than with complex visual interfaces designed for humans.

For example, AI models understand command flows like these extremely well:

git diff
pytest
docker compose up
kubectl logs

That’s because CLI environments are:

  • deterministic,
  • composable,
  • machine-readable,
  • and automation-friendly.

GUI environments are convenient for humans,
but POSIX runtimes are far more natural for AI systems.

As a result,
future development environments may shift away from IDE-centric workflows toward runtime-centric workflows.

🧱 4. MCP and Harnesses May Be Transitional Abstractions

Today, the industry is heavily focused on intermediate layers such as:

  • MCP
  • tool wrappers
  • harness engineering
  • prompt engineering

But these may ultimately be temporary abstractions designed to fill the current capability gap in AI systems.

Historically, the software industry has repeatedly converged from complex wrappers toward standardized runtimes.

Complex wrappers
↓
Standardized runtimes

AI may follow the same path.

In the long run, AI systems may directly understand existing runtime abstractions such as:

  • shell
  • process
  • filesystem
  • workflow

Rather than building entirely new runtimes for AI,
it may be more natural for AI to simply understand the runtimes we already have.

🧠 5. The Real Differentiator Is Still Domain Knowledge

One important thing remains true:

Even if AI writes code,
that does not mean it understands the business itself.

In real-world environments, what matters most is not syntax, boilerplate, or CRUD generation.

The real complexity lies in domain knowledge, such as:

  • financial rules
  • organizational policies
  • operational workflows
  • deployment procedures
  • customer requirements
  • project-specific tribal knowledge

And domain knowledge generally falls into two categories.

The first is Business Domain knowledge.

This is knowledge about the industry and the business itself — understanding what needs to be built.

The second is Project-specific Domain knowledge.

This includes things like:

  • deployment order
  • branching strategy
  • coding conventions
  • operational quirks
  • legacy workarounds
  • customer-specific rules

In other words,
understanding how systems are actually operated.

A surprisingly large percentage of production incidents happen not because of algorithms, but because this kind of project-specific knowledge is missing.

🔧 6. The Core Skill of Future Developers May Again Become “Fundamentals”

In the AI era,
the value of things like:

  • framework-specific trivia
  • tool-specific tricks
  • wrapper engineering

may gradually decline.

Because those are exactly the kinds of tasks AI can replace the fastest.

What will remain valuable are the more fundamental capabilities:

  • runtime understanding
  • domain understanding
  • workflow orchestration
  • operational supervision

Ultimately, future developer skills may converge around three core areas:

1. AI and team operations
2. Domain understanding
3. POSIX and runtime-based development lifecycle knowledge

What’s interesting is that these skills remain relevant regardless of:

  • company,
  • project,
  • or industry.

They are universal capabilities.

🧭 7. Future Developers May Look More Like Supervisors Than Coders

AI will continue generating more and more code.

But humans will still need to decide:

  • what should be built,
  • what constraints exist,
  • how systems should be operated,
  • and what risks need to be managed.

In other words,
future developers may become less like “code writers” and more like supervisors who understand both domain knowledge and runtime systems.

And underneath that role will be things like:

  • POSIX runtimes
  • domain memory
  • operational knowledge
  • agent orchestration

🔚 8. The AI Era May Actually Be a Return to Fundamentals

Many people describe the AI era as:

  • a completely new paradigm,
  • the end of human developers,
  • or magical automation.

But reality may look very different.

As AI evolves,
the industry is steadily moving away from UI-centric systems and toward runtime-centric systems.

And underneath those runtimes,
the old foundations still remain:

  • POSIX
  • Shell
  • Process
  • Workflow

In the end,
future competitiveness may depend less on tool-specific tricks and more on fundamental adaptability that works across any environment.

And perhaps the phrase that best captures this shift is:

Back to POSIX

0Comments
8Minutes