AI 编程代理已取代我常用的所有框架

基本信息

导语

随着大模型技术的成熟，软件开发模式正从“辅助编写”向“自主代理”演进。本文作者分享了将 AI Agent 引入工作流后的实际体验，探讨了这些智能体如何接管从架构搭建到代码生成的具体任务。通过分析这一转变，文章揭示了传统框架在自动化浪潮下面临的挑战，以及开发者如何通过调整协作模式来适应新的技术环境。

评论

文章中心观点： AI 编程代理的智能化与系统化能力已达到临界点，使得开发者可以抛弃对传统开发框架的依赖，转而通过自然语言指令由 Agent 动态生成并维护代码逻辑，从而实现开发模式的“去框架化”。

支撑理由：

  1. 认知负荷的转移与抽象层的提升（你的推断 / 作者观点） 文章核心论点在于，过去框架存在的意义是解决“重复造轮子”和“统一架构”的问题，这需要开发者在脑海中建立复杂的映射。而现在，开发者只需描述意图，Agent 能够实时生成符合最佳实践的代码。这意味着，框架不再是静态的库，而是变成了 Agent 动态生成的“产物”。作者实际上是在主张：从“调用 API”转向“定义行为”，抽象层级从代码级提升到了意图级。

  2. 全栈能力的通用化取代专业化分工（事实陈述 / 作者观点） 文章提到“替换了所有框架”，暗示了 Agent 具备跨技术栈的通用处理能力。以前，前端需要 React/Vue，后端需要 Django/Express，中间件需要 Redis。Agent 的介入打破了这种技术壁垒，它可以根据上下文需求，混用甚至自创实现方式。技术栈的选型不再基于开发者的熟悉度，而是基于 Agent 对当前任务的最优解计算。

  3. 上下文理解能力的质变（事实陈述） 现有的 LLM（如 GPT-4o, Claude 3.5 Sonnet）在长上下文处理和代码库理解上的进步，使得 Agent 不再是简单的“补全工具”，而是具备“系统架构师”视角的协作者。它能够理解整个项目的依赖关系，从而在不需要框架约束的情况下，保证代码的一致性。

反例与边界条件：

  1. 性能与底层控制的黑盒陷阱（你的推断） 虽然 Agent 可以生成代码，但它生成的往往是“通用解”而非“高性能解”。在需要极致内存管理、实时性要求极高的系统编程（如高频交易 HFT、嵌入式开发）中，手写优化过的 C++/Rust 代码或使用经过几十年优化的底层框架，Agent 目前难以替代。框架不仅是工具，更是性能优化的承诺。

  2. 大型团队协作与标准化困境（行业观点） 框架在大型团队中的核心价值是“强制约束”和“降低沟通成本”。如果每个人都用 Agent 生成各自的实现，代码风格、架构模式将千奇百怪，导致 Code Review 变得极其困难，维护成本指数级上升。去框架化可能导致“每人一个框架”的巴别塔效应。

  3. 安全性与合规性风险（事实陈述） 现有框架通常有成熟的安全审计和社区支持。Agent 生成的代码可能包含隐蔽的安全漏洞或许可证问题。在没有框架作为“安全基线”的情况下，直接运行 Agent 生成的代码在金融、医疗等强监管领域是不可行的。

评价维度分析：

  1. 内容深度： 文章触及了软件工程范式的核心转移，即“元编程”的普及。它指出了框架本质上是“固化的最佳实践”，而 Agent 是“流动的最佳实践”。论证较为严谨，但略显激进，忽略了工程领域“稳定性”优于“灵活性”的许多场景。

  2. 实用价值： 对于原型开发、MVP（最小可行性产品）验证、内部工具开发以及独立开发者，该观点具有极高的实用价值。它能极大地缩短从想法到产品的时间。但对于企业级核心系统开发，目前的指导意义有限，因为缺乏对 CI/CD 流程、测试覆盖率和长期维护性的深入探讨。

  3. 创新性： 提出了“框架消亡论”这一极具挑战性的观点。虽然“低代码”概念早已存在，但文章将其提升到了“全流程替代传统编码框架”的高度，重新定义了人机协作的边界。

  4. 可读性： 标题具有极强的冲击力，能够迅速引发技术共鸣。逻辑结构清晰，从个人体验上升到行业趋势，符合技术传播的规律。

  5. 行业影响： 如果该趋势持续，将对技术教育、开源框架生态（如 React, Vue 的统治地位）以及初级开发者的职业路径产生巨大冲击。行业重心将从“学习框架 API”转向“学习如何提示与架构设计”。

