# Claude Code Is Creating a New Class of Developers
**作者**: Suryansh Tiwari
**日期**: 2026-05-29T10:43:26.000Z
**来源**: [https://x.com/Suryanshti777/status/2060311043004666250](https://x.com/Suryanshti777/status/2060311043004666250)
---
Most developers are still using AI the same way they used ChatGPT in 2023.
Open a chat.
Ask a question.
Copy some code.
Paste it into the editor.
Repeat.
It works.
But it's already becoming outdated.
A new category of developers is emerging.
They're not using AI as a coding assistant.
They're building entire operating systems around it.
And the gap between those two approaches is becoming one of the biggest competitive advantages in software.
The developers who understand this shift today will have an enormous advantage over the next few years.
Because the future of software development isn't about writing code faster.
It's about orchestrating intelligence at scale.
The Shift Nobody Is Talking About
For the last two years, the AI conversation has been dominated by one question:
"Which model is better?"
Claude.
GPT.
Gemini.
DeepSeek.
Open-source models.
Everyone is comparing benchmarks, coding scores, context windows, and reasoning abilities.
But that conversation is slowly becoming less important.
A more valuable question is emerging:
How do you turn a language model into a productive software engineer?
Not a chatbot.
Not an autocomplete tool.
Not a code generator.
A real engineering system capable of:
→ Planning work
→ Researching solutions
→ Reviewing code
→ Finding bugs
→ Writing tests
→ Updating documentation
→ Managing context
→ Learning from previous work
→ Improving over time
That's the transformation happening around Claude Code.
And it's much bigger than most people realize.
The First Wave Of AI Was About Writing Code
The first generation of AI coding tools focused on code generation.
GitHub Copilot showed that AI could autocomplete code.
ChatGPT made software development conversational.
Models improved.
Context windows expanded.
Code quality increased dramatically.
For a while, it felt like the entire industry was racing toward one goal:
Generate more code.
But experienced engineers quickly discovered something important.
Writing code is rarely the hardest part of software development.
The real work usually looks like this:
Understanding requirements.
Researching solutions.
Making architectural decisions.
Managing technical debt.
Testing edge cases.
Reviewing implementations.
Debugging production issues.
Maintaining documentation.
Coordinating complex projects.
Most of the engineering lifecycle happens outside the editor.
And that's exactly where traditional AI workflows started breaking down.
Why Claude Code Feels Different
Claude Code introduced a fundamentally different idea.
Instead of treating AI as something you occasionally ask for help, it places AI directly inside the workflow itself.
That sounds subtle.
It's not.
A chatbot waits for instructions.
An operator participates in execution.
That distinction changes everything.
When developers first started experimenting with Claude Code, the conversation shifted from:
"Can AI write this function?"
To:
"Can AI handle this entire workflow?"
Once that question appears, you stop thinking about code generation.
You start thinking about systems.
And systems are where the real leverage exists.
The Real Bottleneck Isn't Intelligence
Most people assume AI failures happen because models aren't smart enough.
In reality, the bottleneck is often context.
Imagine hiring the best engineer in the world and giving them:
❌ No documentation
❌ No project history
❌ No coding standards
❌ No architecture decisions
❌ No knowledge of previous bugs
Even the smartest engineer would struggle.
Not because they're incapable.
Because they're operating without context.
AI models face the exact same problem.
This explains why two developers can use the same model and get completely different results.
One gets incredible outcomes.
The other gets mediocre outputs.
The difference usually isn't intelligence.
The difference is context management.
Context Is Becoming The New Infrastructure
Most AI discussions focus on prompts.
But prompts are only the visible layer.
Underneath every successful AI workflow sits a much larger infrastructure.
That infrastructure includes:
→ Memory systems
→ Knowledge storage
→ Context retrieval
→ Workflow orchestration
→ Evaluation loops
→ Security controls
→ Verification pipelines
→ Performance monitoring
These systems determine whether an AI becomes genuinely useful or remains an expensive autocomplete engine.
The companies building these layers today are effectively building the operating systems of the AI era.
The Rise Of Agentic Development
This is where software development is heading.
Not one AI.
Multiple specialized AIs.
Think about how a modern engineering organization works.
You don't hire one person to do everything.
You have specialists.
Researchers.
Architects.
Reviewers.
Security engineers.
QA engineers.
Technical writers.
Operators.
The exact same pattern is emerging inside AI workflows.
A modern agentic system might look like this:
Research Agent
↓
Architecture Agent
↓
Implementation Agent
↓
Testing Agent
↓
Security Agent
↓
Documentation Agent
↓
Deployment Agent
Each system has a specific responsibility.
Each system focuses on a specific problem.
Together they behave less like a chatbot and more like an engineering organization.
This is why many of the most advanced Claude Code users are no longer building prompts.
They're building workflows.
Memory May Become More Important Than Models
One of the most underrated shifts in AI is the growing importance of memory.
Most models are becoming increasingly capable.
The difference between them is shrinking.
But memory creates compounding advantages.
Think about human engineers.
Experience matters because experience creates memory.
Memory creates intuition.
Intuition creates better decisions.
Without memory:
Every project starts from zero.
Every mistake gets repeated.
Every lesson disappears.
Every workflow must be recreated.
That's incredibly inefficient.
This is why modern AI systems increasingly focus on:
→ Session persistence
→ Long-term memory
→ Pattern extraction
→ Knowledge accumulation
→ Workflow evolution
→ Continuous learning
The future isn't simply smarter models.
The future is smarter systems that remember.
The Hidden Layer Most People Ignore
The most interesting part of the AI stack isn't the model anymore.
It's everything surrounding the model.
Three developers can use the exact same Claude model.
One gets average results.
One gets excellent results.
One builds an entire software company around it.
The difference isn't intelligence.
The difference is infrastructure.
The winning stack increasingly looks like this:
Model
↓
Memory
↓
Workflow
↓
Evaluation
↓
Security
↓
Automation
↓
Execution
Most people only focus on the first layer.
The highest leverage exists in everything below it.
Why This Feels Similar To The Cloud Revolution
Many developers today see agent workflows as optional.
That's exactly how cloud computing looked fifteen years ago.
People thought:
"I can just run servers myself."
Then cloud infrastructure became standard.
The same thing happened with Git.
The same thing happened with containers.
The same thing happened with CI/CD.
Every infrastructure shift initially looks like a productivity hack.
Then it becomes a competitive advantage.
Eventually it becomes the default way of working.
Agentic development is following the same pattern.
Today it's experimental.
Tomorrow it will be expected.
The New Developer Skillset
For years, software engineering success was heavily tied to implementation ability.
The future may look very different.
The highest leverage developers will increasingly focus on:
Designing workflows.
Managing context.
Building evaluation systems.
Creating memory architectures.
Coordinating specialized agents.
Defining verification processes.
Structuring execution pipelines.
The job becomes less about producing code.
And more about directing intelligence.
In many ways, developers are evolving from builders into orchestrators.
Where This Leads
The evolution appears surprisingly clear.
Stage 1
Developer + Editor
Stage 2
Developer + AI Assistant
Stage 3
Developer + AI Team
Stage 4
Developer + AI Operating System
Most developers today are somewhere between Stage 2 and Stage 3.
The next major leap happens when AI stops feeling like a tool and starts feeling like infrastructure.
At that point a single engineer won't just write software.
They'll coordinate an entire network of specialized systems.
Research.
Planning.
Implementation.
Testing.
Security.
Documentation.
Deployment.
All operating together.
Final Thought
Most people are still focused on the model wars.
Claude vs GPT.
GPT vs Gemini.
Open-source vs proprietary.
Those debates are interesting.
But they may ultimately matter less than people think.
The bigger story is that software development itself is becoming agentic.
The winners won't necessarily be the developers with access to the smartest model.
They'll be the developers who build the smartest systems around those models.
That's why Claude Code has become such an important signal.
It's not just another coding tool.
It's one of the earliest glimpses into what software engineering looks like when intelligence becomes programmable.
And once that happens, the question is no longer:
"Can AI write code?"
The question becomes:
"How much of the software development lifecycle can AI own?"
The answer appears to be growing every month.
And we're still in the earliest chapters of that story.
## 相关链接
- [Suryansh Tiwari](https://x.com/Suryanshti777)
- [@Suryanshti777](https://x.com/Suryanshti777)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [6:43 PM · May 29, 2026](https://x.com/Suryanshti777/status/2060311043004666250)
- [73.9K Views](https://x.com/Suryanshti777/status/2060311043004666250/analytics)
- [View quotes](https://x.com/Suryanshti777/status/2060311043004666250/quotes)
---
*导出时间: 2026/5/30 10:37:26*
---
## 中文翻译
# Claude Code 正在创造一类全新的开发者
**作者**: Suryansh Tiwari
**日期**: 2026-05-29T10:43:26.000Z
**来源**: [https://x.com/Suryanshti777/status/2060311043004666250](https://x.com/Suryanshti777/status/2060311043004666250)
---
大多数开发者仍然像 2023 年使用 ChatGPT 那样使用 AI。
打开聊天窗口。
提问。
复制代码。
粘贴到编辑器。
重复。
这确实有用。
但它正逐渐过时。
一类新的开发者正在涌现。
他们不只是将 AI 作为编程助手。
他们正在围绕 AI 构建完整的操作系统。
而这两种方法之间的差距，正成为软件领域最大的竞争优势之一。
如今理解这一转变的开发者，在未来几年将拥有巨大的优势。
因为软件开发的未来不在于更快地编写代码。
而在于大规模地编排智能。
## 没人谈论的真正转变
在过去两年里，AI 领域的讨论始终被一个问题主导：
“哪个模型更好？”
Claude。
GPT。
Gemini。
DeepSeek。
开源模型。
所有人都在比较基准测试、编程得分、上下文窗口和推理能力。
但这场讨论正逐渐变得不再那么重要。
一个更有价值的问题正在浮现：
你如何将大语言模型转变为一个高效的软件工程师？
而不是一个聊天机器人。
不是自动补全工具。
不是代码生成器。
而是一个真正的工程系统，具备以下能力：
→ 规划工作
→ 研究解决方案
→ 审查代码
→ 发现 Bug
→ 编写测试
→ 更新文档
→ 管理上下文
→ 从以往的工作中学习
→ 持续改进
这就是围绕 Claude Code 正在发生的变革。
其意义远超大多数人的认知。
## 第一波 AI 浪潮聚焦于写代码
第一代 AI 编程工具专注于代码生成。
GitHub Copilot 证明了 AI 可以自动补全代码。
ChatGPT 让软件开发变成了对话。
模型在改进。
上下文窗口在扩大。
代码质量大幅提升。
有一段时间，感觉整个行业都在朝着一个目标狂奔：
生成更多的代码。
但经验丰富的工程师很快发现了一件重要的事情。
编写代码通常不是软件开发中最难的部分。
真正的工作通常是这样的：
理解需求。
研究解决方案。
做出架构决策。
管理技术债务。
测试边缘情况。
审查实现。
调试生产问题。
维护文档。
协调复杂项目。
工程生命周期的大部分时间都发生在编辑器之外。
而这正是传统 AI 工作流程开始崩塌的地方。
## 为什么 Claude Code 感觉如此不同
Claude Code 引入了一个根本性的不同理念。
它不再将 AI 视为偶尔寻求帮助的对象，而是直接将 AI 置于工作流程本身之中。
听起来很微妙。
其实不然。
聊天机器人等待指令。
操作者参与执行。
这种区别改变了一切。
当开发者最初开始尝试 Claude Code 时，讨论的话题从：
“AI 能写出这个函数吗？”
转变为：
“AI 能处理这整个工作流吗？”
一旦这个问题出现，你就不再思考代码生成。
你开始思考系统。
而系统才是真正的杠杆所在。
## 真正的瓶颈不是智能
大多数人认为 AI 失败是因为模型不够聪明。
实际上，瓶颈往往是上下文。
想象一下，你雇佣了世界上最优秀的工程师，却不给他们：
❌ 文档
❌ 项目历史
❌ 编码规范
❌ 架构决策
❌ 以往 Bug 的知识
即使是最聪明的工程师也会举步维艰。
不是因为他们能力不足。
而是因为他们在没有上下文的情况下工作。
AI 模型面临着完全相同的问题。
这也解释了为什么两个开发者使用同一个模型会得到完全不同的结果。
一个获得了惊人的成果。
另一个得到了平庸的输出。
这种差异通常不在于智能。
而在于上下文管理。
## 上下文正成为新型基础设施
大多数 AI 讨论集中在提示词上。
但提示词只是可见的表层。
在每个成功的 AI 工作流之下，都隐藏着庞大的基础设施。
该基础设施包括：
→ 记忆系统
→ 知识存储
→ 上下文检索
→ 工作流编排
→ 评估循环
→ 安全控制
→ 验证管道
→ 性能监控
正是这些系统决定了 AI 是能真正派上用场，还是仅仅作为一个昂贵的自动补全引擎。
如今构建这些层的公司，实际上正在构建 AI 时代的操作系统。
## 代理式开发的崛起
这就是软件发展的方向。
不是一个 AI。
而是多个专门的 AI。
想想现代工程组织是如何运作的。
你不会雇佣一个人做所有事情。
你有专家。
研究员。
架构师。
审查员。
安全工程师。
QA 工程师。
技术文档撰写者。
运维人员。
同样的模式也正出现在 AI 工作流中。
一个现代代理系统可能看起来像这样：
研究代理
↓
架构代理
↓
实现代理
↓
测试代理
↓
安全代理
↓
文档代理
↓
部署代理
每个系统都有特定的职责。
每个系统都专注于特定的问题。
它们在一起表现得更像是一个工程组织，而不是聊天机器人。
这也是为什么许多最先进的 Claude Code 用户不再构建提示词。
他们在构建工作流。
## 记忆可能比模型更重要
AI 中最被低估的转变之一，是记忆日益增长的重要性。
大多数模型的能力都在不断提高。
它们之间的差距正在缩小。
但记忆能产生复合优势。
想想人类工程师。
经验之所以重要，是因为经验创造了记忆。
记忆创造了直觉。
直觉创造了更好的决策。
没有记忆：
每个项目都从零开始。
每个错误都会重演。
每个教训都会消失。
每个工作流都必须重新创建。
这效率极低。
这就是为什么现代 AI 系统越来越关注：
→ 会话持久化
→ 长期记忆
→ 模式提取
→ 知识积累
→ 工作流演进
→ 持续学习
未来不仅仅是更聪明的模型。
未来是拥有记忆的更聪明的系统。
## 大多数人忽略的隐藏层
AI 栈中最有趣的部分不再是模型。
而是围绕模型的一切。
三个开发者可以使用完全相同的 Claude 模型。
一个得到普通的结果。
一个得到优秀的结果。
一个围绕它建立了一家软件公司。
区别不在于智能。
而在于基础设施。
获胜的技术栈看起来越来越像这样：
模型
↓
记忆
↓
工作流
↓
评估
↓
安全
↓
自动化
↓
执行
大多数人只关注第一层。
最高杠杆存在于其下的所有层级。
## 为什么这感觉像当年的云计算革命
如今许多开发者将代理工作流视为可选项。
这与十五年前人们对云计算的看法完全一致。
人们当时想：
“我自己也能运行服务器。”
随后云基础设施成为了标准。
Git 也经历了同样的过程。
容器也是如此。
CI/CD 同样如此。
每一次基础设施转变最初看起来都像是提高生产力的技巧。
然后它变成了竞争优势。
最终它变成了默认的工作方式。
代理式开发正在遵循同样的模式。
今天它是实验性的。
明天它将是标配。
## 新的开发者技能组合
多年来，软件工程的成功很大程度上与实现能力挂钩。
未来可能截然不同。
最具杠杆作用的开发者将越来越专注于：
设计工作流。
管理上下文。
构建评估系统。
创建记忆架构。
协调专门的代理。
定义验证流程。
构建执行管道。
工作将不再是生产代码。
而是指挥智能。
在许多方面，开发者正从构建者演变为指挥者。
## 这将通向何方
这种演进出奇地清晰。
第一阶段
开发者 + 编辑器
第二阶段
开发者 + AI 助手
第三阶段
开发者 + AI 团队
第四阶段
开发者 + AI 操作系统
大多数开发者目前处于第二阶段和第三阶段之间。
下一个巨大的飞跃发生在 AI 不再像是一个工具，而开始像是基础设施时。
在那时，单个工程师不仅编写软件。
他们将协调一整套专门的系统网络。
研究。
规划。
实现。
测试。
安全。
文档。
部署。
协同运行。
## 最后的思考
大多数人仍然关注模型大战。
Claude vs GPT。
GPT vs Gemini。
开源 vs 闭源。
这些辩论很有趣。
但它们最终可能没有人们想象的那么重要。
更大的故事是，软件开发本身正在变得“代理化”。
赢家不一定是拥有最聪明模型的开发者。
而是那些围绕这些模型构建最聪明系统的开发者。
这就是为什么 Claude Code 成为了如此重要的信号。
它不仅仅是另一个编程工具。
它是软件工程在智能变得可编程时的早期一瞥。
一旦这种情况发生，问题就不再是：
“AI 能写代码吗？”
问题变成了：
“AI 可以接管软件开发生命周期的多大一部分？”
这个答案似乎每个月都在增长。
而这还只是这个故事最早的章节。
## 相关链接
- [Suryansh Tiwari](https://x.com/Suryanshti777)
- [@Suryanshti777](https://x.com/Suryanshti777)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [6:43 PM · May 29, 2026](https://x.com/Suryanshti777/status/2060311043004666250)
- [73.9K Views](https://x.com/Suryanshti777/status/2060311043004666250/analytics)
- [View quotes](https://x.com/Suryanshti777/status/2060311043004666250/quotes)
---
*导出时间: 2026/5/30 10:37:26*