跳转至

Go 与 AI 辅助开发 — 这门语言为什么值得学,AI 工具摆在什么位置

这一章讲两件事: Go 是什么、它为什么成了云时代后端的首选语言; 以及这本书全程要用的三个 AI 助手——ChatGPT、GitHub Copilot、Amazon Q Developer—— 分别擅长什么、怎么安装配置。 它在全书链条里的位置: 后面九章沿着同一条主线走—— 先把 Go 的语言机制一层层讲透(第 02–05 章),再用这些机制搭真实的后端系统 (数据库、API、并发流水线、部署),AI 辅助是贯穿全程的辅线, 这一章先把辅线的工具摆好。读完你会拿到判断后面每一章「该不该听 AI 的」的基准。

1. 顶层全景:一门语言加三个助手

这一章的全部内容可以画成一张图:

  左侧:一门语言                          右侧:三个 AI 助手
  ┌──────────────────────┐              ┌────────────────────────┐
  │ Go(2007 年,Google)   │   开发者     │ ChatGPT    —— 对话式   │
  │  · 编译成机器码        │ ◄─────────► │ Copilot    —— 编辑器内   │
  │  · 自带并发(goroutine)│   写代码、   │ Amazon Q   —— 云生态内   │
  │  · 自动内存管理(GC)   │   问问题     └────────────────────────┘
  │  · 丰富标准库          │                分工:写、问、查
  └──────────────────────┘
  图说:左半边是「用什么造系统」,右半边是「造的时候谁搭把手」。
  原书反复强调:右边的三个是助手,拿主意的永远是人。[^1]

「拿主意的永远是人」不是客套话,是这本书的方法论。后面九章里,每一章的 AI 部分都在回答同一个问题:这一步把什么交给 AI、把什么留在自己手里。这一章先把三个助手的能力边界画出来。

主线例子(贯穿本章): 假想一个刚装好电脑的开发者,目标是跑通第一个 Go 程序, 然后让 AI 帮她写第一段并发代码。每一步都给出具体的命令和输出,

  ① 下载安装包、解开、配 PATH ──► ② go version 看到版本号 ──► ③ 写 5 行 Hello World 跑通
  ──► ④ 打开 ChatGPT,要一段并发计数器代码 ──► ⑤ 拷进编辑器,go run 跑通 ──► ⑥ 逐行核对 AI 写了什么

②③⑤ 三步的原书依据在脚注里;④⑥ 两步的做法按原书第 1、9 章的口径演示(演示里 AI 的回答是我们编的,不是真实模型输出)。

2. 核心原理:Go 为什么是这样一门语言

2.1 先看现象:云时代的后端几乎被它包圆了

你可能没写过 Go,但你每天都在用它写的软件:容器引擎 Docker、容器编排的 Kubernetes、 基础设施工具 Terraform、监控系统 Prometheus,全是 Go 写的2。 这不是巧合——这几样东西的共同点是:长驻后台、同时要处理大量网络请求、出错就得自己撑着。

原书给出的答案是:Go 在 2007 年由 Google 的 Robert Griesemer、Rob Pike 和 Ken Thompson 设计, 目标一句话就能说清——用接近脚本的简单写法,写出接近 C 的运行速度3。 「脚本语言」指 Python 这类写完直接跑、语法轻量的语言;「C」这里代表编译成机器码、跑得快的那一类。 传统的困境是二者只能取其一:写得快的跑不快,跑得快的写不快。Go 想两头都要。

它靠四样东西做到。下面四样一样一节,每节回答「它解决了什么老问题」。

2.2 编译与静态类型:把错拦在跑起来之前

解决什么问题: 脚本语言(如 Python)的报错常在运行到那一行才蹦出来—— 线上跑了三天,才在某个用户请求上炸一个「把字符串当数字用了」的错。

Go 的做法: 整个程序先编译——一次性翻译成机器码,跑之前就有个完整检查; 每个变量都带类型声明(这行管静态类型,含义:变量是数字还是字符串,写代码时就说死, 编译器逐个核对)4。类型对不上,编译直接失败,根本轮不到上线。