可验证的检查方式：

  1. “白板重构”测试（实验）： 选取一个中等复杂度的 CRUD 应用，分别使用传统主流框架（如 Next.js + Prisma）和纯 AI Agent（如 Claude 3.5 + Cursor，不预设框架）开发。对比两者的代码行数、开发耗时、功能完备度以及运行时的性能指标。

  2. 代码维护性审计（指标）： 在 Agent 生成代码的基础上，进行为期两周的迭代开发。记录每次需求变更时，Agent 是否能保持代码架构不崩坏，以及是否引入了技术债务。观察“代码腐烂”的速度是否快于传统框架开发。

  3. 团队协作摩擦系数观察（观察窗口）： 在一个 3-5 人的开发小组中，实施“去框架化”开发。观察 Code Review 环节中，成员对他人代码的理解时间是否增加，以及是否出现架构分歧无法调和的情况。

总结： 这篇文章是一个重要的技术信号，标志着**“以框架为中心”向“以意图为中心”的开发模式转变**的开始。虽然短期内传统框架不会消失（因为它们提供了

代码示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

# 示例1：自动生成单元测试
def generate_unit_tests(func_name, func_code):
    """
    自动为给定函数生成单元测试代码
    :param func_name: 要测试的函数名
    :param func_code: 函数源代码
    :return: 生成的测试代码字符串
    """
    import ast
    
    # 解析函数代码获取参数信息
    tree = ast.parse(func_code)
    args = []
    for node in ast.walk(tree):
        if isinstance(node, ast.FunctionDef) and node.name == func_name:
            args = [arg.arg for arg in node.args.args]
            break
    
    # 生成测试模板
    test_template = f"""
import unittest
from your_module import {func_name}

class Test{func_name.capitalize()}(unittest.TestCase):
    def test_{func_name}_basic(self):
        # 基本功能测试
        result = {func_name}({', '.join(['1'] * len(args))})
        self.assertIsNotNone(result)
        
    def test_{func_name}_edge_cases(self):
        # 边界条件测试
        with self.assertRaises(ValueError):
            {func_name}({', '.join(['-1'] * len(args))})
"""
    return test_template

# 使用示例
print(generate_unit_tests("calculate_sum", "def calculate_sum(a, b): return a + b"))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# 示例2：智能代码补全助手
class CodeCompletionAgent:
    """
    基于上下文的代码补全助手
    """
    def __init__(self):
        self.common_patterns = {
            "for": "for item in items:\n    # 处理每个item\n    pass",
            "if": "if condition:\n    # 条件满足时的操作\n    pass\nelse:\n    # 条件不满足时的操作\n    pass",
            "class": "class ClassName:\n    def __init__(self):\n        # 初始化代码\n        pass\n    \n    def method(self):\n        # 方法实现\n        pass"
        }
    
    def suggest_completion(self, partial_code):
        """
        根据部分代码提供补全建议
        :param partial_code: 用户输入的部分代码
        :return: 补全建议列表
        """
        suggestions = []
        for key, pattern in self.common_patterns.items():
            if partial_code.strip().startswith(key):
                suggestions.append(pattern)
        return suggestions
    
    def complete_code(self, partial_code, selected_index=0):
        """
        应用选定的补全建议
        :param partial_code: 部分代码
        :param selected_index: 选择的建议索引
        :return: 完整代码
        """
        suggestions = self.suggest_completion(partial_code)
        if suggestions and 0 <= selected_index < len(suggestions):
            return suggestions[selected_index]
        return partial_code

