跳到正文
Amp Chronicle·· 2025-04-15精選AI 評分77

如何用 Go 建立可編輯程式碼的 Claude 智能體

How to Build an Agent

AI 導讀

Thorsten Ball 示範以 Go 和 Anthropic API 建立可編輯程式碼的 Claude 智能體,並以迴圈處理對話及工具呼叫。示範加入 read_file、list_files 和 edit_file,讓模型讀取及列出檔案,並按指令建立或修改檔案;工具結果會送回模型。程式碼不到 400 行。

推薦理由

文章以不到 400 行 Go 程式碼,逐步組裝可讀取、列出及編輯檔案的 Claude 智能體,呈現工具定義與執行結果回傳的基本循環。

正文 · 繁體中文

Thorsten Ball//2025 年 4 月 15 日

或者:皇帝的新衣

要打造一個功能齊全、能編輯程式碼的 Agent,並沒有那麼困難。

看起來可能很困難。當你看到 Agent 編輯檔案、執行指令、從錯誤中脱困,並嘗試不同策略時,會覺得背後一定有甚麼秘訣。

其實沒有。它只是一個 LLM、一個循環,以及足夠的 tokens。從一開始,我們就在Podcast上這樣説。至於其他部分,那些令Amp如此令人上癮、如此出色的東西?全靠埋頭苦幹。

但要打造一個小巧而令人印象深刻的 Agent,甚至不需要這些。不到 400 行程式碼就能做到,而大部分都只是樣板程式碼。

我現在就會示範給你看。我們一起寫一些程式碼,從零行程式碼開始,直到你驚嘆:「哇,這……真是改變一切。」

我強烈建議你跟着一起做。不,真的。你可能覺得只要閲讀本文就可以,不用親手輸入程式碼,但這不到 400 行。我希望你能親身感受程式碼有多精簡,也希望你能在自己的終端機、自己的資料夾裏親眼看到這一切。

我們需要以下東西:

拿出鉛筆!

我們馬上開始,用四個簡單指令設定一個新的 Go 專案:

mkdir code-editing-agent
cd code-editing-agent
go mod init agent
touch main.go

現在,開啟 main.go,第一步先在裏面放入所需內容的骨架:

package main

import (
	"bufio"
	"context"
	"fmt"
	"os"

	"github.com/anthropics/anthropic-sdk-go"
)

func main() {
	client := anthropic.NewClient()

	scanner := bufio.NewScanner(os.Stdin)
	getUserMessage := func() (string, bool) {
		if !scanner.Scan() {
			return "", false
		}
		return scanner.Text(), true
	}

	agent := NewAgent(&client, getUserMessage)
	err := agent.Run(context.TODO())
	if err != nil {
		fmt.Printf("Error: %s\n", err.Error())
	}
}

func NewAgent(client *anthropic.Client, getUserMessage func() (string, bool)) *Agent {
	return &Agent{
		client:         client,
		getUserMessage: getUserMessage,
	}
}

type Agent struct {
	client         *anthropic.Client
	getUserMessage func() (string, bool)
}

沒錯,這還不能編譯。不過,我們現在有一個 Agent,它可以存取 anthropic.Client(預設會尋找 ANTHROPIC_API_KEY),而且可以從終端機的 stdin 讀取用戶訊息。

現在加入缺少的 Run() 方法:

// main.go

func (a *Agent) Run(ctx context.Context) error {
	conversation := []anthropic.MessageParam{}

	fmt.Println("Chat with Claude (use 'ctrl-c' to quit)")

	for {
		fmt.Print("\\u001b[94mYou\\u001b[0m: ")
		userInput, ok := a.getUserMessage()
		if !ok {
			break
		}

		userMessage := anthropic.NewUserMessage(anthropic.NewTextBlock(userInput))
		conversation = append(conversation, userMessage)

		message, err := a.runInference(ctx, conversation)
		if err != nil {
			return err
		}
		conversation = append(conversation, message.ToParam())

		for _, content := range message.Content {
			switch content.Type {
			case "text":
				fmt.Printf("\\u001b[93mClaude\\u001b[0m: %s\n", content.Text)
			}
		}
	}

	return nil
}

func (a *Agent) runInference(ctx context.Context, conversation []anthropic.MessageParam) (*anthropic.Message, error) {
	message, err := a.client.Messages.New(ctx, anthropic.MessageNewParams{
		Model:     anthropic.ModelClaude3_7SonnetLatest,
		MaxTokens: int64(1024),
		Messages:  conversation,
	})
	return message, err
}

不算多,對吧?90 行,而其中最重要的部分,就是 Run() 裏這個讓我們與 Claude 對話的循環。不過,這已經是這個程式的心跳。

