When Agent acts as the first citizen, there are three key changes: 1: Agent is not a revolution, but an acceleration.

It does not change the basic structure of software evolution, it just increases the speed of the "intent → code" cycle by several orders of magnitude.

This judgment is important because it means that we do not need to overturn the existing cognitive framework to understand the agent.

We only need to ask: when the speed changes, does the original assumption that was true at slow speed still hold?

Two: Static precipitation will not disappear.

After uncertainty is eliminated, deterministic things should be expressed in a deterministic way - this is the raison d'être of code.

Using a huge probability model to approximate a determined function is an absurd waste in an information theory sense.

Therefore, after the agent system matures, it will naturally solidify the verified logic into code, and the proportion of agents will decrease - until new intentions pour in, and the proportion of agents will increase again.

Three: The model has not changed, but the requirements for infrastructure have completely changed.

When cycle speeds increase from months to minutes, the infrastructure originally designed for slow cycles will become a bottleneck or become unsuitable.

Git assumes that every change is worthy of commit; CI/CD assumes that build and deployment are discrete events; the test environment assumes that the code is stable and the environment can be prepared in advance to run; the release system assumes that releases are low-frequency and require manual approval; Code Review assumes that someone looks at each line of code.

These assumptions are all true under slow cycles and invalid under fast cycles.

Today's Git, CI/CD, and Code Review systems will not disappear, but their jurisdiction will shrink to the realm of "persistent code"—and the area of that realm is shrinking.

What really needs to be built is a new generation of infrastructure that supports the dynamic mixture of agent + code.

The direction is clear: add capabilities to infra.

Infra's capability boundary is the agent's autonomy boundary.

The above content comes from the Alibaba Technology Official Account:

Visual summary

Article argument map

Generated from the post's content graph

Mermaid outline

flowchart LR
  format-long_post["longform note"]
  topic-agents["agents"]
  topic-harness-engineering["harness engineering"]
  capability-agent-workflow["agent workflow"]
  capability-harness-engineering["harness engineering"]
  format-long_post -->|covers| topic-agents
  format-long_post -->|covers| topic-harness-engineering
  format-long_post -->|signals| capability-agent-workflow
  format-long_post -->|signals| capability-harness-engineering

Visual structure

Essay structure map

Built from summary and key paragraph positions

Mermaid outline

flowchart LR
  thesis["When Agent acts as the first citizen, there are three key changes: 1: Agent is not a revolution, but an acc..."]
  signal["When Agent acts as the first citizen, there are three key changes: 1: Agent is not a revolution, but an acc..."]
  operator["Three: The model has not changed, but the requirements for infrastructure have completely changed."]
  implication["The above content comes from the Alibaba Technology Official Account:"]
  thesis -->|frames| signal
  signal -->|develops| operator
  operator -->|lands in| implication

Source: View the original post