为什么有效: 检查从「运行中随机触发」前移到「每次保存代码时必触发」。 代价是写的时候多敲几个字——Go 的作者认为这个代价值,因为后端系统的故障大头是这类低级错。

2.3 goroutine 与 channel:把「同时做很多事」变成语言内置

解决什么问题: 一个后端服务要同时接待成千上万个请求。传统做法是给每个请求开一个线程—— 线程是操作系统提供的执行单位,问题在于它很重:开太多会把内存吃光,开少了又接待不过来, 而且多个线程改同一个变量时极易出诡异错误(竞态,含义:两个执行流抢着改同一份数据, 结果取决于谁手快,每次跑可能不一样)。

Go 的做法: 语言内置一个轻得多的执行单位,叫 goroutine(中文常直接叫 goroutine, 你可以把它理解成「由 Go 自己调度的微线程」)。开一个 goroutine 只要在调用前加 go 关键字, 内存开销小到可以同时开成千上万个;调度由 Go 的运行时自己管,不依赖操作系统5。

goroutine 之间传数据走 channel(含义:一条有类型的传送带,一个 goroutine 往这头放、 另一个从那头取)。原书强调的口径是:用传消息代替共享变量—— 两个人不抢同一个本子,而是互相递纸条,抢数据的竞态从根上变难发生5。

这两样东西第 05 章从头细讲,这里只记住:并发不是 Go 的一个库,是这门语言自带的语法级能力, 这正是它适合做网络服务的原因。

2.4 垃圾回收(GC):内存自己收拾

解决什么问题: C/C++ 里你申请的每块内存都要手动还,忘了还就是内存泄漏—— 服务跑得越久内存越大,最后整台机器被拖垮;还早了更糟,程序直接崩。

Go 的做法: 内置垃圾回收(GC,Garbage Collector)——运行时会自动认出 「这块内存以后再也用不到了」并回收,程序员不用手动还6。

为什么有效、代价是什么: 自动回收消灭了泄漏的一大半来源; 代价是回收本身要占 CPU、偶尔让程序停顿几十到几百毫秒(这叫停顿,第 10 章讲怎么调)。 对网络服务来说,这个代价比人工管理内存便宜得多——这是 2.1 节那几个软件都选它的原因之一。

2.5 标准库与工具链:能不加依赖就不加

解决什么问题: 很多语言的项目依赖几十个第三方包,其中一个 abandoned(无人维护)或 带安全漏洞,整个项目就被拖下水。

Go 的做法: 官方标准库覆盖极宽——文件读写、网络、加密、HTTP 服务器、格式化输出全都有7。 这一章举的「最少 Go 程序」三行里就有两行是标准库。配套工具也是官方的:gofmt 统一所有人的 代码格式、go test 跑测试、go vet 查可疑写法。一个团队写出来的 Go 代码长得差不多, 这是它被大型基础设施项目接受的隐性原因。

边界: 第 2.3 节提到的 Web 框架 Gin、Fiber 说明生态里也有第三方框架8; 原书的选择是尽量用标准库,框架的好处与代价第 07 章再权衡。

2.8 和其他语言摆在一起看(原书的对照口径)

原书通篇拿 Go 和主流语言对照,收成一张表:

维度 C/C++ Java Python Go
内存 手动,泄漏/野指针自负 GC 引用计数+GC GC,但强调少分配
并发 线程+锁,一切自己扛 线程+锁+并发包 GIL 限制,多进程绕开 goroutine+channel,语法级
部署 编译,但依赖系统库 虚拟机+运行时 解释器或打包工具 单静态二进制,拷走就跑
类型 弱,可隐式转 强,泛型成熟 动态 强,不隐式转,泛型克制
学习曲线的形状 坑在深处处 概念多(模式、框架) 入门快、大型项目难收 语法一周,纪律一月

这张表的最后两行是原书没明说但贯穿全书的判断:Go 把「程序员容易犯的错」 (隐式转换、忘记释放、共享内存)尽量挪给编译器和运行时,代价是写起来 「啰嗦」——if err != nil 的重复就是这张表的直接后果。

3. 主线例子(上):从零到第一个程序