至於這個心跳,運作方式相當簡單:我們先顯示提示,請用戶輸入內容,把訊息加入對話,傳送給 Claude,再把 Claude 的回覆加入對話,顯示回覆,然後不斷循環。

這就是你用過的每款 AI 聊天應用程式,只不過它是在終端機裏運作。

我們來執行它:

export ANTHROPIC_API_KEY="this is the last time i will tell you to set this"

# Download the dependencies
go mod tidy
# Run it
go run main.go

接着,你就可以像這樣跟 Claude 對話:

$ go run main.go

與 Claude 對話(輸入 'ctrl-c' 結束)

你:嗨!我是 Thorsten!你最近怎樣?

Claude:你好,Thorsten!我很好,謝謝你問候。很高興認識你。你今天過得怎樣?有甚麼我可以幫忙嗎?

你:你能想出一些跟馬有關、可以取笑我名字的綽號嗎?

Claude:我可以試着根據「Thorsten」想出一些跟馬有關、帶點玩笑意味的綽號: * Thorough-bred Thorsten * Trotsten * Thorsten the Stallion * Neighsten * Horseten * Thorsten the Galloper * Saddle-sten * Thorsten of the Mane * Canter-sten * Thorsteed 這些綽號只是想帶來輕鬆的笑意,希望能逗你一笑!

你:

留意我們如何在多個回合中延續同一段對話。Claude 記得我在第一則訊息中提過的名字。每個回合之後,conversation 都會變長,而我們每次都會傳送整段對話。伺服器——也就是 Anthropic 的伺服器——是無狀態的。它只會看到 conversation 片段中的內容。維持這段對話的工作就由我們負責。

好,繼續吧,因為這些暱稱很糟糕,而且這還未算是一個 Agent。甚麼是 Agent?以下是我的定義:一個能夠使用工具的 LLM,讓它可以修改上下文視窗以外的內容。

第一個工具

一個能夠使用工具的 LLM?甚麼是工具?基本概念是這樣:你向模型傳送提示詞,告訴它如果想使用「工具」,就要以特定方式回覆。然後,你作為訊息的接收者,就透過執行「工具」並回覆結果來「使用工具」。就是這樣。我們接下來會看到的其他內容,都只是在這個基礎上加一層抽象。

想像一下,你正在跟朋友交談,並告訴他:「接下來的對話中,如果你想讓我舉起手臂,就眨眨眼。」這話説起來有點奇怪,但概念很容易理解。

我們現在就可以試試,不用改動任何程式碼。

$ go run main.go

與 Claude 對話(按 'ctrl-c' 結束)

你:你是一位天氣專家。當我詢問某個地點的天氣時,我希望你以 `get_weather(<location_name>)` 回覆。之後我會告訴你該地點的天氣狀況。明白嗎?

Claude:我明白你的指示。當你詢問特定地點的天氣時,我會以 `get_weather(<location_name>)` 回覆。然後你會告訴我該地點的天氣資訊,我可以再和你討論。我已準備好,隨時可以回答你對任何地方天氣的提問。

你:嘿,慕尼黑的天氣怎樣?

Claude:get_weather(Munich)

我們告訴 Claude,當它想知道天氣時,就用 get_weather 眨眼。下一步是舉起手臂,並回覆「工具的結果」:

你:炎熱潮濕,28 攝氏度

Claude:多謝你提供這些資訊。慕尼黑目前天氣炎熱潮濕,氣温為 28 攝氏度(約 82 華氏度)。對慕尼黑而言,這算是相當温暖的天氣;加上濕度較高,體感温度可能會比實際氣温更高。 如果你身在慕尼黑或正計劃前往,最好補充水分、穿著輕便衣物,並考慮在一天中最熱的時段安排室內活動。炎熱潮濕的天氣可能相當令人不適,尤其是對不習慣這種天氣的人來説。 你想知道其他地方的天氣嗎?

一次就成功了,效果很好,對吧?

這些模型經過訓練和微調,能夠使用「工具」,而且非常樂於這樣做。到了 2025 年,它們某程度上已「知道」自己並非無所不知,並可以使用工具取得更多資訊。(當然,實際情況並不完全是這樣,但暫時這樣解釋已經足夠。)

總括而言,工具和工具的使用只涉及兩件事:

  1. 你告訴模型有哪些工具可用
  2. 模型想執行工具時,會告訴你;你執行工具,再把回應傳回模型

為了更容易做到(1),大型模型供應商已建立內置 API,讓你一併傳送工具定義。

好,現在來建立我們的第一個工具:read_file

read_file 工具

要定義 read_file 工具,我們會使用 Anthropic SDK 建議的類型,但請記住:在底層,這些內容最終都會變成傳送給模型的字串。整個機制就只是「如果你想讓我使用 read_file,就眨眼」。

