自主架構師：AI 如何撰寫、測試並改進自己的程式碼

Abstract: The era of artificial intelligence as a passive, conversational "autocomplete" is ending. The next frontier of software engineering replaces stateless chatbots with autonomous agents—systems capable of architecting, writing, testing, and debugging their own code. This article explores the paradigm shift from probabilistic text generation to deterministic execution lanes. By leveraging the Perceive-Plan-Act-Reflect loop, strict Tool Contracts, and shared session state, developers can orchestrate massive "swarms" of AI sub-agents to build and scale entire software architectures concurrently.

Act 1: Escaping the Text Cage (The Shift from Chat to Action)

Most developers interact with Large Language Models (LLMs) through a highly restrictive paradigm: the chat interface. In this setup, the AI acts as a smart autocomplete tool. A human types a request, the model guesses the statistically likeliest next token, and the output is rendered as markdown text.

However, a traditional conversational model operates as a stateless entity trapped inside its context window.

A chatbot possesses no computational boundary outside of its prompt. It cannot execute side effects, read your local directory, or mutate external state. Once the text generation stops, the execution terminates entirely.

+---------------------------------------------------------+
|                THE CHATBOT PARADIGM (STATELESS)         |
+---------------------------------------------------------+
| [User Prompt] -> [LLM Weights] -> [Text Output] -> STOP |
| (Cannot read files, cannot run tests, cannot mutate)    |
+---------------------------------------------------------+

Breaking the Boundary

To innovate autonomously, AI must escape the text cage and enter the terminal. This requires a structural shift from probabilistic generation to deterministic execution lanes.

An autonomous agent is not defined by its conversational fluency, but by the physical wiring connecting the language model to external tools, shared state storage, and programmatic hooks. By granting the model sandboxed access to the terminal, it transforms from a chatbot into an active software engineer capable of navigating directories, writing scripts, running CI/CD pipelines, and mutating application state.

Act 2: The Agentic Loop & The Tool Contract

When an LLM is upgraded to an agent, it ceases to be a simple input-output function. Instead, it becomes the reasoning engine within a closed, continuous operational loop.

The Perceive-Plan-Act-Reflect Cycle

Agent runtime behavior is governed by a four-phase execution architecture, often referred to in agentic frameworks as the ReAct (Reasoning and Acting) loop:

+----------------------------------------------------------------+
|                   THE AGENTIC EXECUTION LOOP                   |
+----------------------------------------------------------------+
| 1. PERCEIVE: Ingests user intent, session state, and history.  |
|      ↓                                                         |
| 2. PLAN:     Architects a solution and selects target tools.   |
|      ↓                                                         |
| 3. ACT:      Host runtime intercepts the plan and runs code.   |
|      ↓                                                         |
| 4. REFLECT:  Reads terminal logs, evaluates, and rewrites.     |
+----------------------------------------------------------------+

Perceive: The agent reads the current state of the codebase, the developer's architectural instructions, and its available toolkit.
Plan: Realizing it cannot solve the problem with text alone, the model builds an execution plan. It selects appropriate tools (e.g., write_file, run_bash_command) and populates their required arguments.
Act: The host runtime (e.g., a Python backend) intercepts the model's structured tool call and physically executes the code on the server.
Reflect: The runtime feeds the terminal output (such as stack traces, linter warnings, or test successes) back into the model's context. The agent evaluates this feedback, fixing syntax errors autonomously until the tests pass.

The Strict Tool Contract

Language models cannot run Python code natively. To bridge this gap, systems architects use a Tool Contract.

The host framework automatically translates deterministic Python functions (using type hints and docstrings) into standardized JSON Schemas. The model reads this schema, understands the function's capabilities, and returns a structured JSON payload asking the runtime to execute it.

# The Deterministic Python Tool
def write_and_test_route(route_name: str, methods: list[str]) -> str:
    """
    Generates a FastAPI route, writes it to disk, and runs PyTest.
    """
    filepath = f"app/api/routes/{route_name}.py"

    # 1. Write the agent's generated code to disk
    write_to_disk(filepath, generated_code)

    # 2. Trigger the terminal test autonomously
    result = subprocess.run(["pytest", f"tests/test_{route_name}.py"], capture_output=True)

    # 3. Return exact terminal logs to the Agent for 'Reflection'
    if result.returncode != 0:
        return f"TEST FAILED. Fix the code based on this Traceback: {result.stderr.decode()}"

    return "TEST PASSED. Route is production-ready."

Through lifecycle callbacks and parameter overrides, developers force the non-deterministic LLM to abide by strict, programmatic rules—creating a highly reliable control plane.

Act 3: Swarm Architecture (100 Agents Building Together)

A single agent operating in a continuous loop is powerful. However, modern software architecture requires distributed orchestration. Enter Multi-Agent Swarm Architecture.

Instead of forcing one massive model to handle frontend UI, database schema migrations, and security testing simultaneously (which leads to severe context bloat and memory degradation), the architecture is decomposed across a swarm of specialized sub-agents.

Imagine a system where micro-agents operate concurrently:

The Backend Swarm (Agents 1-20): Writing and testing FastAPI routes.
The Data Swarm (Agents 21-40): Provisioning optimized PostgreSQL schemas.
The Red Team (Agents 41-50): Acting as security auditors, actively attempting to break the code the other agents just wrote.

Managing Chaos: The Digital Whiteboard

If 50 autonomous agents modify a codebase simultaneously, they risk overwriting each other's work and causing terminal merge conflicts. This is solved by completely separating Artifacts (the heavy code files) from State (the agent's memory).

Instead of passing massive files back and forth in their context windows, agents use a shared Session Dictionary—a digital whiteboard where they coordinate their actions.

+---------------------------------------------------------------+
|                 MULTI-AGENT SWARM ORCHESTRATION               |
+---------------------------------------------------------------+
|                 [ Shared Session Dictionary ]                 |
|                   (The Digital Whiteboard)                    |
|                              |                                |
|    +-------------------------+-------------------------+      |
|    |                         |                         |      |
| [Sub-Agent: DB]       [Sub-Agent: API]       [Sub-Agent: UI]  |
| (Writes Schema)       (Reads Schema)         (Consumes API)   |
|  *Locks State*         *Waits for Unlock*     *Mocks Data*    |
+---------------------------------------------------------------+

When the Database Agent starts writing a schema, it writes a lightweight reference string to the shared state and triggers a lock:

# Shared State Update
shared_state["database"] = {
    "status": "LOCKED_FOR_WRITING",
    "active_agent": "Agent_DB_01",
    "filepath": "/db/schema.sql"
}

The API Agent reads this state. Using deterministic execution locks, the API agent knows it must wait in a holding loop until the database status changes to UNLOCKED before it writes the routing logic. This transactional safety ensures perfectly coordinated, parallel software generation without human intervention.

Conclusion

The evolution of AI coding is rapidly transitioning from human-in-the-loop assistance to full-scale autonomous generation. The future of software engineering is no longer about typing syntax faster; it is about systems architecture.

By mastering the Perceive-Plan-Act-Reflect loop, defining strict tool contracts, and managing shared state across distributed swarms, developers are building the ultimate meta-software: systems that can architect, debug, and scale themselves.