I’ve been following some of DingTalk’s technical evolution recently, and one change has made me think deeply. They aren’t simply layering AI on top of their existing system; instead, they’re refactoring in a different direction—gradually CLI-fying their capabilities.

If you view this purely from a tooling perspective, it’s easy to interpret as just a shift in technical choices. But if you zoom out and look at the longer arc, it starts to feel more like a directional bet.

For the past two decades, the default user of software has been human. Interfaces, interactions, and workflows have all been designed around reducing the cognitive load for people.

A GUI is essentially a translation layer—it converts a complex system into a form that can be clicked and understood by humans. But as more and more operations are performed by AI, this translation layer becomes redundant. AI doesn’t need an interface, doesn’t rely on visuals, and doesn’t care about navigation paths. What it needs are deterministic commands, clear parameters, and stable return values. From this perspective, CLI isn’t a retro trend; it’s an interface migrating toward machines.

If you accept this premise, then the significance of DingTalk’s move isn’t just “adding another interaction method.” It’s about rewriting the invocation logic of software.

In the past, we entered a system to complete operations. Now, it’s shifting toward invoking a system to complete a task. You no longer care about the specific click path; you express an intent, and the system decomposes it, executes it, and returns the result. Software is transforming from a “tool to be used” into a “capability to be invoked,” and the right to invoke is beginning to transfer from humans to AI.

Once this lands at the enterprise level, the change is no longer about experience optimization—it’s structural reconfiguration.

Previously, an organization’s capabilities were scattered across processes and roles, requiring humans to trigger and connect them. When people leave or processes change, these capabilities erode. But when these capabilities are broken down into structured commands, a fundamental abstraction occurs: organizational capabilities become interface-ized. Once an interface exists, capabilities are no longer tied to specific individuals; they are precipitated into assets that can be reused, combined, and invoked.

From a business perspective, the implication is direct: enterprises begin to possess true “organizational assets.” In the past, many so-called capabilities were essentially built on human effort and were non-reusable. Once interface-ized, they become capability units that can be continuously amplified. Capabilities that cannot be invoked will quickly lose relevance; capabilities that cannot be reused will struggle to achieve economies of scale. The focus of competition shifts from “who does more” to “whose capabilities are easier to invoke.”

If you map this change to the content domain, the same migration is already happening. Our traditional understanding of UGC was people producing content piece by piece. Creation was the core action; tools were just aids. But when content generation becomes intent-based, the situation changes. People no longer write from scratch; they define the direction, set the constraints, and let the system execute the specific generation. Taking it a step further, when generation, formatting, and distribution can all be invoked, content itself is no longer a “work” but more like an execution result.

At this point, the meaning of UGC is also evolving. It’s no longer just “User Generated Content”; it’s closer to “User Defined Content Production.” The center of gravity for creation shifts from writing content to designing the logic of how content is produced. From this angle, CLI isn’t a technical detail; it’s the foundational prerequisite for making “content production workflows orchestratable.” Only when capabilities are structured and invocable can creation be systematized; otherwise, everything remains at the level of manual operation.

But it’s insufficient to see this only in terms of efficiency. The more significant change is that when execution is taken over by systems, the logic of organizational division of labor gets rewritten. In the past, companies improved efficiency through division of labor, with each person responsible for a segment of the process. Now, the execution layer is gradually being abstracted away, and systems begin to handle most of the actions. People are no longer divided by “what they do,” but stratified by “what they define” and “what they choose.” Execution will become increasingly standardized; judgment will become increasingly concentrated.

This is why, in an environment of seemingly increasing automation, human value becomes more “scarce.” Not because humans do more, but because the part humans are responsible for is increasingly difficult to replace. When everyone can invoke the same system, the same capabilities, and the same workflows, results easily converge. The real differentiator isn’t execution efficiency; it’s the difference in judgment.

From a manager’s perspective, the questions this raises are more important than the answers. You need to start re-examining two things. First, have your core capabilities been structured? If they can’t be invoked, they can’t be amplified. Second, within your organization, what are you deliberately not process-ifying? These parts are often your true moat.

DingTalk’s embrace of CLI might look like just a technical path choice, but underneath, it’s betting on a larger thesis: Future software isn’t just for people; it’s also for AI. Future enterprises aren’t just about organizing resources; they are capability interfaces. Future competition isn’t just about efficiency; it’s about invocability.

If this thesis is correct, then UGC, enterprise software, and even the form of organizations themselves will be redefined.

The change won’t happen overnight, but the direction is clear. From humans operating systems, to systems executing intent, to capabilities being freely invoked—once this path is proven viable, many structures that rely on human maintenance will become fragile.

In the end, the question becomes very simple. When everything can be executed, what, in your organization, must still be decided by you?