我們要加入的每個工具都需要以下內容:

  • 一個名稱
  • 用來向模型説明工具的功能、何時應使用或不應使用、會回傳甚麼等資訊的描述
  • 一份輸入結構描述,以 JSON Schema 格式説明此工具預期接收哪些輸入,以及各輸入的格式
  • 一個函式,會使用模型傳給我們的輸入實際執行工具,並回傳結果

現在把它加入程式碼:

// main.go

type ToolDefinition struct {
	Name        string                         `json:"name"`
	Description string                         `json:"description"`
	InputSchema anthropic.ToolInputSchemaParam `json:"input_schema"`
	Function    func(input json.RawMessage) (string, error)
}

現在提供我們的 Agent 工具定義:

// main.go

// `tools` is added here:
type Agent struct {
	client         *anthropic.Client
	getUserMessage func() (string, bool)
	tools          []ToolDefinition
}

// And here:
func NewAgent(
	client *anthropic.Client,
	getUserMessage func() (string, bool),
	tools []ToolDefinition,
) *Agent {
	return &Agent{
		client:         client,
		getUserMessage: getUserMessage,
		tools:          tools,
	}
}

// And here:
func main() {
    // [... previous code ...]
	tools := []ToolDefinition{}
	agent := NewAgent(&client, getUserMessage, tools)

    // [... previous code ...]
}

再透過 runInference 將它們傳給模型:

// main.go

func (a *Agent) runInference(ctx context.Context, conversation []anthropic.MessageParam) (*anthropic.Message, error) {
	anthropicTools := []anthropic.ToolUnionParam{}
	for _, tool := range a.tools {
		anthropicTools = append(anthropicTools, anthropic.ToolUnionParam{
			OfTool: &anthropic.ToolParam{
				Name:        tool.Name,
				Description: anthropic.String(tool.Description),
				InputSchema: tool.InputSchema,
			},
		})
	}

	message, err := a.client.Messages.New(ctx, anthropic.MessageNewParams{
		Model:     anthropic.ModelClaude3_7SonnetLatest,
		MaxTokens: int64(1024),
		Messages:  conversation,
		Tools:     anthropicTools,
	})
	return message, err
}

這裏有不少型別方面的複雜操作,而我對 Go 泛型還不太熟,所以不打算向你解釋 anthropic.String 和 ToolUnionParam。不過,我保證,真的很簡單:

我們會一併傳送工具定義;在伺服器端,Anthropic 會把這些定義包裝在這個系統提示詞中(內容不多),再將它加入我們的 conversation。如果模型想使用該工具,就會以特定方式回覆。

好,工具定義已經一併傳送,但我們還未定義工具。現在就來定義 read_file:

// main.go

var ReadFileDefinition = ToolDefinition{
	Name:        "read_file",
	Description: "Read the contents of a given relative file path. Use this when you want to see what's inside a file. Do not use this with directory names.",
	InputSchema: ReadFileInputSchema,
	Function:    ReadFile,
}

type ReadFileInput struct {
	Path string `json:"path" jsonschema_description:"The relative path of a file in the working directory."`
}

var ReadFileInputSchema = GenerateSchema[ReadFileInput]()

func ReadFile(input json.RawMessage) (string, error) {
	readFileInput := ReadFileInput{}
	err := json.Unmarshal(input, &readFileInput)
	if err != nil {
		panic(err)
	}

	content, err := os.ReadFile(readFileInput.Path)
	if err != nil {
		return "", err
	}
	return string(content), nil
}

func GenerateSchema[T any]() anthropic.ToolInputSchemaParam {
	reflector := jsonschema.Reflector{
		AllowAdditionalProperties: false,
		DoNotReference:            true,
	}
	var v T

	schema := reflector.Reflect(v)

	return anthropic.ToolInputSchemaParam{
		Properties: schema.Properties,
	}
}

內容不多,對吧?它只有一個函式 ReadFile,以及模型會看到的兩段描述:我們的 Description 用來描述工具本身("Read the contents of a given relative file path. ..."),另一段則描述這個工具唯一的輸入參數("The relative path of a ...")。

ReadFileInputSchema 和 GenerateSchema 那些東西?我們需要它們來為工具定義產生 JSON Schema,然後傳給模型。為此,我們會使用 jsonschema 套件,因此需要先匯入並下載:

// main.go

package main

import (
	"bufio"
	"context"
    // Add this:
	"encoding/json"
	"fmt"
	"os"

	"github.com/anthropics/anthropic-sdk-go"
    // Add this:
	"github.com/invopop/jsonschema"
)

然後執行以下指令:

go mod tidy

接着,在 main 函式中,我們要確保使用這個定義:

func main() {
    // [... previous code ...]
	tools := []ToolDefinition{ReadFileDefinition}
    // [... previous code ...]
}

