# A Practical Guide to Becoming an AI-Native Engineer
**作者**: Bytebytego
**日期**: 2026-06-02T14:46:18.000Z
**来源**: [https://x.com/bytebytego/status/2061821715450351992](https://x.com/bytebytego/status/2061821715450351992)
---
If AI writing everything is the answer, then why are most engineering teams shipping more bugs, more incidents, and more technical debt than they shipped two years ago?
That's where this week's guest post starts, and it turns into one of the most practical guides we've seen for engineers trying to actually level up in the AI era.
A Practical Guide to Becoming an AI-Native Engineer, by Shah Rahman, Global Head of Autonomous ML Iteration & Optimization for Ads at Meta.
AI generates more than 75% of Google’s new code. OpenAI and Anthropic claim that almost every line of fresh code that they produce comes from AI. Amazon recently migrated 30,000 of its production applications from Java 8 to Java 17 in a matter of months, a project that would otherwise have taken an estimated 4,500 developer-years. And Mark Zuckerberg expects that AI agents will be operating as mid-level engineers by the end of 2026.
Reading those statements, we may feel as if we are looking at the last lines being written on the closing pages of an era. Perhaps even the closing pages of a profession.
But here’s the question: If AI writing everything is the answer, then why are most engineering teams shipping more bugs, more incidents, and more technical debt than they shipped two years ago?
In an April article in the New York Times, Mike Isaac and Erin Griffith gave a name to describe what's happening across the industry. They called it code overload.
The essence of code overload, according to Isaac and Griffith, is that “tech workers are producing so much code so quickly that it has become too much to handle.” Teams that have rebuilt their work around the use of AI agents are drowning in code churn and security holes.
But. Many engineers who have employed AI agents are pulling ahead of the field, achieving real productivity gains. They are using the same models and the same tools, but they are generating very different outcomes. What explains the gap?
It comes down to one decision. Real productivity gains come when engineers decide to make the leap from writing code to orchestrating it. This piece is a working guide for engineers who want to land on the productive side of that split. It will cover the practices, guardrails, and mindset shifts that separate AI-native engineering from vibe coding and from the everyday chaos that most teams are now generating at scale.
# From Engineer to Orchestrator
Let me first clarify one thing: engineers are not becoming obsolete. Coding has always been a small part of engineering (20-30% max). This underappreciated reality is more visible when AI agents and tools produce more code, but more code is not necessarily more productive (often it’s less). This is a critical distinction that the industry is blurring dangerously, and I state that as:
When Andrej Karpathy coined "vibe coding" in early 2025, it captured something useful — the ability for non-engineers to build functional software by describing what they want. That democratization is valuable. But it's categorically different from professional AI-native engineering.
AI-native engineering means commanding and mastering available and emerging AI agents and tools to engineer things that weren't possible in the pre-AI era. Knowing how to code remains a fundamental expectation. Without that knowledge, you can build systems using AI — and that's vibe coding. It has its place, but it's not engineering.
The AI-native engineer operates as an orchestrator — someone who can turbocharge 10x engineering into 100x output through proper orchestration of AI agents. And that bar continues to rise weekly.
## The Four Core Practices
1. Synchronized Context Engineering
Emerging as a distinct discipline, this is the single most important skill for AI-native engineers. Context engineering means the systematic curation and injection of project-specific information into AI working memory: architectural diagrams, coding standards, business rules, team conventions, and development workflows that are reusable and standardized across your team members.
This shifts basic "prompt engineering" to sophisticated "context engineering" reflecting a deeper understanding: the quality of AI output is bounded by the quality of context it receives. Teams practicing rigorous context engineering report 40–50% speed increases and dramatically reduced alignment overhead.
As context engineering matures, Anthropic's MCP — described as "USB-C for AI" — continues to be a universal standard for connecting agents to external tools and data sources. Context files like CLAUDE.md have become core infrastructure, not optional documentation. This persistent, evolving knowledge layer makes agents genuinely useful within your specific codebase, once you master developing and maintaining this critical context.
2. Specification-Driven Development
The quality of AI-generated code matches the quality of input specifications. Garbage in, garbage out — this principle applies with even more force when AI can generate garbage at unprecedented speed and volume.
Random prompting and vibe coding consistently underperform spec-driven workflows. AI agents get stuck in circular reasoning without clear specifications and instructions that are contained and well-defined. Consider this discipline: define what you want before asking AI to build it, break problems into discrete milestones with clear success criteria, and execute incrementally with validation at each checkpoint. Make sure the agent checks all open Qs with you and doesn’t run off on its own to find answers.
3. Critical Verification
AI-generated code quality approximates that of early-career developers. Research consistently shows that around 45% of AI-generated code contains security flaws. A Stanford study found that developers using AI assistants wrote significantly less secure code and were more confident it was secure — a dangerous combination.
Meanwhile, a striking METR/Anthropic randomized controlled trial found experienced open-source developers were actually 19% slower when using AI assistants on familiar codebases. The culprit? Over-reliance without adequate verification. A GitClear study found AI-assisted codebases showed increased "code churn" — code written and then quickly revised or deleted — suggesting raw output is a poor proxy for productivity.
In the AI-native era, the bottleneck has permanently shifted from writing code to proving that it works at scale, with reliability and security. When AI generates code quickly, review, testing, and verification of that code become the new rate-limiting factors, and verification now becomes non-negotiable.
4. Problem Decomposition
Avoid over-trusting AI with large, complex problems. Break tasks into AI-manageable chunks where humans handle edge cases, custom logic, and domain-specific aspects while AI agents handle the 70–80% of routine implementation. Complex problems lead to context pollution and slop generation that AI agents really struggle to recover from. Compacting and summarizing when context is polluted and shifting to a different session helps, but this discontinuity can be damaging for long-horizon tasks.. Many of us wasted hours, if not days, due to not decomposing and stubbornly confusing agents about expectations outside of a well-defined context, reasonable specifications, and a lack of verification guardrails.
## Time Allocation for AI-Native Work
I recommend the optimal split of: 40% context-setting, 20% generation and testing iteration, 40% reviewing and verification. This surprises many developers who spend most of their time in code generation. In practice, the generation step is fast; the verification and context work become the new time sink.
# The Individual Transformation Journey
## Phase 1: Foundation — should only take a couple of weeks
Begin with one primary AI assistant — pick your favorite one: Codex, Claude Code, or Cursor. Dive deep and build intuition for its capabilities and limitations through daily practice. Set up your workspace, workflow, and initial configurations. You’ll have to take the leap from the times of manual coding to AI-assisted and AI-generated coding practices. Your goal should be to develop judgment about when AI delivers value versus when it creates more work than it saves. Write down your personal notes, iterate, and build a strong foundation.
## Phase 2: Integration — should take a month max
Adopt structured prompting frameworks. Create project-specific context files encoding team standards and architectural patterns. Implement the "Plan first, then Execute and finally review" workflow: planning mode generates specifications, execution mode implements, and make sure you review after each atomic task. Establish approval gates and guardrails that prevent agent drift. Skipping the review will pile tech debt that you and your agent will both struggle downstream.
The critical practice here is small loops with verification checkpoints. Evidence shows tight human-in-the-loop cycles with limited scope dramatically outperform large autonomous runs, at least for coding tasks. This may feel counterintuitive and slower — but it produces dramatically better outcomes in practice. Indulging into somewhat unplanned and speculative autonomous agent runs will likely produce a large volume of slop whose only destiny may be throwaway and start all over again. Avoid that before it happens.
## Phase 3: Mastery — live on
Deploy AI agents for multi-step, multi-file tasks. Implement AI-assisted code review workflows. Use advanced techniques: multi-agent workflows, parallel sessions, and cross-agent verification loops. Every week, we hear about coding agents advancing on benchmarks and solving problems that were never solved before. Stay on top of those developments and embrace what Claude or Codex inventors are advocating, but adopt those to your needs (don’t blindly follow as their situations may be wildly different than yours).
Target metrics: 80%+ AI-generated coding rate with less than 20% rewrite rate. Achieve this, and you can pull your team toward the same proficiency level rather fast.
# Team Transformation: The Cultural Foundation
Research shows 70% of transformation success comes from operational and cultural change. These changes call for Organizational and technical leads to actively model transformation through daily AI usage. At the same time, ensure three critical aspects to establish the AI-native cultural foundation:
1. Psychological safety is paramount. MIT research found 83% of leaders believe psychological safety measurably improves AI initiative success. Celebrate "AI failure stories" as learning opportunities. Make this deliberate practice, not optional and ensure everyone feels included as part of the collective learning and growing exercise.
2. Evolved code review is essential. AI-generated code volume overwhelms traditional human review processes. Redesign review to distinguish AI-generated versus human code with separate review rubrics. Be especially vigilant about the dangerous combination of AI-generated and AI-reviewed PRs — these combinations should be explicitly guardrailed and governed, when necessary.
3. Shared context libraries become the core currency. Standardize context files, evaluation sets, and agent configurations across teams. Modern tooling enables easy packaging of context through plugins, skills, and commands — but watch for uncontrolled proliferation, where teams compete for standardization rather than collaborating. Don’t let too many team members’ desire to build agents and skills jeopardize your standardized agentic operating environment.
# The Agentic Development Life Cycle (ADLC)
Traditional SDLC — and even extreme agile — falls short for how AI agents develop software alongside humans. AI-native engineering evolution toward an Agentic Development Life Cycle redefines each phase.
## Planning
The most critical step. Use deep research and planning modes with multiple agents for parallel exploration. Specify against codebases, flag ambiguities, decompose into subtasks, and estimate difficulty. Create roadmaps with version milestones that help agents follow through incrementally. A planning agent can assemble findings from multiple exploration agents into a coherent implementation strategy. OpenClaw of Claude can run in multiple sub-agent in parallel.
## Building
AI agents handle end-to-end feature implementation like junior or mid-level engineers (at the time of this writing, which I expect to edge up to senior engineers within a year or two). The engineer acts as the tech lead, orchestrating multiple agents rather than coding directly. Sequential or parallel execution models depend on your roadmap and verification plan. The agentic coding tool landscape has matured rapidly — Claude Code, Cursor's Composer mode, GitHub Copilot's Agent Mode, and OpenAI's Codex agent all support this pattern with varying strengths. There’s new versions coming out every month -- watch closely for new capabilities.
## Testing
This is TDD reincarnated. Agents write test plans first, then implement code. All tests should fail at the beginning and then incrementally pass. Unit testing at the atomic level, integration testing across features, and end-to-end testing across the system. Don’t overindex on unit testing at the expense of integration or system testing lack.
Pro Tip: Consider separating planning, building, and testing agents. Each agent swarm specializes and develops a deep understanding of your codebase from a different perspective. Planning agents can challenge building agents who take shortcuts; testing agents who skip coverage; or the review agents who are biased towards incorrect implementations that appear to be correct. Similarly, review agents can hold every other upstream agent accountable for making mistakes or missing steps.
## Review
Deploy agent swarms specializing in key dimensions: functionality, quality, scalability, performance, reliability, security, and privacy. Agents take the first pass and produce reports; humans review each report carefully. When one agent discovers an issue — say, an injection vulnerability — apply the generalization principle: if one instance exists, others likely do too and this is your chance to proactively similar a vulnerability type in your code, not just one or two instances.
## Documentation
Move from post-facto documentation to continuous generation. AI agents generate summaries, key design decisions, architectural diagrams, and changelogs in real time. This flows naturally into API documentation, feature collaterals, and customer-facing contents. I’m quite excited about AI tools finally solving the outdated, stale, and inconsistent documentation problem that I’ve seen myself and my teams suffer for decades.
## Codify ADLC
Encode your Layer-1 (individual) and Layer-2 (team) practices into maintained, self-evolving context files, skills libraries, and MCP tools. This ensures ADLC adoption scales across the organization rather than remaining tribal knowledge or trapped in parts of the org. Promote the ADLC tooling package.
# What AI-Native Process Actually Looks Like
There's a seductive narrative in the industry right now: fewer people, less overhead, faster builds. But this narrative conflates construction costs with decision costs. AI has drastically reduced the cost of building, but that represents only 20–30% of total development costs, while leaving the cost of deciding what to build and what to cut largely untouched. With the proliferation of code and builders, this becomes a harder problem.
AI-native process optimization requires redirecting effort from coordinating execution to accelerating learning.
## The Learning Loop
AI compresses the first step dramatically. But compression value depends entirely on execution quality throughout the remaining cycle. Faster building without robust user observation and scope discipline produces faster divergence from genuine product goals. This results in customers not seeing the benefits of AI acceleration.
## Where AI Creates Genuine Leverage
Cheaper experimentation. Test more hypotheses per unit time. Over 70% of features never reach real users. AI makes it trivially cheap to test whether something matters before committing to full development. The discipline: kill non-viable concepts ruthlessly.
Faster prototyping for user research. Working prototypes replace documentation. Tools like Vercel's v0, Replit Agent, and Bolt.new enable functional prototypes from natural language in minutes. This produces superior signal quality from user testing. Encourage everyone to prototype aggressively, make it a habit before you build.
Automated boilerplate, not automated judgment. AI handles undifferentiated work: scaffolding, non-novel code, business logic tests, documentation, and data models. Teams focus on differentiated work: core business logic, empathetic user experiences, novel implementations, and the crucial decision of what to keep or kill.
The "design to 50%" principle. Ship minimal functionality enabling core user journeys. Observe where users hesitate, misunderstand, or abandon. This reveals actual product challenges rather than imagined ones. AI makes this approach nearly zero cost.
# Guardrails — Not Optional
The security landscape for AI-generated code has become genuinely alarming. The data shows AI-native development speed is creating new attack surfaces faster than manual security review or traditional tools can address. We observed roughly one new insecure AI integration appearing per week in our environment, many resulting in production incidents. Anthropic’s Daybreak and Mythos bring a clear wake-up call to security.
## Real Incidents, Real Consequences
Chat Integration RCE. Built in two days using AI, achieved Remote Code Execution by bypassing 2FA and exploiting open ACLs. It costs tens of hours to detect, mitigate, and fix.
Unauthorized Database Access. An AI coding agent accessed approximately 1,500 secure, unauthorized database tables without proper authorization, exposing sensitive data to prompt injection risks.
Google Docs Prompt Injection. An AI coding agent achieved Remote Code Execution through prompt injection embedded in a Google Docs document, bypassing input filtering protections entirely.
Supply Chain Poisoning. A new attack vector called "slopsquatting" emerged in 2025 — AI models hallucinate package names that don't exist, and attackers register those names with malicious code. Multiple documented incidents have resulted from this.
## Emerging Security Controls
Agent Identity and Access Control. Implement step-up 2FA. Apply the principle of least privilege. No shared credentials or open ACLs. Start with passive, read-only use cases and build confidence before granting read-write or broader access.
Data Classification Awareness. Agents must respect data classifications and sensitive boundaries. "Agentic Authorization" is an emerging enterprise challenge where agents bypass restrictions at machine speed that human oversight cannot match.
Prompt Injection Protection. External content — documents, web pages, user inputs — can contain hidden instructions that hijack agent behavior. Implement input filtering, content validation, and context sanitization. Never auto-execute untrusted commands. Resist the temptation of auto-accepting all agent suggestions.
Infrastructure Sandboxing. Agent activities must be observable and auditable. Block high-risk production surfaces — configurations, critical execution, critical storage — until controls are verified. Use sandboxing and OS-level enforcement.
## Technical Guardrails
Static analysis integration. Data shows roughly 30% of Python and 25% of JavaScript AI-generated snippets contain security weaknesses. Centralize advanced static analysis in CI/CD pipelines. Require mandatory human review for critical functions: authentication, payments, and PII handling.
Automated quality gates. Implement "Ralph Loops", OpenClaw, or another form of autonomous loops — iterative verification until success criteria are met. Type checking, linting, and test execution before diff submission. Multi-stage canary systems with stringent gates before production deployment.
Skills-based security. Where the agents are taught secure coding patterns, flagging common vulnerabilities during generation rather than after. Shift left, but with agents.
## Organizational Guardrails
Skill atrophy prevention. Gartner reports 50% of organizations will require "AI-free" skills assessments by 2026. Treat AI as a learning tool — request explanations alongside generated code. Occasionally, work without AI to preserve foundational abilities. The goal isn't Luddism; it's insurance against the day your AI tools are unavailable or producing subtly wrong, but potentially fatal results.
The productivity paradox. Individual productivity gains from AI tools often fail to materialize at the team and company levels. Focus on end-to-end cycle time and feature velocity, not coding speed alone. Adding AI to broken processes yields broken processes that generate more code, faster.
# The Engineer of 2026 and Beyond
The engineers thriving in the new environment treat AI as a collaborative partner for execution while maintaining the systems thinking, critical judgment, and communication skills that no AI can replicate. AI amplifies existing expertise rather than replacing it — senior engineers achieve dramatically better results because they bring deeper context and sharper judgment.
Your domain expertise is the key differentiator in AI-native productivity. No AI tool or agent can replace it. So, invest in sharpening your domain skills, whether that’s math, science, finance, health science, or a legal profession. Continuing to uplevel your engineering fundamentals pay recurring dividends in AI effectiveness.
This is a multi-year transformation, not a one-off tool adoption. Teams treating it as a tooling upgrade consistently fail to realize productivity gains. The organizations that succeed are the ones treating AI-native engineering as a new way of working — with new practices, new disciplines, and new definitions of what "amazing" looks like.
Are you building this way yet? If not, ping me, and I’m happy to have a chat.
This is Part 1 of a two-part series. Part 2, "AI-Native Leaders," covers the organizational transformation, leadership models, and measurement frameworks required to make AI-native engineering work at scale.
## 相关链接
- [Bytebytego](https://x.com/bytebytego)
- [@bytebytego](https://x.com/bytebytego)
- [19K](https://x.com/bytebytego/status/2061821715450351992/analytics)
- [Shah Rahman](https://www.linkedin.com/in/shahirahman/)
- [code overload](https://www.nytimes.com/2026/04/06/technology/ai-code-overload.html)
- [Bolt.new](https://bolt.new/)
- [have a chat](https://www.linkedin.com/in/shahirahman/)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [10:46 PM · Jun 2, 2026](https://x.com/bytebytego/status/2061821715450351992)
- [19.3K Views](https://x.com/bytebytego/status/2061821715450351992/analytics)
- [View quotes](https://x.com/bytebytego/status/2061821715450351992/quotes)
---
*导出时间: 2026/6/3 09:27:02*
---
## 中文翻译
# 成为 AI 原生工程师的实用指南
**作者**: Bytebytego
**日期**: 2026-06-02T14:46:18.000Z
**来源**: [https://x.com/bytebytego/status/2061821715450351992](https://x.com/bytebytego/status/2061821715450351992)
---
如果“AI 编写一切”就是答案，那为什么现在大多数工程团队交付的 Bug、事故和技术债务比两年前还要多？
这正是本周特邀文章的开篇之问，随后它演变成了一篇我们见过的最实用的指南之一，专为那些希望在 AI 时代真正升级的工程师量身打造。
《成为 AI 原生工程师的实用指南》，作者 Shah Rahman，Meta 广告业务自主机器学习迭代与优化全球负责人。
AI 生成了超过 75% 的新代码。OpenAI 和 Anthropic 声称，他们生产的几乎每一行新代码都源自 AI。亚马逊最近在几个月内将 30,000 个生产应用程序从 Java 8 迁移到了 Java 17，而这个项目预计原本需要消耗 4,500 个开发者年。此外，马克·扎克伯格预计，到 2026 年底，AI 智能体将以中级工程师的身份投入工作。
读到这些言论，我们可能会感觉自己正目睹一个时代终章的最后几行字正在被写就。甚至可能是一个职业的终结。
但问题来了：如果 AI 编写一切就是答案，那为什么大多数工程团队交付的 Bug、事故和技术债务比两年前还要多？
在《纽约时报》4 月的一篇文章中，Mike Isaac 和 Erin Griffith 给这种遍及全行业的现象起了一个名字。他们称之为“代码过载”。
根据 Isaac 和 Griffith 的说法，代码过载的本质在于“技术人员产出的代码速度太快、数量太大，以至于已变得难以驾驭。”那些围绕 AI 智能体使用重组工作流程的团队，正淹没在代码频繁更迭和安全漏洞的泥沼中。
然而，许多采用 AI 智能体的工程师正在脱颖而出，实现了真正的生产力提升。他们使用相同的模型和相同的工具，却产生了截然不同的结果。是什么造成了这种差距？
归结为一个决定。真正的生产力提升，源于工程师决定从“编写代码”跨越到“编排代码”。这篇文章是为那些希望跨越这道鸿沟并站在生产力一侧的工程师准备的实战指南。它将涵盖那些将 AI 原生工程与“氛围编码”以及大多数团队目前正在大规模制造的日常混乱区分开来的实践、护栏和思维转变。
# 从工程师到编排者
首先让我澄清一点：工程师并没有变得过时。编写代码历来只是工程工作的一小部分（最多 20-30%）。当 AI 智能体和工具产出更多代码时，这个被低估的现实变得更加清晰——但更多的代码并不一定意味着更高的生产力（通常反而更低）。这是一个关键的区别，而业界正危险地模糊这一界限，正如我所陈述的那样：
当 Andrej Karpathy 在 2025 年初提出“氛围编码”时，它捕捉到了某种有价值的东西——即非工程师通过描述需求来构建功能性软件的能力。这种民主化很有价值。但它与专业的 AI 原生工程有着本质的区别。
AI 原生工程意味着指挥和掌握现有的及新兴的 AI 智能体与工具，去构建那些在前 AI 时代无法实现的东西。懂得如何编写代码仍然是一项基本期望。没有这些知识，你可以利用 AI 构建系统——这就是“氛围编码”。它有一席之地，但这并不是工程。
AI 原生工程师以编排者的身份运作——这种人能够通过对 AI 智能体的恰当编排，将 10 倍工程效率的输入转化为 100 倍的输出。而且这个门槛每周都在升高。
## 四大核心实践
1. 同步上下文工程
作为一个新兴的独特学科，这是 AI 原生工程师最重要的单一技能。上下文工程意味着将项目特定信息系统化地策划并注入到 AI 的工作记忆中：包括架构图、编码标准、业务规则、团队规范以及在整个团队成员间可复用和标准化的开发工作流。
这将基础的“提示工程”转化为成熟的“上下文工程”，反映了一种更深层的理解：AI 输出的质量受限于其接收到的上下文质量。践行严谨上下文工程的团队报告称，速度提升了 40–50%，且对齐开销大幅降低。
随着上下文工程的成熟，Anthropic 的 MCP——被描述为“AI 的 USB-C 接口”——继续成为连接智能体与外部工具及数据源的通用标准。像 CLAUDE.md 这样的上下文文件已成为核心基础设施，而非可有可无的文档。一旦你掌握了开发和维护这种关键上下文的能力，这一持久且不断演进的知识层就能让智能体在你的特定代码库中真正发挥作用。
2. 规范驱动开发
AI 生成代码的质量取决于输入规范的质量。垃圾进，垃圾出——当 AI 能够以前所未有的速度和体量生成垃圾时，这一原则的效力倍增。
随机提示和氛围编码的表现始终不如规范驱动的工作流。在缺乏清晰规范和明确界定指令的情况下，AI 智能体容易陷入循环推理。请养成这种习惯：在让 AI 构建之前先定义你的需求，将问题分解为具有明确成功标准的离散里程碑，并在每个检查点进行增量验证和执行。务必确保智能体与你核实所有未决问题，而不是擅自离队去寻找答案。
3. 关键验证
AI 生成代码的质量接近初级开发人员水平。研究一致显示，约 45% 的 AI 生成代码包含安全漏洞。斯坦福大学的一项研究发现，使用 AI 助手的开发人员编写的代码安全性明显较低，却对代码的安全性更有信心——这是一种危险的组合。
与此同时，一项引人注目的 METR/Anthropic 随机对照试验发现，经验丰富的开源开发人员在熟悉的代码库中使用 AI 助手时，速度实际上慢了 19%。罪魁祸首是什么？缺乏适当验证的过度依赖。GitClear 的一项研究发现，AI 辅助的代码库显示出更高的“代码更迭率”——即代码编写后被快速修改或删除——这表明原始输出是生产力的一个糟糕代理指标。
在 AI 原生时代，瓶颈已经永久地从编写代码转移到了证明代码在大规模、可靠性和安全性下有效运行上。当 AI 快速生成代码时，对该代码的审查、测试和验证成为新的速率限制因素，验证现在变得不可或缺。
4. 问题分解
避免过度信任 AI 处理大型复杂问题。将任务拆解为 AI 可管理的块，由人类处理边缘情况、自定义逻辑和特定领域方面，而 AI 智能体处理 70–80% 的常规实现工作。复杂问题会导致上下文污染和生成劣质代码，AI 智能体很难从中恢复。当上下文被污染时进行压缩和总结，并切换到不同的会话会有所帮助，但这种不连续性可能对长期任务有害。我们许多人浪费了数小时，甚至数天，就是因为没有进行问题分解，并在缺乏明确定义的上下文、合理的规范和验证护栏的情况下，固执地让智能体对期望感到困惑。
## AI 原生工作的时间分配
我建议采用最佳的时间分配比例：40% 用于上下文设定，20% 用于生成和测试迭代，40% 用于审查和验证。这让许多将大部分时间花在代码生成上的开发者感到惊讶。在实践中，生成步骤很快；验证和上下文工作成为了新的时间黑洞。
# 个人转型之旅
## 第一阶段：基础——只需几周时间
从一种主要的 AI 助手开始——选择你最喜欢的一个：Codex、Claude Code 或 Cursor。通过日常实践深入了解它，建立对其能力和局限性的直觉。设置你的工作区、工作流和初始配置。你必须跨越从手动编码时代到 AI 辅助和 AI 生成编码实践的时代鸿沟。你的目标应该是培养判断力，辨别 AI 何时能带来价值，何时制造的工作比节省的还多。记录你的个人笔记，不断迭代，并打下坚实基础。
## 第二阶段：整合——最多一个月
采用结构化的提示框架。创建编码团队规范和架构模式的项目特定上下文文件。实施“先计划，再执行，最后审查”的工作流：规划模式生成规范，执行模式实施，并确保在完成每个原子任务后进行审查。建立审批关卡和护栏，防止智能体跑偏。跳过审查环节会导致技术债务堆积，你和你的智能体在后续都会为此挣扎。
此处的关键实践是带有验证检查点的小循环。证据表明，对于编码任务至少来说，范围有限且紧密的人机协同循环，显著优于大规模自主运行。这可能感觉反直觉且更慢——但在实践中，它产生的结果要好得多。沉溺于某种未经计划和投机性的自主智能体运行，可能会产生大量毫无价值的垃圾，其唯一的命运可能是被丢弃并从头再来。在此发生之前，请避免这种情况。
## 第三阶段：精通——持续进行
部署 AI 智能体处理多步骤、多文件任务。实施 AI 辅助的代码审查工作流。使用高级技术：多智能体工作流、并行会话和跨智能体验证循环。每周，我们都听到编码智能体在基准测试中取得进展，并解决以前从未解决的问题。紧跟这些发展，拥抱 Claude 或 Codex 发明者所倡导的理念，但要根据自身需求进行调整（不要盲目追随，因为他们的情况可能与你的截然不同）。
目标指标：AI 生成代码率 80% 以上，重写率低于 20%。实现了这一目标，你就能相当快地带领你的团队达到同样的熟练水平。
# 团队转型：文化基础
研究表明，70% 的转型成功归因于运营和文化变革。这些变革要求组织和技术负责人通过日常使用 AI 来积极示范转型。同时，确保以下三个关键方面，以建立 AI 原生的文化基础：
1. **心理安全感至关重要。** 麻省理工学院的研究发现，83% 的领导者认为心理安全感能显著提高 AI 倡议的成功率。将“AI 失败故事”作为学习机会来庆祝。使其成为刻意的实践，而非可选项，并确保每个人都感到包容在内，作为集体学习和成长的一部分。
2. **进化的代码审查必不可少。** AI 生成的代码量让传统的人工审查流程不堪重负。重新设计审查流程，区分 AI 生成代码和人工代码，使用不同的审查标准。对“AI 生成 + AI 审查”的 PR 这种危险组合要格外警惕——必要时，这些组合应明确加以护栏管控和治理。
3. **共享上下文库成为核心通货。** 在团队间标准化上下文文件、评估集和智能体配置。现代工具通过插件、技能和命令使上下文的打包变得容易——但要警惕不受控制的扩散，即团队为了标准化而竞争，而不是协作。不要让太多团队成员想要构建智能体和技能的愿望破坏你标准化的智能体运行环境。
# 智能体开发生命周期 (ADLC)
传统的 SDLC——甚至是极端敏捷开发——在 AI 智能体与人类共同开发软件方面显得力不从心。AI 原生工程向智能体开发生命周期的演进，重新定义了每个阶段。
## 规划
最关键的一步。利用深度研究和规划模式，让多个智能体进行并行探索。针对代码库进行规范说明，标记模糊之处，分解为子任务，并估算难度。创建带有版本里程碑的路线图，帮助智能体逐步跟进。规划智能体可以将多个探索智能体的发现汇总成连贯的实施策略。Claude 的 OpenClaw 可以并行运行多个子智能体。
## 构建
AI 智能体像初级或中级工程师一样处理端到端的功能实现（在撰写本文时，我预计在一两年内其水平将提升至高级工程师）。工程师扮演技术负责人的角色，编排多个智能体而不是直接编写代码。顺序或并行执行模式取决于你的路线图和验证计划。智能体编码工具格局已经迅速成熟——Claude Code、Cursor 的 Composer 模式、GitHub Copilot 的 Agent 模式以及 OpenAI 的 Codex 智能体都支持这种模式，且各有所长。每个月都有新版本发布——密切关注新功能。
## 测试
这是测试驱动开发（TDD）的复活。智能体先编写测试计划，然后实现代码。所有测试在开始时都应失败，然后逐步通过。在原子级别进行单元测试，在功能间进行集成测试，以及在整个系统范围内进行端到端测试。不要过度偏向单元测试而忽视集成测试或系统测试的缺失。
专家提示：考虑将规划、构建和测试智能体分离。每个智能体群从不同角度进行专业化，并深入了解你的代码库。规划智能体可以挑战走捷径的构建智能体；跳过覆盖范围的测试智能体；或者对看起来正确但实际错误的实现有偏见的审查智能体。同样，审查智能体可以让每一个上游智能体对犯错或遗漏步骤负责。
## 审查
部署专攻关键维度的智能体群：功能性、质量、可扩展性、性能、可靠性、安全性和隐私。智能体进行初审并生成报告；人类仔细审查每份报告。当一个智能体发现一个问题——比如注入漏洞——应用泛化原则：如果存在一个实例，很可能也存在其他实例，这是你主动在代码中修复同类漏洞类型的机会，而不仅仅是一两个实例。
## 文档
从事后文档转向持续生成。AI 智能体实时生成摘要、关键设计决策、架构图和变更日志。这自然汇入 API 文档、功能辅助材料和客户面向的内容。我对 AI 工具终于解决了过时、陈旧和不一致的文档问题感到非常兴奋，这也是我和我的团队几十年来一直深受其害的问题。
## 将 ADLC 编码固化
将你的第一层（个人）和第二层（团队）实践编码为维护良好、自我演进的上下文文件、技能库和 MCP 工具。这确保 ADLC 的采用能在整个组织范围内扩展，而不是仅作为部落知识存在或被困在组织的局部。推广 ADLC 工具包。
# AI 原生流程的真实面貌