# 使用示例
agent = CodeCompletionAgent()
print(agent.suggest_completion("for"))  # 输出: ['for item in items:\n    # 处理每个item\n    pass']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# 示例3：自动代码重构工具
def refactor_code(source_code):
    """
    自动重构代码以提高可读性和性能
    :param source_code: 原始代码
    :return: 重构后的代码
    """
    import ast
    import re
    
    # 1. 简化条件表达式
    source_code = re.sub(r'if\s+(.+?):\s*return\s+True\s*else:\s*return\s+False', 
                        r'return bool(\1)', source_code)
    
    # 2. 合并连续的字符串操作
    source_code = re.sub(r'(\w+)\s*=\s*(\w+)\s*\+\s*["\'](.+?)["\']', 
                        r'\1 = f"{\2}\3"', source_code)
    
    # 3. 转换为列表推导式
    tree = ast.parse(source_code)
    for node in ast.walk(tree):
        if isinstance(node, ast.For) and isinstance(node.body[0], ast.Append):
            # 检测简单的for循环append模式
            if (isinstance(node.body[0].value, ast.Call) and 
                hasattr(node.body[0].value.func, 'attr') and 
                node.body[0].value.func.attr == 'append'):
                # 转换为列表推导式
                new_code = f"{node.target.id} = [{node.body[0].value.args[0].value} for {node.target.id} in {node.iter.id}]"
                source_code = source_code.replace(ast.unparse(node), new_code)
    
    return source_code

# 使用示例
original_code = """
result = []
for num in numbers:
    result.append(num * 2)
"""
print(refactor_code(original_code))  # 输出: result = [num * 2 for num in numbers]

案例研究

1：某中型 SaaS 初创公司的技术重构

1：某中型 SaaS 初创公司的技术重构

背景: 该公司主要开发基于 Web 的数据管理平台。随着业务迭代，前端遗留了大量历史代码，使用了旧版的 Angular 框架。由于 Angular 版本升级困难且生态逐渐落后，新入职的工程师更倾向于使用 React 或 Vue，导致团队内部技术栈割裂，维护成本极高。

问题: 公司面临两个选择：一是投入数月时间进行昂贵且风险高的人工重写；二是继续忍受旧框架带来的低开发效率。此外，团队中缺乏精通旧版 Angular 的资深专家，单纯的人力重构不仅耗时，还容易引入新的 Bug。

解决方案: 技术主管引入了 AI 编程代理（如 GitHub Copilot Workspace 或 Cursor），配合自定义的 Prompt 工程流。他们没有让 AI 一次性重写整个系统，而是采用“模块化迁移”策略。工程师编写详细的逻辑描述，让 AI 代理生成基于 React 和 TypeScript 的新组件代码，并自动编写对应的单元测试。AI 工具负责处理繁琐的语法转换和状态管理逻辑迁移，人类工程师则专注于审核业务逻辑的正确性。

效果: 原本预计需要 6 个月的重构工作，在 2 个月内完成了核心模块的迁移。AI 编码代理不仅生成了新框架的代码，还优化了类型定义，减少了运行时错误。团队彻底抛弃了旧框架，统一了技术栈，新功能的开发速度提升了约 40%。

2：全栈独立开发者的 MVP 爆发式开发

2：全栈独立开发者的 MVP 爆发式开发

背景: 一位拥有产品背景的独立开发者想要验证一个关于“AI 自动生成周报”的商业创意。虽然他具备基础的编程知识，但对现代前端复杂的工程化工具（如 Webpack, Vite, Next.js 等）感到头疼，学习曲线极陡，阻碍了他将想法快速落地的进程。

问题: 如果按照传统流程，他需要先花费数周学习 React 或 Vue 框架，配置构建工具，然后再编写后端 API。这种高门槛的“摩擦力”往往导致创意在原型阶段就夭折。他需要的不是一个完美的架构，而是一个能快速上线、收集用户反馈的产品。