是時候試試了!

$ go run main.go

與 Claude 對話(使用 'ctrl-c' 離開)

你:main.go 裏有甚麼?

Claude:我會幫你查看 main.go 檔案的內容。我來讀給你聽。

你:

等等,甚麼?呵,呵,呵,它想使用工具!你的輸出當然會略有不同,但聽起來 Claude 確實知道自己可以讀取檔案,對吧?

問題是我們沒有聽!Claude 眨眼示意時,我們卻置之不理。我們得修正這點。

讓我示範如何用一個簡單、快速,而且以我這把年紀來説出奇敏捷的動作做到這點:把我們的 Agent 的 Run 方法替換成以下內容:

// main.go

func (a *Agent) Run(ctx context.Context) error {
	conversation := []anthropic.MessageParam{}

	fmt.Println("Chat with Claude (use 'ctrl-c' to quit)")

	readUserInput := true
	for {
		if readUserInput {
			fmt.Print("\\u001b[94mYou\\u001b[0m: ")
			userInput, ok := a.getUserMessage()
			if !ok {
				break
			}

			userMessage := anthropic.NewUserMessage(anthropic.NewTextBlock(userInput))
			conversation = append(conversation, userMessage)
		}

		message, err := a.runInference(ctx, conversation)
		if err != nil {
			return err
		}
		conversation = append(conversation, message.ToParam())

		toolResults := []anthropic.ContentBlockParamUnion{}
		for _, content := range message.Content {
			switch content.Type {
			case "text":
				fmt.Printf("\\u001b[93mClaude\\u001b[0m: %s\n", content.Text)
			case "tool_use":
				result := a.executeTool(content.ID, content.Name, content.Input)
				toolResults = append(toolResults, result)
			}
		}
		if len(toolResults) == 0 {
			readUserInput = true
			continue
		}
		readUserInput = false
		conversation = append(conversation, anthropic.NewUserMessage(toolResults...))
	}

	return nil
}

func (a *Agent) executeTool(id, name string, input json.RawMessage) anthropic.ContentBlockParamUnion {
	var toolDef ToolDefinition
	var found bool
	for _, tool := range a.tools {
		if tool.Name == name {
			toolDef = tool
			found = true
			break
		}
	}
	if !found {
		return anthropic.NewToolResultBlock(id, "tool not found", true)
	}

	fmt.Printf("\\u001b[92mtool\\u001b[0m: %s(%s)\n", name, input)
	response, err := toolDef.Function(input)
	if err != nil {
		return anthropic.NewToolResultBlock(id, err.Error(), true)
	}
	return anthropic.NewToolResultBlock(id, response, false)
}

眯起眼仔細看,就會發現九成是樣板程式碼,只有一成是重點:收到 Claude 傳回的 message 時,我們會查看是否有 content.Type == "tool_use",以判斷 Claude 是否要求我們執行工具;如果有,就交由 executeTool 處理,按名稱在本機註冊清單中查找工具、反序列化輸入、執行工具並回傳結果。如果出錯,就切換一個布林值。就這樣。

(沒錯,雖然有一個迴圈套着另一個迴圈,但這不重要。)

我們執行工具,把結果傳回 Claude,再次詢問 Claude 的回覆。真的,就是這樣。我示範給你看。

準備好後,執行:

echo 'what animal is the most disagreeable because it always says neigh?' >> secret-file.txt

這會在我們的目錄中建立一個 secret-file.txt,裏面有一道神秘謎題。

現在就在同一個目錄中執行這個可以使用工具的新 Agent,並叫它查看檔案:

$ go run main.go

與 Claude 對話(使用 'ctrl-c' 離開)

你:Claude,老友,幫我解開 secret-file.txt 檔案裏的謎題

Claude:我會幫你解開 secret-file.txt 檔案裏的謎題。我先讀取檔案內容,看看謎題是甚麼。

工具: read_file({"path":"secret-file.txt"})

Claude:太好了!我找到這個謎語了。 謎底是:**一匹馬** 這個謎語運用了雙關語:「neigh」(馬發出的叫聲)聽起來跟「nay」(表示「不」或反對的説法)相似。因此,謎語説馬總是唱反調,因為牠們總是説「neigh/nay」,暗示牠們總是在反對別人。

你:

我們先深呼吸,然後一起説。準備好了嗎?來吧:我靠。你只要給它一個工具,而它……在認為有助於完成任務時就會使用該工具。記住:我們沒有説過任何關於「如果用戶問你某個檔案的事,就讀取該檔案」的話。我們也沒有説「如果某樣東西看起來像檔名,就想辦法讀取它」。不,完全沒有。我們只説「幫我解決這個檔案中的問題」,Claude 就會想到可以讀取檔案來回答,然後便開始處理。