下面把第 1 节的 ①②③ 走完。命令照原书第 1 章的安装步骤;当前的具体版本号随时间变, 本节里的版本号以原书印刷时为准,装的时候去官网取最新。

① 安装。 三个系统殊途同归,都是「下载 → 放进固定目录 → 把目录加进 PATH」:

系统 关键动作 验证命令
Linux 下载 go1.25.4.linux-amd64.tar.gz,删旧目录 /usr/local/go 再解开新包到 /usr/local go version
macOS 下载安装包,双击按提示装 go version
Windows 下载 MSI 安装包,双击装 go version

PATH 是操作系统找命令的目录清单;把 /usr/local/go/bin 加进去,终端才敲得到 go 这个命令9。

② 验证。 终端里敲:

$ go version
go version go1.25.4 linux/amd64

看到一行带版本号的输出,说明装好了10。(这行输出是按原书版本号演示的;你的版本号会更新。)

③ 第一个程序。 建一个文件 main.go,内容照原书11:

package main

import "fmt"

func main() {
    fmt.Println("Hello, Readers!")
}

三行骨架各管一件事:package main 声明这是可执行程序(包,含义:一组一起编译的代码文件, 第 03 章细讲);import "fmt" 引入标准库的格式化输出包;func main() 是入口—— 程序从这里开始跑。然后:

$ go run main.go
Hello, Readers!

走到这一步,左侧那门语言已经能用了。接下来看右侧三个助手。

4. 核心原理:三个 AI 助手,三种分工

4.1 它们共同靠什么工作

这三个工具底下是同一类东西:大语言模型(LLM,Large Language Model—— 在巨量文本和代码上训练出来的「续写机器」,本库另一本《这就是 ChatGPT》讲透了它的原理)。 它们不是搜索引擎,不是规则引擎——是模式识别器:「看过海量代码之后,这个位置大概率该写什么」。 这一句是第 9 章全部提示技巧的根:它们不读心,只能从你给的文字里猜意图12。

4.2 ChatGPT:对话式的「问与答」

OpenAI 出的对话工具。用法是像聊天一样打字:「帮我写一个读文件的 Go 函数」 「这段报错是什么意思」。它适合做解释、设计讨论、整段代码的生成13。

主线例子的第 ④ 步用它。我们在对话框里输入(演示提示,非原书原文):

用 Go 写一个并发计数器:10 个 goroutine 各自把一个共享计数器加 1000 次, 用 WaitGroup 等待全部完成,打印最终结果。解释为什么需要加锁。

(WaitGroup、加锁是第 05 章的词,这里先不展开——主线例子走到第 ⑤ 步只需要会粘会跑。)

4.3 GitHub Copilot:编辑器里的「边写边补」

装在 VS Code、GoLand 这类 IDE(集成开发环境,就是你写代码的那个编辑器)里的插件, 底层是 OpenAI 的 Codex 模型。它不等你问——你打着字,它把后面几行猜出来,按一下 Tab 就采纳14。

它擅长的场景:重复性的结构(循环、结构体、函数模板)、照着上下文补全测试、 给一个陌生标准库函数的用法示例。原书特别强调它「模型可选」—— 用户可以挑用哪个模型来出建议15。

4.4 Amazon Q Developer(原 CodeWhisperer):云生态里的「贴身向导」

AWS 出的助手,前身叫 CodeWhisperer,现已并入 Amazon Q Developer。 它的差异化位置:和 AWS 服务绑在一起——你写调用 S3(对象存储)、Lambda(按需跑函数的 云服务)、DynamoDB(NoSQL 数据库)的代码时,它能给出针对这些服务的写法建议和安全检查16。

三个助手不是三选一,是各管一段:

你想干什么 找谁 为什么
讨论设计、解释报错、要整段代码 ChatGPT 对话式,上下文给多少你说了算
减少敲重复代码、边写边学 Copilot 在编辑器里,不打断手头的活
代码要跑在 AWS 上 Amazon Q 懂 AWS 服务的细节

4.5 装进编辑器,再调一调

