# AI Engineering Skills Map: Using coding agents
**作者**: Andrew Ng
**日期**: 2026-09-04T15:02:37.000Z
**来源**: [https://x.com/AndrewYNg/status/2095890279865721217](https://x.com/AndrewYNg/status/2095890279865721217)
---
A key AI engineering skill is using coding agents. Your skill at steering them both to write code and to carry out non-code tasks, such as analyzing data or managing system operations, allows you to get a lot more done.
The rapid pace of evolution for coding agents means this skill, too, is evolving rapidly — faster than other top-level AI engineering skills. Proprietary agents (like Claude Code, Codex, and Cursor) and open agents (like OpenCode and Pi) progress in strides via both harness and model improvements. So keeping up with how to use coding agents requires a continuous process of experimentation, building, and learning.
In interviewing dozens of top AI Engineers and reflecting on our own team’s use of coding agents, we found a consistent high-level workflow for building software with them. The key steps are:
- Planning. This includes (i) brainstorming, which may include research, experimentation, and understanding the existing codebase (if any) and (ii) writing a spec that captures requirements, technical design, and architecture, followed by generating an execution plan. You might also review the plan to interrogate key assumptions and check for security, overengineering, and other gaps.
- Execution, where you build, test, and verify, with the right balance between agent autonomy and human oversight. This involves (i) having the agent build the software, with a calibrated level of agent autonomy and (ii) verifying its output via automated and/or human checks.
- Deployment and monitoring, in which you (i) deploy, perhaps gated with a CI/CD pipeline or additional human gates, and (ii) use agents to watch logs, surface issues, and propose and execute improvements.
This high-level workflow is similar to the one typically used to build software before coding agents. Now, we focus much less on code and instead focus on deciding what to build, designing the architecture, writing the spec, and verifying outputs.
The duration of each step can vary significantly between projects, and steps can be omitted. For example, the spec for a greenfield (meaning built-from-scratch) prototype might be loosely described in a quickly written prompt, whereas the spec for a brownfield (pre-existing) project with many users might require much more effort to write and verify. Further, the workflow is highly iterative, and skilled developers know when feedback from a later step should lead them back to an earlier one. For example, if verification fails, they know how to steer the agent to rebuild and fix errors; or if monitoring surfaces issues, how to have agents update the system and redeploy.
To use coding agents effectively in this workflow, the key skills are:
- Directing the workflow
- Enabling agent autonomy
- Reviewing the work
- Customizing the agent and its environment
- Coding agent foundations
Directing the workflow. You know how to navigate each step of the workflow above. This involves deciding how much human and how much agent effort to spend on each and when to go back to an earlier step to iterate. It requires deeply understanding the tradeoffs of speed, cost, technical risk, and human effort, so you can decide how much to research and plan up front, when to retain human ownership over critical work, how to choose the architecture, how much detail to write into a set of planning artifacts (like a spec), and how to decompose the work into verifiable steps.
Enabling agent autonomy. When applying a coding agent to the steps in the workflow, you choose the autonomy level: Do you watch it and go back-and-forth interactively or delegate a larger chunk of work to it? And when do you set a clear goal and have it loop until it succeeds? Additionally, you have to manage the context carefully for the agent. As the build proceeds through different phases, you will calibrate when to make sure key learnings, user feedback, and assumptions — including assumptions that changed partway through the build — are captured for the agent to use downstream. Additionally, you will decide when to set up many agents to run in parallel on a decomposition of the task — either by having a human or a higher-level agent orchestrate these other agents — and how to manage human attention across concurrent agent sessions. You also know how to run agents safely, setting permissions and gating actions appropriately to let development proceed quickly while limiting the risk of leaks, data loss, or other damage.
Reviewing the work. The output of a coding agent is uncertain. We don’t know in advance what good ideas it might come up with and what bugs it will implement. Reviewing and verifying the output is a key step to ensure you are getting the result you want and to redirect the agent if not. You will design testing and validation that is matched to the task, applying both behavioral and functional verification as needed. You might also test user flows, perhaps having an agent provide screenshots as evidence of success or failure. For qualitative/behavioral evaluation, eval sets, perhaps with LLM-as-a-judge, can be used.
You also need to decide how much of these tests should be automated. Some workflows will have all testing and validation fully automated so the agent can check its work and know when it has succeeded in completing a task. You have to evaluate the tests to ensure they correspond to your aims, and you will evolve them if not. Additionally, you use agentic code review and run AI-enabled security and architecture audits. When AI review isn’t sufficient, you judiciously insert human reviews of the code behavior (and, infrequently, of code as well) while exploring how to automate this review further. Finally, you verify deployment and can operationalize monitoring and incident management with agents.
Customizing the agent and its environment. Your ability to update both the agent and the environment it works in allows your agents to efficiently get the context they need, access tools, and build correctly and efficiently. You know how to integrate agent skills, plugins, and MCP servers. Occasionally you will prune them when they are no longer necessary (such as when a new model obviates an old skill). You can use hooks to automate repeatable parts of the development process, like triggering automated code reviews or CI/CD pipelines. You can also maintain the environment the agent works in: updating the standing context (such as AGENTS.md or CLAUDE.md) with information on the codebase, key architectural assumptions, code style, and data access patterns. You know how to preserve state across multiple sessions and across parallel agents, and accumulate agent learnings over time, perhaps by running post-run retrospectives to capture what did and did not work. You also know how to set up consistent conventions and structure to make your codebase navigable to the agent, and how to occasionally clear out agent-generated debt. When you work in a team, you consider how to coordinate context across different developers’ agents.
Coding agent foundations. Finally, to make good decisions throughout, you have a good understanding of how coding agents work: how they carry out codebase search/retrieval, how they manage their context windows, how different operations (like adding tool calls, MCP servers, etc.) affect context, how agents and subagents interact, and how the agent is built by wrapping a harness around an LLM. This makes the agent less of a black box and helps you to recognize failure modes, such as overengineering a simple solution, losing rigor because the agent lacks an explicit verification process, stopping short of the goal, or agent actions that risk destruction of files or production data. It also helps you reason about the agent’s state and steer it by giving it the right prescription or context. And when monitoring a run, this understanding allows you to better spot when the agent goes off-track and requires your intervention.
I find that social media often gives oversimplified descriptions of how to use coding agents. For example, it is sometimes useful to get agents to run autonomously for hours and burn millions or tens of millions of tokens. But currently the practical utility of very long-horizon tasks — especially relative to their cost — has been amplified beyond reality. Instead, most effective coding agent use is a complex, highly iterative process, and being able to intervene with high-skill judgement gives much better results.
Your skill at using coding agents will make you an effective builder. This positions you to also steer the overall build. I will say more about this in a future article.
## 相关链接
- [Andrew Ng](https://x.com/AndrewYNg)
- [@AndrewYNg](https://x.com/AndrewYNg)
- [403K](https://x.com/AndrewYNg/status/2095890279865721217/analytics)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [11:02 PM · Sep 4, 2026](https://x.com/AndrewYNg/status/2095890279865721217)
- [403.4K Views](https://x.com/AndrewYNg/status/2095890279865721217/analytics)
- [View quotes](https://x.com/AndrewYNg/status/2095890279865721217/quotes)
---
*导出时间: 2026/9/5 16:25:35*
---
## 中文翻译
# AI 工程技能图谱：使用编码智能体
**作者**： Andrew Ng
**日期**: 2026-09-04T15:02:37.000Z
**来源**: [https://x.com/AndrewYNg/status/2095890279865721217](https://x.com/AndrewYNg/status/2095890279865721217)
---
一项关键的 AI 工程技能是使用编码智能体。你引导它们编写代码以及执行非代码任务（例如分析数据或管理系统运维）的能力，能让你完成多得多的工作。
编码智能体的快速演进意味着这项技能本身也在快速演化——比其他顶层 AI 工程技能更快。专有智能体（如 Claude Code、Codex 和 Cursor）和开放智能体（如 OpenCode 和 Pi）通过框架和模型的双重改进大步前进。因此，跟上编码智能体的使用方法需要持续不断地实验、构建和学习。
在访谈了数十位顶尖 AI 工程师并反思我们自己团队对编码智能体的使用之后，我们发现了一套一致的、使用编码智能体构建软件的高层工作流。关键步骤包括：
- 规划。包括 (i) 头脑风暴，其中可能包含调研、实验，以及理解现有代码库（如果有的话）；以及 (ii) 编写一份涵盖需求、技术设计和架构的规格说明，然后生成执行计划。你还可以审阅该计划，审视关键假设，并检查安全性、过度工程化等问题和其他缺口。
- 执行，即在智能体自主性与人类监督之间取得恰当的平衡，进行构建、测试和验证。这包括 (i) 让智能体构建软件，并校准其自主性水平；以及 (ii) 通过自动化和/或人工检查来验证其输出。
- 部署与监控，其中你 (i) 进行部署，可能通过 CI/CD 流水线或额外的人工关卡加以把关；(ii) 使用智能体监控日志、发现暴露问题，并提出并执行改进。
这一高层工作流与编码智能体出现之前构建软件时常用的流程类似。如今，我们把注意力更多地从代码本身移开，转而专注于决定构建什么、设计架构、编写规格说明以及验证输出。
每个步骤的持续时间在不同项目之间可能差异很大，某些步骤也可以省略。例如，一个绿地（从零开始构建）原型的规格说明可能只是一段快速写就的提示词，而一个有众多用户的棕地（已有代码基础）项目的规格说明则可能需要多得多的精力去编写和验证。此外，这个工作流高度迭代，熟练的开发者知道什么时候后续步骤的反馈应当让他们回到先前的步骤。例如，当验证失败时，他们知道如何引导智能体重新构建并修复错误；或者当监控暴露出问题时，知道如何让智能体更新系统并重新部署。
要在这个工作流中有效使用编码智能体，关键技能包括：
- 引导工作流
- 赋予智能体自主性
- 审查工作成果
- 定制智能体及其环境
- 编码智能体基础知识
引导工作流。你知道如何驾驭上述工作流的每个步骤。这包括决定每个步骤中投入多少人类工作、多少智能体工作，以及何时返回先前的步骤进行迭代。它要求你深刻理解速度、成本、技术风险和人力投入之间的权衡，从而决定前期要做多少调研和规划、何时对关键工作保持人类的掌控权、如何选择架构、在规划产物（如规格说明）中写入多少细节，以及如何把工作分解为可验证的步骤。
赋予智能体自主性。在将编码智能体应用于工作流的各步骤时，你需要选择自主性水平：你是盯着它进行交互式的来回协作，还是把一大块工作委派给它？什么时候你设定一个清晰的目标并让它循环执行直至成功？此外，你必须为智能体精心管理上下文。随着构建经历不同阶段，你需要校准何时确保把关键经验、用户反馈和假设——包括构建过程中途发生变化的假设——记录下来，供智能体在后续阶段使用。此外，你还要决定何时设置多个智能体并行处理任务的分解——要么由人类编排这些智能体，要么由更高层的智能体来编排——以及如何在并发的智能体会话之间管理人类的注意力。你还知道如何安全地运行智能体，恰当地设置权限和对操作设限，让开发快速推进的同时限制泄露、数据丢失或其他损害的风险。
审查工作成果。编码智能体的输出是不确定的。我们事先无法知道它会想出哪些好点子、又会引入哪些 bug。审查和验证输出是确保你得到想要的结果的关键步骤，否则就要重新引导智能体。你会设计与任务相匹配的测试和验证，按需同时应用行为验证和功能验证。你也可以测试用户流程，或许让智能体提供截图作为成功或失败的证据。对于定性/行为评估，可以使用评估集，或许配合“LLM 作为评判者”。
你还需要决定这些测试中有多少应当自动化。有些工作流会把所有测试和验证完全自动化，这样智能体可以检查自己的工作并知道何时成功完成了任务。你必须评估这些测试是否与你的目标相符，如果不符就要对它们进行演进。此外，你可以使用智能体代码审查，并运行 AI 驱动的安全和架构审计。当 AI 审查不够充分时，你要审慎地插入人工审查（审查代码行为，偶尔也审查代码本身），同时探索如何进一步将这类审查自动化。最后，你要验证部署，并可以用智能体实现监控和事件管理的运维化。
定制智能体及其环境。你更新智能体及其工作环境的能力，能让你的智能体高效获取所需上下文、访问工具，并正确高效地进行构建。你知道如何集成智能体技能、插件和 MCP 服务器。当它们不再必要时（例如新模型使某个旧技能过时），你也会不时将其裁剪。你可以使用钩子来自动化开发过程中可重复的部分，例如触发自动化代码审查或 CI/CD 流水线。你还可以维护智能体工作的环境：用关于代码库、关键架构假设、代码风格和数据访问模式的信息来更新常驻上下文（如 AGENTS.md 或 CLAUDE.md）。你知道如何在多个会话和并行智能体之间保持状态，并随时间累积智能体的经验，或许通过运行后的复盘来记录什么有效、什么无效。你还知道如何建立一致的约定和结构，让智能体能够方便地浏览你的代码库，以及如何不时清理智能体产生的技术债。在团队协作时，你会考虑如何在不同开发者的智能体之间协调上下文。
编码智能体基础知识。最后，为了在整个过程中做出好的决策，你需要深入理解编码智能体的工作原理：它们如何进行代码库搜索/检索，如何管理上下文窗口，不同操作（如添加工具调用、MCP 服务器等）如何影响上下文，智能体与子智能体之间如何交互，以及智能体是如何通过在 LLM 外包裹一个框架而构建的。这让智能体不再是一个黑箱，帮助你识别失败模式，例如把简单的方案过度工程化、因为缺乏明确的验证流程而失去严谨性、未达目标就停止，或者存在破坏文件或生产数据风险的智能体操作。这也有助于你对智能体的状态进行推理，并通过给出正确的指示或上下文来引导它。而在监控运行时，这种理解让你能更好地发现智能体何时偏离轨道、需要你的干预。
我发现社交媒体上关于如何使用编码智能体的描述常常过于简化。例如，让智能体自主运行数小时、消耗数百万甚至数千万 token 有时确实有用。但目前，超长周期任务的实际效用——尤其是相对于其成本而言——被夸大到了超越现实的地步。实际上，最有效的编码智能体使用是一个复杂且高度迭代的过程，能够以高水平的判断力进行干预会带来好得多的结果。
你使用编码智能体的技能将使你成为一名高效的构建者。这也为你驾驭整体构建奠定了基础。我会在未来的文章中进一步阐述这一点。
## 相关链接
- [Andrew Ng](https://x.com/AndrewYNg)
- [@AndrewYNg](https://x.com/AndrewYNg)
- [403K](https://x.com/AndrewYNg/status/2095890279865721217/analytics)
- [升级到 Premium](https://x.com/i/premium_sign_up)
- [2026年9月4日 晚上11:02](https://x.com/AndrewYNg/status/2095890279865721217)
- [40.34万次浏览](https://x.com/AndrewYNg/status/2095890279865721217/analytics)
- [查看引用](https://x.com/AndrewYNg/status/2095890279865721217/quotes)
---
*导出时间： 2026/9/5 16:25:35* 