當然,我們可以講得具體些,並大力引導它使用某個工具,但基本上它會自行完成所有事情:

$ go run main.go

與 Claude 對話(輸入 'ctrl-c' 退出)

你:main.go 裏發生了甚麼事?簡短回答!

Claude:我會查看 main.go 檔案,瞭解其中的內容。

tool:read_file({"path":"main.go"})

Claude:根據我的檢視,main.go 實作了一個能使用工具的 Claude AI 助手 Agent。簡要概述如下: - 使用 Anthropic Go SDK 建立與 Claude 對話的命令列介面 - 實作工具系統,其中只有一個用來讀取檔案內容的「read_file」工具 - 管理與 Claude 的對話流程,處理一般文字回應和工具使用請求 - Claude 要求使用工具時,Agent 會執行該工具並返回結果 - 程式會持續循環以維持對話,直到用戶退出 簡而言之,這段程式碼建立了一個簡單的 CLI 聊天機械人,Claude 提出要求時,它便能與檔案系統互動。

你:

完全正確。好,現在我們知道如何讓 Claude 使用工具,就再加幾個。

list_files 工具

如果你跟我一樣,登入新電腦後第一件事就是執行 ls — 列出檔案,瞭解一下目前的環境。

讓 Claude 也具備同樣的能力,加入一個列出檔案的工具。以下是 list_files 工具的完整實作:

// main.go

var ListFilesDefinition = ToolDefinition{
	Name:        "list_files",
	Description: "List files and directories at a given path. If no path is provided, lists files in the current directory.",
	InputSchema: ListFilesInputSchema,
	Function:    ListFiles,
}

type ListFilesInput struct {
	Path string `json:"path,omitempty" jsonschema_description:"Optional relative path to list files from. Defaults to current directory if not provided."`
}

var ListFilesInputSchema = GenerateSchema[ListFilesInput]()

func ListFiles(input json.RawMessage) (string, error) {
	listFilesInput := ListFilesInput{}
	err := json.Unmarshal(input, &listFilesInput)
	if err != nil {
		panic(err)
	}

	dir := "."
	if listFilesInput.Path != "" {
		dir = listFilesInput.Path
	}

	var files []string
	err = filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		relPath, err := filepath.Rel(dir, path)
		if err != nil {
			return err
		}

		if relPath != "." {
			if info.IsDir() {
				files = append(files, relPath+"/")
			} else {
				files = append(files, relPath)
			}
		}
		return nil
	})

	if err != nil {
		return "", err
	}

	result, err := json.Marshal(files)
	if err != nil {
		return "", err
	}

	return string(result), nil
}

這裏沒有甚麼花巧之處:list_files 會返回目前資料夾中的檔案和目錄清單。如果這是認真的專案,我們還可以(而且大概應該)進行一大堆優化;不過我只是想展示魔術師帽子裏有甚麼,所以這樣已經足夠。

有一點要注意:我們返回字串清單,並在目錄名稱末尾加上斜線。這並非必要,只是我自行決定這樣做。格式沒有固定要求,只要 Claude 能理解,任何格式都可以。至於它是否能理解,則需要透過實驗找出答案。你也可以在每個目錄前加上 "directory: ",或返回一份包含兩個標題的 Markdown 文件:"directories" 和 "files"。選擇很多,取決於哪種格式最容易讓 Claude 理解、需要多少 token、生成和讀取的速度等。

在這裏,我們只想建立一個小型 list_files 工具,所以最簡單的做法就是最佳選擇。

當然,我們也要告訴 Claude list_files 是甚麼:

// main.go

func main() {
	// [... previous code ...]

	tools := []ToolDefinition{ReadFileDefinition, ListFilesDefinition}

	// [... previous code ...]
}

就這樣。問問 Claude 在這個目錄中看到了甚麼。

$ go run main.go

與 Claude 對話(輸入 'ctrl-c' 退出)

你:你在這個目錄中看到甚麼?

Claude:我來幫你查看目前目錄中的內容。我會列出檔案和目錄。

工具:list_files({})

Claude:我在目前目錄中看到幾個檔案和目錄: 1. 與 Git 相關的檔案和目錄: - `.git/` 目錄,內有各種 Git 設定和追蹤檔案 - `.gitignore` 檔案 2. Go 專案檔案: - `main.go` - Go 主要原始程式碼檔案 - `go.mod` - Go 模組定義檔案 - `go.sum` - Go 模組校驗和檔案 3. 文件: - `blogpost.md` - Markdown 檔案,可能載有網誌內容 4. 環境設定: - `.envrc` - 可能是環境設定檔案 你想我查看這份清單中的哪個特定檔案嗎?

你:

成功!它可以讀取目錄。

但關鍵是:Claude 知道如何組合這些工具。我們只需要用能促使它這樣做的方式提示它:

$ go run main.go

與 Claude 對話(使用 'ctrl-c' 退出)

你:簡短介紹一下這裏所有的 Go 檔案!

Claude:我來查看目前目錄中的 Go 檔案。首先讓我看看有哪些檔案。

工具:list_files({})

Claude:我在目前目錄中找到一個 Go 檔案。讓我查看一下:

工具:read_file({"path":"main.go"})

工具:read_file({"path":"go.mod"})

Claude:以下簡要介紹這個專案中的 Go 檔案: **main.go**: - 實作一個 Claude AI Agent,可與本機檔案系統互動 - 使用 Anthropic 的 Go SDK 與 Claude AI 模型通訊 - 提供兩種工具:`read_file` 和 `list_files`,讓 Claude 讀取檔案內容及列出目錄內容 - 管理用戶與 Claude 之間的對話流程,並在 Claude 需要存取檔案時處理工具執行 **go.mod**: - 定義模組依賴項目 - 主要依賴項目是 Anthropic 的 Go SDK 和一個 JSON schema 程式庫 - 使用 Go 1.24.1 這看來是一個簡單的終端機應用程式,讓用戶可以與 Claude 對話,同時讓 AI 讀取本機檔案及列出目錄。

你:

它先使用了 list_files,然後用與 Go 相關、而且是我問到的檔案呼叫了 read_file 兩次。

就……就跟我們會做的一樣,對吧?我的意思是,如果我問你這個專案使用哪個版本的 Go,你會怎樣做?以下是 Claude 為我做的事:

$ go run main.go

與 Claude 對話(使用 'ctrl-c' 退出)

你:這個專案使用哪個版本的 Go?

Claude:我來幫你找出這個專案使用的 Go 版本。我會查看檔案,找出可能註明 Go 版本的位置。

工具:list_files({})

Claude:我看到這裏是一個 Go 專案,有幾個重要檔案,例如 `go.mod`、`go.sum` 和 `main.go`。我先查看 `go.mod` 檔案,因為 Go 版本通常會在這裏註明。

工具:read_file({"path":"go.mod"})

Claude:根據 `go.mod` 檔案,這個專案使用 Go 1.24.1。

Claude 查看目錄,再查看 go.mod,便得出答案。

目前程式碼大約有190行。好好消化一下。消化完之後,我們再加入另一個工具。

讓它 edit_file

我們要加入的最後一個工具是 edit_file — 一個讓 Claude 編輯檔案的工具。

你現在大概會想:「我的天,這就是真正考驗開始的地方,也就是他要變出兔子的時候。」好吧,我們來看看?

首先,為新的 edit_file 工具加入定義:

// main.go

var EditFileDefinition = ToolDefinition{
	Name: "edit_file",
	Description: `Make edits to a text file.

Replaces 'old_str' with 'new_str' in the given file. 'old_str' and 'new_str' MUST be different from each other.

If the file specified with path doesn't exist, it will be created.
`,
	InputSchema: EditFileInputSchema,
	Function:    EditFile,
}

type EditFileInput struct {
	Path   string `json:"path" jsonschema_description:"The path to the file"`
	OldStr string `json:"old_str" jsonschema_description:"Text to search for - must match exactly and must only have one match exactly"`
	NewStr string `json:"new_str" jsonschema_description:"Text to replace old_str with"`
}

var EditFileInputSchema = GenerateSchema[EditFileInput]()

沒錯,我又知道你在想甚麼:「用字串取代來編輯 檔案?」Claude 3.7 很喜歡取代字串(要了解它們喜歡甚麼或不喜歡甚麼,就得透過實驗),所以我們會透過告訴 Claude 可以用新文字取代現有文字來編輯檔案,從而實作 edit_file。

以下是 EditFile 函式的 Go 實作:

func EditFile(input json.RawMessage) (string, error) {
	editFileInput := EditFileInput{}
	err := json.Unmarshal(input, &editFileInput)
	if err != nil {
		return "", err
	}

	if editFileInput.Path == "" || editFileInput.OldStr == editFileInput.NewStr {
		return "", fmt.Errorf("invalid input parameters")
	}

	content, err := os.ReadFile(editFileInput.Path)
	if err != nil {
		if os.IsNotExist(err) && editFileInput.OldStr == "" {
			return createNewFile(editFileInput.Path, editFileInput.NewStr)
		}
		return "", err
	}

	oldContent := string(content)
	newContent := strings.Replace(oldContent, editFileInput.OldStr, editFileInput.NewStr, -1)

	if oldContent == newContent && editFileInput.OldStr != "" {
		return "", fmt.Errorf("old_str not found in file")
	}

	err = os.WriteFile(editFileInput.Path, []byte(newContent), 0644)
	if err != nil {
		return "", err
	}

	return "OK", nil
}