安装路径都很短:Copilot 在 VS Code 的扩展市场搜官方账号发布的那个装上; Amazon Q 走 AWS Toolkit 扩展,也有命令行装法(brew install --cask amazon-q,Mac 上一条命令)17。 装完要认证——登录 GitHub / AWS / OpenAI 账号,工具才能调远端模型18。

配置这一层值得停一下,因为原书点到的几个参数直接影响输出质量:

参数 管什么 这本书里的用法
temperature(温度) 输出的随机程度:低 = 稳,高 = 花样多 要代码时调低,要方案 brainstorm 时调高
context length(上下文长度) 一次能「看到」多少字 贴代码别只贴报错,上下文越全建议越准
隐私/数据设置 你公司的代码会不会被拿去训练 企业环境必须查这一项

(温度的含义与机制,本库《这就是 ChatGPT》第 01 章有完整讲解;这里只按原书的用法带过。) API 方式接 ChatGPT 时这些参数都能调;用网页版时它们藏在背后,由产品默认值替你选好了19。

4.6 装好之后的第一个小时(原书步骤串起来)

环境装完到写出第一行代码之间,原书散在三个工具里的步骤可以串成一张清单:

  ① go version 看到版本号          ── 装好了
  ② go env GOPATH 看到路径          ── 知道东西装在哪(可选,排障用)
  ③ VS Code 装三个扩展:Go(官方)、GitHub Copilot、Amazon Q
  ④ 编辑器里登录:GitHub 账号(Copilot)/ AWS 账号(Q)
  ⑤ 打开 Copilot 设置,确认建议频率、遥测/隐私选项
  ⑥ 新建 main.go,确认保存时自动 gofmt(改一行格式乱的代码,存盘即对齐)
  ⑦ 打开 ChatGPT,问一个你真不懂的问题,验证整条链路通

几个值得停一下的细节:

  • 认证是工具生效的前提。 Copilot 不登录 GitHub 就只会沉默;Amazon Q 同理走 AWS。 企业账号还可能带组织级策略(哪些仓库允许发送、日志留存多久),入职第一周就该问清。
  • gofmt 是「存盘即发生」的。 如果你存盘后格式没变,是编辑器没配好,不是 gofmt 坏了—— 这是新手最容易误会的点。
  • 隐私选项默认未必如你所愿。 原书只一句带过「adjust privacy or data usage parameters」, 但公司代码能不能被发去训练,是入职第一天就该确认的事,默认开着的日子一去不复返。

4.7 三个特性的数字感(补第 2 节的台阶)

第 2 节说的并发、内存管理、可扩展性是定性的,这里给一组数量感 (以下数字为演示性参照,非原书原值;原书只给了方向没给数字):

  • goroutine 栈起步 几 KB,OS 线程栈以 MB 计——差三个数量级, 所以「一万并发连接」在 Go 里是一万 goroutine,在线程模型里是一万 MB = 10GB,开不起;
  • GC 停顿原书第 10 章才展开(0.2–0.5% 停顿),第 1 章只要记住: 回收自动,但分配不是免费的;
  • 可扩展性「从几个请求到几百万并发操作」(原书第 1 章原话的方向)靠的就是前两样加起来。

5. 主线例子(下):AI 写的代码,要自己核一遍

回到主线例子的最后两步。

⑤ 跑通。 把 ChatGPT 给的并发计数器存成 counter.go,跑:

$ go run counter.go
10000

10 个 goroutine × 每个加 1000 次 = 10000——数对不上就是有 bug。

⑥ 核对(这一步是原书全部 AI 内容的隐含前提)。 对着代码逐行问三个问题:

  1. 它引了什么包、开了几个 goroutine?——和提示里的要求数一遍;
  2. 它用了什么同步手段(WaitGroup?锁?)——这个机制我认不认识?不认识就去问它「这行是干嘛的」;
  3. 我能不能改动它——改动的前提是看懂了。

三个问题答不上来,这段代码就是黑箱;黑箱进生产,坏的时候你不知道为什么坏。 这一章没有明写这三问,但第 9 章的「AI 生成代码的质量保证」一节把同一要求说得很直白; 我们把核对的关口前移到这里20。

6. 作者的判断与证据

这一章是导论,断言多于论证。把「书里给过证据的」和「作者直接断言的」分开:

有行业事实作底的:

  • Go 被 Docker/Kubernetes/Terraform/Prometheus 采用——这是可查证的事实,原书列举为「业界采用证明了实用性」2。证据强度:硬。
  • 三个 AI 助手的能力描述(补全、解释、安全建议)——2026 年的产品现状,可上手验证1316。

作者直接断言、本章未给证据的:

  • 「AI 增强而非替代开发者」「提高生产力、减少认知负荷」——原书反复陈述,但没有给出量化数据 (比如「快了多少」)1。这是行业通行的乐观叙述,不是测量结论。
  • 「AI 建议符合惯用的 Go 写法」——实际取决于模型版本和你给的上下文,原书没讨论会建议错的场景 (第 9 章才补上这一半)。

判断(我们的,不是书里的): 这一章真正的价值不在 Go 介绍(任何入门书都有), 而在它把 AI 工具明确定位为辅线:后面九章每次 AI 出场,都是「人先懂机制,AI 再提效」的顺序。 这个顺序是对的——Go 的坑(并发竞态、接口 nil 值)恰恰是最容易被 AI 一本正经建议错的领域。 如果错,会错在: 如果读者真把 AI 当「会用 Go 的外包」,跳过 02–05 章的机制直接让 AI 写系统, 那么辅线变主线,这本书的价值就没了——这是读法问题,不是书写错。

7. 边界与局限

  • 安装步骤会过期。 具体版本号、下载地址、产品名(CodeWhisperer 已改名 Amazon Q Developer) 都以原书印刷时为准,动手时以官网为准。这类时效内容是工具书的通病,不影响机制部分。
  • 三个工具的介绍是产品快照。 界面、价格、模型选项到 2026 年中可能已变;不变的是三分类 (对话式 / 编辑器内 / 云生态内)和「大语言模型不读心」这条根。
  • 「好处」一节是单向的。 风险(幻觉代码、许可证、隐私)要到第 9 章才系统讲; 读第 1 章时别把「好处」当完整图景。
  • 没有深入 Go 本身。 语言机制从第 02 章才开始,这一章只是告诉你「这门语言值得你花九chapter」。

8. 可带走的

  1. Go 的定位一句话: 用写脚本的简单度,写出接近 C 的速度——靠编译+静态类型、 goroutine/channel、垃圾回收、厚标准库这四样,云时代基础设施(Docker、Kubernetes、 Terraform、Prometheus)因此选它。
  2. goroutine 是语法级能力,不是库:go 关键字一开就开,channel 传消息代替抢共享变量。 这是它和「线程+锁」路线的本质区别。
  3. 三个 AI 助手按场景分工,不是三选一: ChatGPT 对话、Copilot 边写边补、Amazon Q 贴身云生态。
  4. 安装三系统归一: 下载 → 固定目录 → PATH → go version 验证;版本号以官网当下为准。
  5. LLM 不读心——后面九章所有「怎么向 AI 描述需求」的技巧,都建立在这一句上。
  6. AI 给的代码三个核对问题: 引了什么开了几个、同步手段认不认识、能不能改。答不上来就是黑箱。
  7. temperature、上下文长度、隐私设置是三个值得动手调的配置项,尤其公司代码要先查清隐私项。

9. 原文地图

