When AI Generates Its Own Code and Collaboration Protocols
郭猛跃 (Guo Mengyue)
Core arguments supplied by the author; text and English translation drafted with AI assistance. The cover is AI-generated. This is an opinion essay about a possible future.
Human-authored software and protocols will no longer be a prerequisite for getting work done.
People will set goals. AI will generate executable code, negotiate the rules of collaboration, and organize the work. The era organized around fixed applications is coming to an end.
How Much of Our Day Belongs to Software?
Consider a familiar working day. You open a messaging app to receive a task, search a shared drive for an attachment, copy data into a spreadsheet, and turn the findings into a presentation. After the meeting, you update the project tracker, send notifications, and add deadlines to a calendar.
One coherent job has been split across several applications. A person must remember where its pieces live, connect the workflows, and explain the same objective repeatedly.
Expense reporting makes the arrangement especially clear. The purchase is complete, but the employee still has to download an invoice, upload a receipt, choose a category, and enter an amount. The systems already hold some of the information. The employee must assemble it again.
We call these activities work. How much of that work creates value, and how much exists to accommodate the systems?
Software expanded human capability. It also trained us to accept a particular order: learn the tool first, pursue the goal second; adapt to the workflow first, move the work forward second. Users paid with attention. Employers paid for training. Familiarity and the difficulty of moving elsewhere became commercial defenses.
AI raises a fundamental question: must we keep paying that cost?
One AI Builds. Another AI Operates.
Today, one side uses AI to write software: pages, buttons, forms, and workflows. The other side uses AI to operate that software: recognize the page, locate the button, fill in the form.
One AI packages a capability. Another AI unpacks it.
A system renders data as a dashboard, and an AI extracts the conclusion. A system arranges functions in a menu, and an AI works out what to click.
This approach has immediate value. Much of the world's operational capability is locked inside existing systems, and AI must work through them to get things done. But a useful transition need not become the permanent architecture.
If both ends can understand a task, why require them to communicate through an entire interaction structure designed for people?
The next step is to exchange goals, constraints, and results directly. AI can generate task-specific code and negotiate data formats, acceptance criteria, and interaction rules. People need not build a separate application for every anticipated need or prescribe a fixed workflow for every possible collaboration.
There is an important technical distinction here. Assembly or machine code is still software and must follow the hardware's instruction set. Communication between devices still needs shared rules. What changes is who generates those rules, and whether they must be fixed in advance.
Designing software and protocols will become part of the AI execution process itself.
Original diagram drawn programmatically. Shared communication foundations, explicit authorization, and verification remain necessary.
The Future Will Not Begin by Opening an App
Imagine a future business trip.
You specify the destination, schedule, and budget. AI checks the meetings, coordinates with transport and accommodation services, and presents a plan you can inspect. You approve material spending. Changes to the trip trigger proposed adjustments. When the trip ends, expenses and receipts are assembled for verification.
You do not have to remember which app holds the reservation or carry the same information between systems. You keep track of the trip as a whole.
Now imagine a small factory receiving an order. The customer's AI provides specifications and a delivery deadline. The factory's AI builds a proposal around inventory, capacity, and cost. Both sides establish quality standards and acceptance conditions. Production proceeds within authorized limits. If the delivery schedule changes, the system proposes alternatives and the responsible person makes the trade-off.
Capabilities that once required buying applications, configuring workflows, and training staff could instead be assembled around the task.
Interfaces would change with them. A comparison calls up a table. A design task calls up a canvas. A decision calls up evidence. Once the job is complete, the temporary workspace closes. Tools appear around the work, and human attention returns to the problem.
What Remains When Applications Recede?
This future forces the software industry to prove its value again.
Reliable data, scarce expertise, accurate execution, and the ability to deliver on a promise will matter more than page counts or feature lists. Businesses sustained by complicated operations, closed formats, and migration friction will come under pressure.
Users will face new judgments too. Did the AI understand the objective? Were the negotiated terms fair? Did execution exceed its authority? Important decisions, verification records, and ways to correct errors must remain visible.
The opportunity is to spend less time maintaining tools and more time choosing directions, creating value, and taking responsibility for our decisions.
Stop asking one AI to build a maze and another AI to find the exit.
Let people set the goals. Let AI generate the necessary code and negotiate the rules of collaboration, with explicit authorization and verification.
Human-authored software and protocols will no longer be a prerequisite for getting work done.
The software industry's old order begins to unravel at that point.
Top comments (0)