它會檢查輸入參數、讀取檔案(或在檔案已存在時建立檔案),並以 NewStr 取代 OldStr。然後,它會將內容寫回磁碟,並傳回 "OK"。

還欠缺的是 createNewFile,這只是一個小型輔助函式;如果不是用 Go 寫的話,程式碼可以短70%:

func createNewFile(filePath, content string) (string, error) {
	dir := path.Dir(filePath)
	if dir != "." {
		err := os.MkdirAll(dir, 0755)
		if err != nil {
			return "", fmt.Errorf("failed to create directory: %w", err)
		}
	}

	err := os.WriteFile(filePath, []byte(content), 0644)
	if err != nil {
		return "", fmt.Errorf("failed to create file: %w", err)
	}

	return fmt.Sprintf("Successfully created file %s", filePath), nil
}

最後一步:將它加入我們傳送給 Claude 的工具清單。

// main.go

func main() {
	// [... previous code ...]

	tools := []ToolDefinition{ReadFileDefinition, ListFilesDefinition, EditFileDefinition}

	// [... previous code ...]
}

然後……我們準備好了,不過你準備好了嗎?你準備好放手一試了嗎?

我就知道。來吧,告訴 Claude 用 JavaScript 建立一個新的 FizzBuzz 函式。

$ go run main.go

與 Claude 聊天(使用 'ctrl-c' 結束)

你:嘿,Claude,建立 fizzbuzz.js,讓我可以用 Nodejs 執行,而且檔案內要有並執行 FizzBuzz

Claude:我會建立一個可用 Node.js 執行的 fizzbuzz.js 檔案。首先,我來檢查這個檔案是否已存在:

工具:list_files({})

Claude:我找不到 fizzbuzz.js 檔案,所以會建立一個包含經典 FizzBuzz 實作的檔案。這個程式會輸出1至100的數字;但遇到3的倍數時會輸出「Fizz」,遇到5的倍數時會輸出「Buzz」,而遇到同時是3和5的倍數時則會輸出「FizzBuzz」。