解决方案: 该开发者放弃了使用传统前端框架，转而使用 AI 编码代理（如 v0.dev 或 Claude 3.5 Sonnet + Artifacts）。他直接通过自然语言描述 UI 需求和交互逻辑，让 AI 生成基于 Web Components 的原生代码，或者直接生成包含样式的 HTML/JS 模块。AI 充当了“框架”的角色，自动处理了路由、状态绑定和样式响应式问题。

效果: 他在 3 天内完成了包含前端界面、支付对接和后端逻辑的 MVP（最小可行性产品）并上线。由于没有使用复杂的重型框架，代码极其轻量，部署在静态服务器上成本极低。产品上线后迅速获得了首批付费用户，验证了商业模式。对他而言，AI 编码代理取代了传统框架的学习成本，成为了他唯一的开发工具。

最佳实践

最佳实践指南

实践 1：从“框架使用者”转变为“架构审查者”

说明: 当 AI 编程代理能够自动生成各种框架的样板代码时，开发者的核心价值不再是记忆特定框架的 API，而是审查 AI 生成的架构设计是否合理。你需要关注代码的可维护性、安全性以及是否符合业务逻辑，而不是纠结于语法细节。

实施步骤:

  1. 在使用 Agent 生成代码前，先绘制系统架构图或编写高层次的设计文档。
  2. 要求 Agent 根据设计文档推荐最适合的框架，而不是由你预设框架。
  3. 重点审查 Agent 生成的依赖注入、模块划分和数据流设计。

实践 2：建立上下文感知的 Prompt 策略

说明: AI 编程代理的效能高度依赖于输入的上下文质量。与其直接下达“使用 React 重写”的指令，不如提供业务背景、性能约束和现有代码库的风格指南，让 Agent 自主决定技术栈。

实施步骤:

  1. 创建包含项目结构、编码规范和业务规则的 CONTEXT.md 文件。
  2. 在 Prompt 中明确输入变量和输出结果，而非指定具体的库函数。
  3. 使用迭代式对话，先让 Agent 理解需求，再让其生成代码。

注意事项: 避免在一次对话中包含过多无关的文件上下文，这会稀释 Agent 的注意力，导致生成质量下降。

实践 3：优先选择“原生”或“标准”解决方案

说明: 框架通常是为了解决特定时期的痛点而存在的。随着 AI 能够快速生成原本繁琐的样板代码，过度依赖复杂的第三方框架可能会导致不必要的抽象层。最佳实践是倾向于使用语言标准库或轻量级库，让 Agent 生成更直观、更易调试的代码。

实施步骤:

  1. 评估现有框架是否仅为了减少打字量而存在，如果是，考虑移除它。
  2. 在任务分配时，指示 Agent 优先使用标准库实现功能。
  3. 对比“使用框架”与“原生实现”的代码复杂度，选择更易读的方案。

注意事项: 在涉及高性能、并发或底层安全（如加密）的场景下，仍应优先使用经过验证的成熟框架，而非手写逻辑。

实践 4：实施严格的测试驱动验证（TDD）

说明: 当 Agent 替代了框架的约束力后，代码的正确性边界变得模糊。必须通过高覆盖率的自动化测试来确保 Agent 生成的代码符合预期。测试用例是 Agent 理解业务逻辑的最精确契约。

实施步骤:

  1. 在让 Agent 编写功能代码之前，先让它生成基于边界条件的测试用例。
  2. 使用测试作为验证手段，运行 Agent 生成的代码直到所有测试通过。
  3. 将测试集成到 CI/CD 流水线中，确保后续的 Agent 修改不会破坏现有功能。

注意事项: Agent 可能会生成“通过测试但逻辑错误”的代码（如过拟合测试用例），因此代码审查依然必不可少。

实践 5：掌握“最小可行依赖”原则

说明: Agent 可以快速编写胶水代码，这消除了使用大型全能框架的必要性。最佳实践是采用组合式开发，即使用多个单一职责的小型库（或 Agent 生成的内部模块）来替代庞大的框架，从而降低锁定风险。