主题 原书章 原文位置
Go 的诞生与定位 1. Introduction to Go and AI-Assisted Development text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:30(搜「Every few years」)
goroutine 与 channel 初介绍 同上 text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:80(搜「lightweight threads」)
垃圾回收 同上 text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:94(搜「risk of memory leaks」)
可扩展性与业界采用 同上 text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:53(搜「Docker」)与text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:104(搜「Scalability」)
三系统安装步骤 同上 text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:124(搜「For Linux machines」)
go version 验证 同上 text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:136(搜「Verify the installation」)
最少 Go 程序 同上 text/12-ch02-2-go-syntax-variables-and-data-types.txt:65(搜「Hello, Readers」)
三个 AI 助手分工 同上 text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:186(搜「conversational AI model」)、text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:202(搜「pair programmer」)、:218(搜「CodeWhisperer」)
安装与配置(含 amazon-q) 同上 text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:241(搜「Installing and Configuring」)
temperature / context length 同上 text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:275(搜「temperature」)
AI 的六项好处 同上 text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:287(搜「Enhanced Productivity」)
「AI 增强而非替代」立场 同上 text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:173(搜「supplant」)

  1. 出处:「1. Introduction to Go and AI-Assisted Development」第 173 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:173,搜「supplant」)。原文:「AI-driven development is not intended to supplant programmers—it rather aims to enhance their capabilities.」 ↩

  2. 出处:同章第 53 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:53,搜「Docker」)。原文列举 Docker、Kubernetes、Terraform、Prometheus 为 Go 的业界采用案例。 ↩↩

  3. 出处:同章第 30–35 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:30,搜「Every few years」;text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:32,搜「Robert Griesemer」)。原书称 Go 「combines the speed and efficiency of low-level languages such as C with the simplicity and readability of higher-level scripting languages」。 ↩

  4. 出处:同章第 39 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:39,搜「static typing」)。原文:「Its static typing and memory safety features reduce common programming errors, while its built-in garbage collector ensures efficient memory management.」 ↩

  5. 出处:同章第 75–84 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:76,搜「Built-in concurrency support」;text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:80,搜「lightweight threads」)。goroutine 由 Go 运行时管理、用 go 关键字创建;channel「facilitate communication and synchronization」。 ↩↩

  6. 出处:同章第 94 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:94,搜「risk of memory leaks」)。原文:「The GC automatically allocates and frees memory, reducing the risk of memory leaks」。 ↩

  7. 出处:同章第 47 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:47,搜「rich standard library」)。原书列举文件 I/O、网络、加密、格式化等。 ↩

  8. 出处:同章第 113 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:113,搜「Gin and Fiber」)。 ↩

  9. 出处:同章第 123–138 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:124,搜「For Linux machines」;text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:133,搜「PATH」)。 ↩

  10. 出处:同章第 137 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:137,搜「command prompt」)。原书把 go version 列为安装验证命令。 ↩

  11. 出处:同章第 65 段(text/12-ch02-2-go-syntax-variables-and-data-types.txt:65,搜「Hello, Readers」)。这是原书第一个完整程序示例,三要素:包声明、import、main 函数。 ↩

  12. 出处:同章第 168 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:168,搜「Large Language Models」)。原文:「these technologies employ Large Language Models (LLMs) and machine learning algorithms trained on massive volumes of programming data」。「模式识别器、不读心」的完整论证见原书第 9 章第 74 段(text/19-ch09-9-integrating-ai-tools-in-go-development.txt:74,搜「pattern recognizers」)。 ↩

  13. 出处:同章第 186–198 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:186,搜「ChatGPT, developed by OpenAI」;text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:192,搜「Generate Go functions」)。 ↩↩

  14. 出处:同章第 201 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:201,搜「Codex」)。原文:「GitHub Copilot, powered by OpenAI's Codex model, functions as an AI pair programmer within popular IDEs」。 ↩

  15. 出处:同章第 215 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:215,搜「model」)。 ↩

  16. 出处:同章第 219–230 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:219,搜「AWS CodeWhisperer」;text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:225,搜「optimized for AWS services」)。 ↩↩

  17. 出处:同章第 261–265 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:261,搜「command-line」;text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:265,搜「brew install」)。 ↩

  18. 出处:同章第 252 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:252,搜「authentication」)。 ↩

  19. 出处:同章第 272–277 段(text/11-ch01-1-introduction-to-go-and-ai-assisted-development.txt:275,搜「temperature」)。「温度的机制」属书外内容,依据我们的姐妹库《这就是 ChatGPT》第 01 章的拆解(此处按书库规矩以正文说明带过,不引外部网址)。 ↩

  20. 出处:「9. Integrating AI Tools in Go Development」(text/19-ch09-9-integrating-ai-tools-in-go-development.txt,搜「Quality Assurance for AI-Generated Go Code」)。三问是我们把第 9 章质量保证一节的要点前移;AI 风险(幻觉、许可证)在同章第 49 节起系统讨论(同文件,搜「Hallucinations」)。 ↩