工具:edit_file({"path":"fizzbuzz.js","old_str":"","new_str":"/**\n * FizzBuzz implementation in JavaScript\n * Prints numbers from 1 to 100, but:\n * - For multiples of 3, print \"Fizz\" instead of the number\n * - For multiples of 5, print \"Buzz\" instead of the number\n * - For multiples of both 3 and 5, print \"FizzBuzz\"\n */\n\nfunction fizzBuzz(n) {\n for (let i = 1; i <= n; i++) {\n let output = '';\n \n if (i % 3 === 0) output += 'Fizz';\n if (i % 5 === 0) output += 'Buzz';\n \n console.log(output || i);\n }\n}\n\n// Execute FizzBuzz for numbers 1 to 100\nconsole.log('Running FizzBuzz:');\nfizzBuzz(100);"}

Claude:我已建立可用 Node.js 執行的 fizzbuzz.js 檔案。這個程式: 1. 定義一個名為 `fizzBuzz` 的函式,接受參數 `n` 作為上限 2. 從1迴圈至 n(執行時設定為100) 3. 對每個數字: - 如果可以被3整除,就在輸出中加入「Fizz」 - 如果可以被5整除,就在輸出中加入「Buzz」 - 如果同時可以被3和5整除,就同時加入兩者,組成「FizzBuzz」 - 如果不能被3或5整除,就輸出數字本身 4. 指令碼會自動執行函式,處理1至100的數字 你可以在終端機中使用以下指令,透過 Node.js 執行這個指令碼: node fizzbuzz.js 這會在你的主控台輸出1至100的 FizzBuzz 數列。

對吧?!很厲害,對不對?而這大概就是你能想到的最基本 edit_file 實作——一般 Agent 的最基本實作。

但它有成功嗎?有,成功了:

$ node fizzbuzz.js
Running FizzBuzz:
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
[...]

太厲害了。不過,讓我們試試叫它真正編輯檔案,而不只是建立檔案。

以下是我請 Claude「請編輯 fizzbuzz.js,讓它只輸出至 15」時,它的做法:

$ go run main.go

與 Claude 對話(使用 'ctrl-c' 離開)

你:請編輯 fizzbuzz.js,讓它只輸出至 15

Claude:我會編輯 fizzbuzz.js 檔案,將輸出上限改為 15。首先,讓我查看檔案目前的內容,瞭解需要作出哪些修改。

tool:read_file({"path":"fizzbuzz.js"})

Claude:我看到檔案目前會執行 FizzBuzz 至 100。我會修改 fizzBuzz 函式呼叫中的參數,將上限改為 15。

tool:edit_file({"path":"fizzbuzz.js","old_str":"// Execute FizzBuzz for numbers 1 to 100\nconsole.log('Running FizzBuzz:');\nfizzBuzz(100);","new_str":"// Execute FizzBuzz for numbers 1 to 15\nconsole.log('Running FizzBuzz:');\nfizzBuzz(15);"})

Claude:我還需要更新檔案頂部的註解,以反映這項修改:

tool:edit_file({"path":"fizzbuzz.js","old_str":"/**\n * FizzBuzz implementation in JavaScript\n * Prints numbers from 1 to 100, but:","new_str":"/**\n * FizzBuzz implementation in JavaScript\n * Prints numbers from 1 to 15, but:"})

Claude:已成功修改 fizzbuzz.js 檔案。程式現在會: 1. 只輸出 1 至 15 的 FizzBuzz(而非 1 至 100) 2. 更新説明文件以反映這項修改 函式本身維持不變,因為它會透過參數設定上限;我們只是將該參數由 100 改為 15。

它會讀取檔案,編輯檔案以改變程式執行至哪個數字,而且還會編輯檔案,更新頂部的註解。

而且仍然可以正常運作:

$ node fizzbuzz.js
Running FizzBuzz:
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz

好,再試一次,請它完成以下工作:

建立一個 congrats.js 指令碼,對以下字串進行 ROT13 解碼並輸出:‘Pbatenghyngvbaf ba ohvyqvat n pbqr-rqvgvat ntrag!’

這個要求可能有點高。看看吧:

$ go run main.go

與 Claude 對話(使用 'ctrl-c' 離開)

你:建立一個 congrats.js 指令碼,對以下字串進行 ROT13 解碼並輸出:'Pbatenghyngvbaf ba ohvyqvat n pbqr-rqvgvat ntrag!'

Claude:我會建立一個 congrats.js 指令碼,解碼 ROT13 編碼的字串並將結果輸出。ROT13 是一種簡單的字母替換密碼,會把字母替換成字母表中其後第 13 個字母。 讓我為你建立這個檔案:

tool: edit_file({"path":"congrats.js","old_str":"","new_str":"/**\n * A script to decode a ROT13-encoded string and print the result\n */\n\nfunction rot13Decode(encodedStr) {\n return encodedStr.replace(/[a-zA-Z]/g, function(char) {\n // Get the character code\n const charCode = char.charCodeAt(0);\n \n // Handle uppercase letters\n if (charCode >= 65 && charCode <= 90) {\n return String.fromCharCode(((charCode - 65 + 13) % 26) + 65);\n }\n \n // Handle lowercase letters\n if (charCode >= 97 && charCode <= 122) {\n return String.fromCharCode(((charCode - 97 + 13) % 26) + 97);\n }\n \n // Return non-alphabetic characters as is\n return char;\n });\n}\n\nconst encodedMessage = 'Pbatenghyngvbaf ba ohvyqvat n pbqr-rqvgvat ntrag!';\nconst decodedMessage = rot13Decode(encodedMessage);\n\nconsole.log(decodedMessage);"})

Claude: 我已建立一個名為 congrats.js 的 JavaScript 檔案,當中: 1. 定義 `rot13Decode` 函數,接收一個已編碼字串,並套用 ROT13 密碼進行解碼 2. 使用提供的字串 'Pbatenghyngvbaf ba ohvyqvat n pbqr-rqvgvat ntrag!' 3. 使用該函數解碼 4. 將解碼後的訊息輸出至主控台 你可以在終端機輸入 `node congrats.js`,使用 Node.js 執行此指令碼。指令碼會解碼並顯示隱藏的祝賀訊息!

它行得通嗎?試試看:

$ node congrats.js
Congratulations on building a code-editing agent!

成功了!

這不是很神奇嗎?

如果你跟我過去幾個月談過的所有工程師一樣,很可能你讀到這裏時,一直在等我把兔子從帽子裏變出來,等我説:「嗯,實際上事情要困難得多得多。」但事實並非如此。

這基本上就是程式碼編輯 Agent 內部循環的全部內容。當然,要把它整合到編輯器、調整系統提示詞、在適當時候給它適當的回饋、為它設計出色的使用者介面、為各種工具打造更完善的配套工具、支援多個 Agent 等等——我們已經在 Amp 裏完成了所有這些工作,但這並不需要靈光一閃。所需的只是實際的工程技術和埋頭苦幹。

這些模型現在的能力非常強大。只需 300 行程式碼和三個工具,你現在就能跟一個會編輯你程式碼的外星智慧對話。如果你心想「嗯,但我們其實沒有真的……」——就去試試看!看看用這個方法能做到甚麼程度。我敢説,你能做到的遠比你想像中多。

這就是我們認為一切正在改變的原因。

來源:Amp Chronicle · ampcode.com