实施步骤:

  1. 分析当前框架的功能，拆解为独立的功能模块（如路由、状态管理、ORM）。
  2. 指示 Agent 针对每个模块寻找最轻量级的替代方案或实现方案。
  3. 逐步剥离框架依赖，观察系统功能是否受影响。

注意事项: 在剥离框架时，要确保 Agent 生成的替代方案包含必要的错误处理和边缘情况逻辑，这些通常是成熟框架默认提供的。

实践 6：构建可解释的代码库

说明: 框架通常隐含了大量的“魔法”行为和约定俗成的规则。在使用 Agent 辅助开发时，代码应具有高度的显式性和可读性，以便 Agent 能够理解上下文并进行后续修改，同时也便于人类开发者审查。

实施步骤:

  1. 要求 Agent 在代码中添加业务逻辑注释，而非语法注释。
  2. 避免使用过于复杂的元编程或隐式依赖注入模式，除非有明确的性能需求。
  3. 定期重构，确保变量命名和函数调用能够直观反映业务意图。

注意事项: 显式代码可能会比框架代码更冗长，但考虑到 Agent 的生成速度和代码的可维护性，这种冗长是值得的权衡。

实践 7：动态适应与工具链无关化

说明: 既然 Agent 可以快速切换技术栈，开发者不应过度依附于某一种特定的框架或工具链。最佳实践是培养“第一性原理”思维，让 Agent 根据当前问题的最优解来选择工具，而不是因为“熟悉”而使用工具。

学习要点

  • 基于 Coding agents（AI 编程代理）对开发工作流的重构，以下是从该主题中提炼出的关键要点：
  • AI 编程代理已具备独立完成复杂任务的能力，使开发者从“编写代码”转变为“审核代码”，极大降低了实现功能的门槛。
  • 现代开发不再需要记忆繁杂的框架 API 或语法细节，开发者只需专注于业务逻辑和架构设计，具体实现由 AI 代理全权处理。
  • 技术选型的焦虑被消除，因为 AI 代理能瞬间掌握并运用任何框架，开发者无需再为了通用性而局限于特定技术栈。
  • 代码库的维护成本显著降低，当框架更新或废弃时，无需人工重写，只需指示 AI 代理即可自动完成迁移和重构。
  • 开发者的核心竞争力已从“代码熟练度”转移至“产品定义力”和“Prompt（提示词）工程”，即如何精准描述需求的能力。
  • 原型开发速度呈指数级提升，个人开发者借助 AI 代理即可在极短时间内构建出过去需要团队协作才能完成的复杂应用。

常见问题

1: 什么是 Coding Agent（编程智能体），它与传统的 GitHub Copilot 等代码补全工具有何区别？

1: 什么是 Coding Agent（编程智能体），它与传统的 GitHub Copilot 等代码补全工具有何区别？

A: Coding Agent 是一种基于大语言模型（LLM）的高级自动化工具，它不仅能根据上下文补全代码片段，还能理解高层指令、规划任务、自主调用开发工具（如终端、文件系统、编译器），并迭代修复错误。与 Copilot 等被动式补全工具不同，Coding Agent 具备“代理”属性，能够独立完成从需求分析、架构设计到代码编写、测试和部署的完整闭环。它更像是一个虚拟的初级程序员或结对编程伙伴，而不仅仅是一个输入法插件。

2: Coding Agent 真的能完全取代 React、Vue 或 Django 等现有框架吗？

2: Coding Agent 真的能完全取代 React、Vue 或 Django 等现有框架吗？

A: 这是一个概念上的误解。Coding Agent 并不是在运行时层面“取代”了框架，而是改变了开发框架的方式。在底层，Web 应用依然需要运行在浏览器环境中，后端依然需要操作系统和网络接口，因此底层技术栈（如 JavaScript、HTML、CSS、SQL 或 Python）依然存在。但是，Agent 改变了开发者的交互模式：开发者不再需要手动编写框架特定的样板代码，而是由 Agent 根据需求自动生成、调用和维护这些框架代码。因此，Agent 取代的是“使用框架的手工劳动”，而非框架本身提供的运行能力。

3: 如果 Agent 生成了代码，我是否还需要学习前端或后端的底层技术细节？

3: 如果 Agent 生成了代码，我是否还需要学习前端或后端的底层技术细节？

A: 是的，依然非常需要。虽然 Agent 可以大幅降低编写代码的门槛，但软件开发的核心难点往往在于“定义问题”和“系统设计”，而非单纯的“语法实现”。当 Agent 生成的代码出现逻辑错误、性能瓶颈或安全漏洞时，只有具备扎实技术背景的开发者才能有效地进行调试、审查和优化。此外，理解底层原理有助于你向 Agent 提供更精准的提示词，从而获得更好的结果。未来的开发者将从“代码编写者”转变为“代码审查者和架构设计者”。

4: 使用 Coding Agent 进行开发，目前面临的主要挑战和局限性是什么？

4: 使用 Coding Agent 进行开发，目前面临的主要挑战和局限性是什么？

A: 尽管技术发展迅速，但目前仍存在几个显著挑战：

  1. 上下文窗口限制：Agent 可能无法一次性理解超大型单体项目的全部上下文，导致修改时缺乏全局观。
  2. 幻觉与准确性：Agent 可能会生成看似合理但实际无法运行，或使用了不存在库的代码。
  3. 调试困难：当 Agent 生成的复杂逻辑出现 Bug 时，人类开发者可能需要花费大量时间去理解其生成的逻辑才能修复问题。
  4. 环境配置：让 Agent 自主处理复杂的企业级环境配置、依赖冲突和权限管理仍然是一个难题。

5: 这种“AI 优先”的开发模式会对软件架构产生什么影响？

5: 这种“AI 优先”的开发模式会对软件架构产生什么影响？

A: 这种模式可能会推动软件架构向“模块化”和“标准化”方向发展。由于 AI 擅长处理常见的、有明确文档规范的代码，未来的架构可能会倾向于使用更清晰、解耦度更高的设计模式，以便 AI 能够更好地理解和生成。同时，为了适应 AI 的上下文限制，单体应用可能会进一步加速向微服务或无服务器架构转变，将大任务拆解为 AI 能够独立处理的小型、独立功能单元。

6: 对于初学者来说，现在学习编程是否还有意义，如果未来都是 Agent 在写代码？

6: 对于初学者来说，现在学习编程是否还有意义，如果未来都是 Agent 在写代码？

A: 学习编程依然意义重大，但学习的重心需要转移。过去的学习重点可能在于记忆语法和 API，现在的重点应转向计算思维、系统设计、算法逻辑以及对业务流程的理解。编程语言将变成一种“交流语言”，用于与 AI 协作。懂得编程原理的人能够利用 Agent 以一当十，而不懂原理的人可能只能得到质量低下且无法维护的代码。因此，入门门槛降低了，但成为专家的门槛依然存在，甚至因为需要驾驭 AI 而变得更高。

7: 企业在引入 Coding Agent 时，最需要关注的安全风险是什么？

7: 企业在引入 Coding Agent 时，最需要关注的安全风险是什么？

A: 最大的风险在于数据泄露和供应链安全。开发者可能会将包含敏感信息（如 API 密钥、客户数据或专有算法）的代码片段发送给云端模型进行处理，这可能导致数据泄露。此外，Agent 建议的依赖库可能存在恶意代码或已知漏洞。企业需要建立严格的 AI 使用策略，使用私有化部署的模型或具备企业级安全保护的 SaaS 服务，并对 AI 生成的代码进行严格的安全扫描。

思考题

## 挑战与思考题

### 挑战 1: [简单]

问题**: 假设 Coding Agent 能够自动生成标准的 CRUD（增删改查）代码。请列出三个即使代码由 Agent 生成，人类开发者仍然必须亲自编写或审核的关键代码片段或配置部分。

提示**: 思考代码运行的安全性、系统的外部连接点以及业务逻辑的独特性。

引用

注：文中事实性信息以以上引用为准；观点与推断为 AI Stack 的分析。

站内链接

相关文章