跳转到内容

AI

标签「AI」下的 7 篇文章

全程 Vibe Coding 做了一个股票分析系统,我的一些技巧

最近全程 Vibe Coding 了一个股票分析系统。

第一版大概用了 15 个小时。

比较有意思的是,这 15 个小时里,大部分实现都不是我一行一行写出来的,而是 Codex 按照我给的计划自己往前推进。

我做的更多是给方向、补充约束、看结果、提调整意见。

这次体验让我对 Vibe Coding 又有了一些新的感受。

以前说 AI 写代码快,更多是在说“它能帮我补代码、修 bug、写页面”。

但这一次,我更明显地感觉到:如果前置计划足够清楚,Codex 真的可以像一个执行力很强的工程协作者,把一个项目从 0 推到第一版可用。

当然,这里说的是股票分析系统的工程实现。

它不是投资建议系统,也不代表生成出来的分析结果就可以直接用于决策。

我关心的重点,是这次 Vibe Coding 的工程过程。

很多人用 AI 做项目,第一句话可能是:

帮我做一个股票分析系统。

这句话当然可以开始,但它太空了。

AI 会做,但它只能根据自己的理解去猜。

它会猜页面长什么样,猜后端接口怎么设计,猜数据怎么组织,猜你想要哪些分析指标,猜要不要登录,猜要不要缓存,猜要不要图表。

猜得多了,项目就容易偏。

这次我没有让 Codex 猜。

我先给了一个非常详细的计划方案。

里面包括系统目标、技术栈、模块边界、页面结构、数据流、接口设计、核心功能、优先级、实现步骤、验收标准。

不是一句“做个系统”。

而是告诉它:

  • 这个系统先解决什么问题
  • 第一版做到什么程度
  • 哪些功能必须有
  • 哪些功能可以后面再补
  • 前端有哪些页面
  • 后端有哪些接口
  • 数据怎么流转
  • 什么情况下算跑通

这一步非常关键。

因为 AI 的执行力很强,但它需要一个明确的方向。

方向越模糊,它越容易“看起来很努力”,但做出来不是你想要的东西。

把 AI 当执行团队,而不是许愿机

Section titled “把 AI 当执行团队,而不是许愿机”

这次我最大的体会是:Vibe Coding 不是许愿。

不是我说一句“我要股票分析系统”,然后等它变出一个完整产品。

更好的心态是,把 Codex 当成一个执行团队。

我负责产品判断和架构方案。

它负责大量实现、联调、修复和补齐细节。

这两件事不能混在一起。

如果我把方向也完全交给 AI,它可能会做得很快,但最后会越来越像“它理解中的产品”。

如果我只把它当自动补全,那又浪费了它完整读项目、改项目、跑命令、修错误的能力。

比较舒服的方式,是把目标和边界给清楚,然后让它充分执行。

就像你带一个工程同事做项目。

你不会只说“随便做个股票系统”。

你也不会每一行代码都盯着他写。

你会说清楚目标、约束、优先级和验收标准,然后让他推进。

Codex 也是这样。

我现在越来越觉得,给 AI 的计划不能只是“想法列表”。

想法列表对人有用,但对 AI 来说还不够。

它更需要任务链。

比如不要只写:

做股票列表、股票详情、分析报告。

而是写成:

  1. 先搭建项目结构,确认前后端能启动。
  2. 再实现股票基础数据模型和接口。
  3. 再做股票列表页面。
  4. 再做股票详情页。
  5. 再接入分析指标。
  6. 再补图表展示。
  7. 最后跑构建,修复类型和样式问题。

这样 Codex 就知道先后顺序。

它不会一上来就纠结一个复杂图表,也不会在后端模型没定的时候先写一堆页面。

任务顺序越清楚,它越能自主推进。

这次第一版能比较顺地跑下来,很大一部分原因就是计划里已经把路径铺好了。

AI 不是不知道怎么做。

它最怕的是不知道先做什么,做到哪里停,什么叫完成。

股票分析系统很容易一开始就想做复杂。

各种指标、K 线、财务数据、新闻情绪、行业对比、AI 解读、风险提示。

这些都可以做。

但第一版不能全塞进去。

我这次的策略是先跑通主链路。

先有股票列表。

再有详情页。

再有基础分析。

再有图表和展示。

先让用户能点进去、看得到数据、读得到分析结果。

第一版最重要的不是完美,而是闭环。

闭环跑通以后,再优化体验、样式、指标和数据质量。

这对 Vibe Coding 尤其重要。

因为 AI 很擅长在已有结构上继续补东西。

但如果一开始结构就混乱,它补得越快,后面整理成本越高。

所以我更愿意先让它完成一个清晰的小闭环,再逐步加功能。

这次我没有只让 Codex 写代码。

我让它自己读项目、改文件、跑构建、看报错、继续修。

这是 Vibe Coding 和普通聊天式写代码很不一样的地方。

以前用 AI,很多时候是它给一段代码,我复制过去,然后自己跑。

报错了,再贴错误回来。

这个过程其实很割裂。

而 Codex 可以在项目里直接工作,它能看到文件结构,也能运行命令。

所以我更倾向于让它完成一个闭环:

  • 先理解项目
  • 再修改代码
  • 再运行检查
  • 再根据错误修复
  • 再继续验证

我只在关键节点做判断。

比如它修复方向不对,我再介入。

比如它做得太复杂,我让它收回来。

比如页面气质不对,我重新描述目标。

其他重复的调试工作,就交给它自己处理。

这会省很多精力。

Vibe Coding 里,人最重要的工作之一是验收。

不是 AI 写完就结束了。

尤其是股票分析系统这种项目,表面看起来能跑,不代表真的对。

我会检查几个东西:

  • 页面是不是能正常打开
  • 列表和详情是不是能串起来
  • 接口返回结构是不是稳定
  • 空数据和异常状态有没有处理
  • 构建是否通过
  • 图表是否遮挡
  • 分析文案是否过度自信
  • 有没有把展示工具写成投资建议

最后这个点很重要。

股票分析系统可以做趋势展示、指标汇总、风险提示、数据对比。

但它不能给人一种“照着买就行”的感觉。

所以我会让它在文案和产品边界上保持克制。

这也是人要负责的地方。

AI 可以帮你实现功能,但什么东西该不该这样表达,还是要人判断。

这次还有一个感受:提示词当然重要,但上下文更重要。

如果项目结构、技术栈、计划方案、验收标准都很清楚,提示词不需要写得多花。

你只要说:

按计划继续实现下一阶段。

或者:

根据当前报错修复构建问题。

或者:

保留现有架构,不要引入新的复杂依赖。

它就能接着往下做。

但如果上下文缺失,你写再多漂亮提示词,它也可能跑偏。

所以我现在更重视前置文档。

把项目目标、模块边界、接口约定、数据模型、优先级写清楚。

这些内容既是给人看的,也是给 AI 看的。

文档越清楚,AI 越像一个熟悉项目的协作者。

文档越模糊,AI 越像一个手很快但刚进组的人。

这次 15 个小时做出第一版,我并不觉得自己“没参与”。

只是参与方式变了。

以前我更多是在写代码细节里消耗时间。

现在我更多是在做这些事:

  • 定义目标
  • 拆分阶段
  • 控制范围
  • 判断取舍
  • 验收结果
  • 修正方向

这其实更像产品负责人加架构师的角色。

AI 把大量执行工作接走了,但人的判断没有消失。

甚至更重要了。

因为执行速度越快,方向错了的代价也越大。

以前方向错了,可能写两小时才发现。

现在方向错了,AI 可能很快帮你实现一大片。

所以 Vibe Coding 不是让人不用思考。

它是把人的思考从“怎么写这一段代码”,往上推到了“这个系统应该怎么长出来”。

我觉得最重要的一句话是:计划越清楚,AI 的自主执行能力越强。

Codex 这次能在 15 个小时左右把第一版跑通,不只是因为它代码能力强。

更重要的是,我给了一个足够具体的计划。

它知道要做什么,知道先做什么,知道做到什么程度算完成,也知道哪些地方不要越界。

Vibe Coding 的技巧,不是写一句神奇提示词。

而是把你的想法整理成 AI 可以执行的工程上下文。

你给它一个模糊愿望,它会给你一个模糊结果。

你给它一个清晰方案,它就能变成一个很强的执行者。

这也是我现在越来越喜欢 Vibe Coding 的原因。

它不是替我做决定。

它是在我把决定说清楚以后,能够将任务推进到验收版本。

聊聊我对 MCP 的一点理解

全称模型上下文协议(Model Context Protocol)。这是由 Anthropic 推出的一项开放标准,目标是为大型语言模型和 AI 助手提供一个统一、标准化的接口,使 AI 能够轻松操作外部工具并完成更复杂的任务。

通过使用 MCP,Claude 或 ChatGPT 等 AI 应用程序可以连接到数据源(如本地文件、数据库)、工具(如搜索引擎、计算器)和工作流(如专门的提示词),从而使它们能够获取关键信息并执行任务。 可以将 MCP 想象成 AI 应用程序的 USB-C 接口。正如 USB-C 为连接电子设备提供了一种标准化方式一样,MCP 也为连接 AI 应用程序和外部系统提供了一种标准化方式。

就拿我开发的 AI LocalBase 来说吧。AI LocalBase 是一个本地化的知识库和数据管理工具,它可以帮助用户在本地存储和管理各种数据,并通过 AI 助手进行智能查询和操作。 虽然是本地化,但它也可以支持 OpenAPI 和 MCP 协议。通过 MCP 协议,AI LocalBase 可以和 Claude、Cursor、Codex 这类 AI 应用连接起来,使用户能够通过自然语言与本地知识库进行交互。

MCP 协议连接层架构示意图

放到 AI LocalBase 这个项目里看,MCP 其实没有那么玄。

本质上,它还是启动一个后端服务,然后暴露一个符合 MCP 协议的接口,给其他 AI 应用看。

只不过这个接口不是普通业务接口。

普通 HTTP API 更多是给前端页面、脚本或者其他服务调用的。调用方需要提前知道接口路径、参数格式和业务含义。

MCP 接口面对的是 AI 应用。它要让对方能够先发现能力,再决定怎么调用。

比如 AI LocalBase 后端启动后,可以暴露一个 MCP 入口。Claude、Cursor、Codex 这类工具作为 MCP Client 连进来之后,先问后端:

你有哪些工具?

你有哪些资源?

你支持哪些操作?

后端再把自己的能力按 MCP 的方式描述出去。

例如:

  • 可以列出知识库
  • 可以检索某个知识库
  • 可以读取文档片段
  • 可以生成带来源的回答
  • 可以查看索引状态
  • 在有权限时,也可以上传文档或重建索引

这样一来,AI 应用访问的就不是 AI LocalBase 的网页,而是 AI LocalBase 暴露出来的一组能力。

架构上大概就是上面这张图表达的链路:AI 应用通过 MCP Client 连到 AI LocalBase 后端暴露的 MCP 入口,再由后端去访问知识库、文档、向量索引和检索服务。

这个时候,AI LocalBase 就不只是一个可以打开的本地知识库工具了。

它还变成了其他 AI 应用可以调用的知识库后端。

这也是我理解 MCP 的一个关键点:它不是替代业务系统,而是让业务系统把自己的能力用一种标准方式暴露出去。

真正有价值的地方,不是“我又多写了一个接口”,而是这个接口背后有一套能力发现、工具描述、权限控制和调用返回的协议约定。

所以 MCP Server 不是把所有内部接口原样丢给 AI。

更好的做法是站在 AI 应用的视角重新整理能力。

比如对外暴露 search_knowledge_base,而不是暴露一堆底层查询接口。

比如返回检索结果时,不只返回文本,还要返回来源、置信度、文档 ID、chunk 信息,方便 AI 继续组织答案。

比如写入、删除、重建索引这种操作,就不能和普通查询放在同一个权限层级里。

说白了,MCP 的工程价值在于:让后端服务多了一层面向 AI 应用的能力出口。

如果用代码表达,它其实可以很朴素。

下面这些不是完整实现,更像是把核心链路拆开看:后端启动时挂一个 /mcp 入口,然后在这个入口里处理 MCP 的初始化、工具发现和工具调用。

比如在 Go + Gin 后端里,可以大概这样挂路由:

func RegisterRoutes(r *gin.Engine, cfg Config, deps Dependencies) {
api := r.Group("/api")
if cfg.MCP.Enabled {
mcp := NewMCPHandler(deps.KnowledgeBaseService, deps.SearchService)
api.POST(
"/mcp",
RequireAPIKey(),
RequireScope("mcp:read"),
mcp.Handle,
)
}
}

这里的重点不是 /api/mcp 这个路径本身。

重点是:AI LocalBase 后端启动以后,多暴露了一个 MCP 协议入口。其他 AI 应用不是直接访问页面,而是通过这个入口发现和调用后端能力。

MCP 请求底层可以理解成一类 JSON-RPC 消息。后端收到请求以后,根据 method 分发到不同处理逻辑。

type MCPRequest struct {
JSONRPC string `json:"jsonrpc"`
ID any `json:"id,omitempty"`
Method string `json:"method"`
Params json.RawMessage `json:"params,omitempty"`
}
func (h *MCPHandler) Handle(c *gin.Context) {
var req MCPRequest
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, rpcError(req.ID, -32700, "invalid json"))
return
}
switch req.Method {
case "initialize":
c.JSON(http.StatusOK, h.initialize(req.ID))
case "tools/list":
c.JSON(http.StatusOK, h.listTools(req.ID))
case "tools/call":
c.JSON(http.StatusOK, h.callTool(c.Request.Context(), req.ID, req.Params))
default:
c.JSON(http.StatusOK, rpcError(req.ID, -32601, "method not found"))
}
}

tools/list 可以理解成 AI 应用进来以后先问一句:你这里有什么能力?

后端返回的不是普通菜单,而是一组工具描述。

func (h *MCPHandler) listTools(id any) MCPResponse {
return MCPResponse{
JSONRPC: "2.0",
ID: id,
Result: map[string]any{
"tools": []map[string]any{
{
"name": "list_knowledge_bases",
"description": "列出当前用户可以访问的知识库",
"inputSchema": map[string]any{
"type": "object",
"properties": map[string]any{},
},
},
{
"name": "search_knowledge_base",
"description": "在指定知识库中检索相关文档片段",
"inputSchema": map[string]any{
"type": "object",
"properties": map[string]any{
"knowledgeBaseId": map[string]string{"type": "string"},
"query": map[string]string{"type": "string"},
"topK": map[string]any{"type": "integer", "default": 5},
},
"required": []string{"knowledgeBaseId", "query"},
},
},
},
},
}
}

当 AI 应用决定调用 search_knowledge_base 时,后端再把这个工具调用转成内部业务服务调用。

func (h *MCPHandler) callSearchKnowledgeBase(
ctx context.Context,
args SearchKnowledgeBaseArgs,
) (MCPToolResult, error) {
hits, err := h.search.Search(ctx, SearchRequest{
KnowledgeBaseID: args.KnowledgeBaseID,
Query: args.Query,
TopK: args.TopK,
})
if err != nil {
return MCPToolResult{}, err
}
return MCPToolResult{
Content: []MCPContent{
{
Type: "text",
Text: formatSearchSummary(args.Query, hits),
},
},
Structured: map[string]any{
"query": args.Query,
"hits": hits,
},
}, nil
}

这里其实就能看出 MCP Server 的位置了。

它不是向量数据库。

它也不是 RAG 本身。

它只是把 AI LocalBase 已经有的检索能力,包装成 AI 应用能发现、能理解、能调用的工具。

客户端配置也可以很简单。比如一个支持 HTTP MCP 的 AI 应用,可能只需要知道 MCP 服务地址和访问凭证:

{
"mcpServers": {
"ai-localbase": {
"type": "http",
"url": "http://localhost:8080/api/mcp",
"headers": {
"Authorization": "Bearer lb_xxx"
}
}
}
}

这样配置之后,AI 应用就可以把 AI LocalBase 当成一个外部能力源。

用户问问题时,AI 应用可以先通过 MCP 调用 search_knowledge_base,拿到相关文档片段,再基于这些片段组织回答。

所以从代码角度看,MCP 并不是多神秘的东西。

它就是一层协议适配。

只不过这层适配面向的是 AI 应用,所以它不只要能调用,还要能描述能力、限制权限、返回结构化结果,并且让后续的 Agent 工作流继续往下走。

Vibe Coding 一段时间后,我的一些新感受

Vibe Coding 又用了有一段时间。

一开始接触它的时候,更多是新鲜感。看到 AI 能读项目、改文件、跑命令、修问题,会觉得这东西多少有点离谱。

但用久一点之后,新鲜感会慢慢退下去,剩下的就是一些更真实的体感。

它确实提高了效率。

但它也不是魔法。

以前做一个功能,很多时间会花在重复劳动上。

比如找文件、改样式、补类型、处理小 bug、跑构建、看报错。

这些事情不难,但很碎。

碎事情多了,人就容易烦。

Vibe Coding 最大的变化,是它把这些碎事情接过去了一部分。很多时候,我只需要描述清楚目标,它就可以帮我把第一版做出来。

这带来的不是简单的“少写几行代码”。

而是反馈变快了。

以前一个想法可能要等自己慢慢写完,才能知道效果行不行。现在可以更快看到一个版本,然后再判断它是不是对。

这点很重要。

因为很多想法不是想出来的,是做出来之后才知道哪里不对。

AI 写代码很快。

有时候快得让我有点不放心。

它会非常自信地修改文件,也会非常自然地补一些它认为合理的逻辑。

问题是,它的“合理”不一定等于我的“合适”。

比如一个页面,它可能会加很多解释文案,让功能看起来更完整;但我的博客更适合保持安静、简洁。

比如一个样式,它可能会顺手加背景、卡片、动效;但我可能只需要一个很轻的交互反馈。

所以用 Vibe Coding 越久,我越觉得验收很重要。

不是它写完就结束了。

而是它写完之后,我要重新看一遍:

  • 有没有改过头
  • 有没有偏离原来的设计
  • 有没有引入不必要的复杂度
  • 有没有破坏已有习惯
  • 有没有只是“看起来很努力”

有时候 AI 的代码没错,但气质不对。

这就需要人来判断。

以前我会觉得提示词很重要。

现在我觉得,上下文更重要。

一个项目里已经有自己的结构、命名、样式、内容风格和取舍习惯。如果 AI 不理解这些,它就很容易写出一个“能跑但不像这个项目”的东西。

所以我现在更愿意先让它读代码。

先看现有文件。

先理解已有逻辑。

再让它动手。

这和人接手项目其实是一样的。一个靠谱的人不会上来就重构,他会先看看这个项目原来是怎么长出来的。

AI 也一样。

给它足够的上下文,它会更像协作者。

不给上下文,它就更像一个手很快的陌生人。

Vibe Coding 用得越多,我越不觉得人会变得不重要。

相反,人要负责的东西变得更靠前了。

以前我主要关心“怎么实现”。

现在我更多关心:

  • 要不要做
  • 做到什么程度
  • 放在哪里合适
  • 会不会影响长期维护
  • 这个功能是不是符合产品气质

AI 可以帮我往前推,但方向还是要自己定。

如果方向不清楚,AI 只会更快地把混乱实现出来。

这也是我最近很明显的感受:Vibe Coding 不是让人不用思考,而是把思考的位置往上抬。

以前卡在代码细节里。

现在卡在产品判断里。

听起来好像还是会卡。

但卡得高级一点。

还有一个很现实的问题:AI 参与越多,项目越需要规则。

比如文件怎么命名,文章放哪里,数据抽到哪里,样式怎么复用,哪些信息不能写进仓库。

如果这些规则不清楚,AI 每次都会根据当下情况做一个“看起来可以”的选择。

短期没问题。

长期就会慢慢乱。

所以我最近反而更重视项目规范。

比如博客按年份月份归档,URL 用 slug 固定;友链和技术栈抽到 data;部署信息用 .env;新增文章用脚本生成。

这些事情看起来不酷。

但它们能让 AI 更好地工作,也能让未来的自己少骂几句过去的自己。

现在再看 Vibe Coding,我已经不太把它当成一个炫技词了。

它更像一种新的工作方式。

不是我把所有事情交给 AI。

而是我负责目标、边界、判断和验收,AI 负责承担大量具体执行。

这个分工如果配合得好,效率确实会高很多。

但如果人自己没想清楚,它也会很快把问题放大。

所以我现在对 Vibe Coding 的感受很简单:

它不是让开发变得不用动脑。

它是让开发者必须更清楚地知道,自己到底想要什么。

决策会变得越来越重要。

AI 编辑器工具的一点观察

最近一直在想一类工具。

类似 Cursor 这样的 AI 编辑器工具平台。

从去年开始,市面上出现了很多新的编辑器产品。它们大多不是从零开始做一个全新的 IDE,而是选择基于开源的 VS Code 平台继续往上搭。

这个选择其实很现实。

VS Code 已经有成熟的编辑体验、插件生态、终端、调试、文件管理和开发者习惯。重新做一套编辑器,成本太高,也很难让开发者迁移。

所以大家更愿意站在 VS Code 的基础上,把真正的差异放到 AI 能力上。

我用过一些类似工具,比如腾讯的 CodeBuddy、阿里的 Qoder,还有字节的 Trae。

它们给人的第一感觉都很熟悉。

因为底层体验都绕不开 VS Code。

文件树、编辑区、终端、快捷键、插件习惯,这些东西不用重新教育用户。开发者打开之后,不会有太强的陌生感。

所以现在这类工具的竞争,已经不太是“谁更像一个编辑器”。

大家的地基差不多,真正的差异开始出现在 AI 层:

  • 谁能更好地理解项目。
  • 谁能更稳地修改多文件。
  • 谁能把任务拆得更清楚。
  • 谁能在执行过程中少犯错。
  • 谁能把结果验证到位。

这些问题,开始比传统编辑器功能更重要。

每个平台都会有自己想强调的 Agent 能力。

比如阿里的 Qoder,有“专家执行团”这种偏多角色协作的设计。

Trae 里也有 Solo 这种更偏独立执行任务的模式。

这些名字背后,其实都在回答一个问题:

AI 到底应该以什么方式参与开发?

是作为一个回答问题的助手?

还是作为一个能拆任务、改代码、跑命令、检查结果的执行者?

我感觉现在的趋势很明显:大家都不满足于“问答式 AI 编程”了。

单纯聊天已经不够。

开发者真正想要的是:

我给你一个目标,你能不能理解项目,然后一步步把事情做完?

这就是 Agent 开始变重要的原因。

最早 AI 编程给人的印象,更多是代码补全。

写一半,它补一半。

后来变成 Chat。

你问它一个问题,它回答你一段解释,或者给一段代码。

现在越来越多工具在往执行系统走。

也就是:

读项目 -> 理解需求 -> 修改文件 -> 运行检查 -> 根据结果继续调整

这个变化很大。

因为它改变的不只是“写代码速度”,而是开发流程本身。

以前 AI 像是一个在旁边回答问题的人。

现在它开始像一个能参与工作的协作者。

当然,这并不意味着可以完全放手。

Agent 越强,人越需要判断方向。

它可以帮你做很多具体事情,但你仍然要知道目标是什么、边界在哪里、什么东西不能乱改、结果是否真的符合需求。

最近还有一个新的趋势:很多平台开始推出移动端。

这件事挺有意思。

以前开发工具基本都绑定在电脑上。哪怕是 AI 编辑器,本质上也还是一个桌面工作台:打开项目、读文件、改代码、跑命令。

但移动端出来之后,入口变了。

它更像是把 Agent 从编辑器里拆出来,放到一个随时可以对话的地方。

有些未完成的工作,或者临时想到的事情,不一定非要坐到电脑前才能处理。

比如:

  • 路上想到一个需求,让 Agent 先整理方案。
  • 临时发现一个 bug,让 Agent 先定位可能原因。
  • 让它继续某个没做完的任务。
  • 让它总结项目状态。
  • 让它根据上下文生成一个待办清单。

这时候手机不是用来完整开发的。

它更像一个轻量入口。

真正的执行可能还是在云端、远程环境或者本地项目里完成,但人和 Agent 的交互,不再必须发生在电脑前。

这会让 AI 编程工具从“编辑器产品”继续往“工作流产品”走。

桌面端负责深度开发,移动端负责随时调度。

我觉得这类工具后面的竞争,可能不只是模型本身。

模型当然重要。

但真正拉开差距的,可能还有这些东西:

  • 上下文组织能力。
  • 项目索引能力。
  • 多文件修改能力。
  • 终端和测试集成。
  • Agent 任务规划。
  • 错误恢复能力。
  • UI 和交互设计。
  • 对开发者工作流的理解。

如果只是接入一个模型,其实很容易被复制。

但如果一个工具能把模型、编辑器、终端、文件系统、Git、测试和任务流整合得很顺,那它就会变成真正的平台。

这也是为什么大家都在做自己的 Agent。

模型是发动机,但工具平台决定这辆车怎么开。

用这些工具的时候,我有一个很明显的感受:

它们都还在快速变化。

有些时候很惊艳,一个任务丢进去,它可以读项目、改文件、跑检查,最后给出还不错的结果。

有些时候也会很狼狈,改一半跑偏,理解错上下文,或者给出看似完整但实际没验证过的结果。

所以我现在更愿意把它们看成一种新的工作流,而不是一个稳定成熟的终点。

它们正在把开发者从“每一行都自己写”推向“定义目标、审查过程、把控结果”。

这和我之前接触 Vibe Coding 的感受也能连起来。

AI 工具越强,人的角色越往上移。

不是不写代码了,而是不再只盯着代码本身。

如果移动端这个方向走通,开发者和工具的关系会再变一次。

以前是:

我打开编辑器,然后开始工作。

以后可能会变成:

我想到一个任务,先丢给 Agent,让它继续推进。

这也是为什么移动端值得关注。

它不一定是为了在手机上写代码,而是为了让 AI 参与工作的入口变得更随身。

下一个 AI 编辑器工具平台会是什么样子?

Section titled “下一个 AI 编辑器工具平台会是什么样子?”

从对话到主动编辑,现在把 Agent 装进口袋,下一个阶段呢?

我觉得它可能不只是更聪明的聊天窗口,也不只是更强的代码补全。

AI 编辑器正在从“写代码的工具”,变成“管理开发过程的入口”。

如果说过去的编辑器是人操作代码的地方,那么下一代 AI 编辑器,可能会变成 Agent 和人一起推进项目的地方。人不再只是盯着每一行代码,而是更多地定义目标、判断方向、确认结果。

做 AI 本地优先知识库三个月后,我发现 RAG 没那么简单

上周基本都在更新我的 AI 本地优先知识库。

说是更新,其实更像是把一个放了一个多月的项目重新捡起来,拍掉灰,再试着往前推几步。

从发布到现在,差不多快三个月了。

项目地址是:veyliss/ai-localbase

Star 到了 300+。这个数字说大不大,说小也不小。对一个个人项目来说,能被三百多人点一下星,已经说明它至少击中过一小部分人的需求。

但我也很清楚,中间有一个多月没怎么更新,所以 Star 涨得慢下来也很正常。

开源项目有时候像一条很细的火线。你持续更新,它就偶尔亮一下;你停下来,它就慢慢变暗。不是项目突然没价值了,而是互联网上每天都有太多新的东西流过去。

重新看这个项目的时候,第一感觉是:

它还是一个 Demo。

不是不能用,也不是只有一个空壳。

它已经能跑起来,方向也比较明确:本地优先、知识库、AI 问答、RAG、个人数据掌控。

但离“一个成熟产品”还有距离。

Bug 还不少,体验也不算很好。有些流程能走通,但不够顺。有些功能看起来有了,但真的连续使用时,边角问题会一个个冒出来。

这也是个人项目很真实的一面。

发出来的时候,更多是在表达一个想法:

我想做一个本地优先的 AI 知识库。

但真正要让别人舒服地用起来,靠一个想法远远不够。

这次回来更新,主要做了两件事:优化 UI,优化检索。

UI 的问题比较直观。一个工具能不能让人继续用下去,很多时候不是取决于它有没有某个大功能,而是打开之后顺不顺、清不清楚、有没有那种“我愿意继续点下去”的感觉。

检索就更核心了。一个知识库项目,如果检索不准,后面 AI 回答再漂亮也没有意义。

RAG 的链路里,LLM 往往是最显眼的部分,但真正影响回答质量的,很多时候是前面的检索。

这也是我这几天最明显的感受:

RAG 不是接一个模型,再塞一点文档,就自然变聪明。

真正做起来才发现,RAG 的难点不只在“调用大模型”。

模型只是最后一步。

前面还有一整套不太显眼、但很要命的链路:

  • 文档怎么解析。
  • 内容怎么切分。
  • 怎么向量化。
  • 怎么检索。
  • 怎么重排序。
  • 怎么拼上下文。
  • 怎么让答案有依据。

以前看 RAG 的概念图,会觉得它很清晰:

用户问题 -> 检索资料 -> 交给模型 -> 生成答案

但真正落到项目里,它就不是一条那么干净的线了。

文档内容可能很乱,切分可能切断语义,向量检索可能召回不准,模型可能忽略上下文,回答可能没有引用依据。这些问题不会在 Demo 截图里出现,但会在真实使用里一点点暴露。

也正因为这样,我越来越觉得 RAG 是一个工程问题,不只是一个 AI 概念。

这个项目一开始很强调本地优先。

我很喜欢这个方向。

知识库本来就带有很强的个人属性。笔记、文档、想法、项目资料,这些东西放在本地,用户自己掌控,会让人更安心。

所以最开始我很自然地选择了 Ollama。

本地模型、本地运行、本地数据,听起来非常完整。

但现实很快给了我一巴掌。

太慢了。

在普通机器上,本地模型的体验并不好。回复一次两次都很勉强,更不用说连续对话、长上下文、知识库检索之后再生成回答。

本地优先的理念是好的,但如果体验慢到让人不想继续用,那它就会从“安全感”变成“阻力”。

这件事让我重新思考一个问题:

本地优先是不是等于只能使用本地模型?

后来我觉得,不一定。本地优先更重要的是数据和控制权。用户的数据应该尽量保存在本地,知识库应该由用户自己掌控,项目不应该强绑定某个平台。

后面我加入了 API 接入能力。

这样项目不再只依赖 Ollama,也可以接入市面上很多模型。

这不是放弃本地优先,更像是给项目留出两个出口:

想要完全本地,可以走 Ollama。
想要更好体验,可以走 API。

我现在更愿意把它理解成:

数据本地优先,模型选择开放。

这个取舍比一开始更现实,也更接近一个工具真的要被使用时的样子。

这几天还有一个很强烈的感受:自己的知识储备还不太够。

以前以为做一个 AI 知识库,重点是把产品形态搭起来。现在发现,产品形态只是外壳。里面真正难的是检索、向量化、上下文组织和回答质量。

向量化这块尤其明显。Embedding 模型怎么选?中文效果怎么样?切片多大合适?什么时候只用向量检索,什么时候要结合关键词检索?要不要重排序?

这些问题都不是一句“接入向量数据库”就能解决的。它们需要实验,也需要积累。

我现在还在补这些东西。

所以,如果给这个项目现在的状态做一个描述,我会这样写:

方向是对的,但还不够好用。

它已经证明了一些事情:

  • 本地优先知识库是有需求的。
  • AI 问答和个人知识库结合是有吸引力的。
  • 但体验、速度、检索质量和稳定性都还需要继续打磨。

Star 300+ 当然让我开心。

但我也知道,Star 不是产品成熟的证明。

真正的证明是:有人能把它装起来,导入自己的资料,连续用几天,还愿意继续打开。

这比 Star 更难。

写到这里,感觉这不是一篇项目总结,更像是给自己留的一张便签。

提醒自己不要被概念骗得太轻松。

RAG 很热,本地优先也很好听,AI 知识库也很有想象空间。

但真正做起来,还是那些很具体的东西:

  • 一个按钮是否清楚。
  • 一次检索是否准确。
  • 一段回答是否有依据。
  • 一个模型是否太慢。
  • 一个新用户能不能顺利跑起来。

这些东西不酷,但它们决定项目能不能从 Demo 往前走。

项目现在还不成熟。

但至少,它还在往前。

这几天重新更新它的时候,我又找回了一点刚开始做它时的感觉:不是很确定,但挺想继续看看它能长成什么样。

软考高级架构师考试后的一个感受

昨天,也就是 2026 年 5 月 23 日,去参加了软考高级系统架构设计师考试。

考完之后最明显的感受是:这类考试真的在越来越快地贴近新的技术趋势。以前提到架构,更多想到的是分层、缓存、消息队列、高并发、数据库、微服务这些传统工程问题;但这次做题时,AI、模型、多模态这些内容已经很自然地出现在题目里了。

这种感觉还挺直接的。

不是那种“AI 作为热点,被强行塞进试卷”的感觉,而是它开始变成架构师应该了解的背景知识之一。

上午选择题做下来,感觉整体还可以。

时间上比较充裕,没有那种一路卡住、最后疯狂赶题的感觉。很多题还是围绕软件工程、架构设计、数据库、网络、安全、项目管理这些基础内容展开,只要平时有积累,大多数题都能比较顺地往下做。

比较有意思的是,题型很快就来到了 AI 和模型相关内容。

印象里有一道和 Transformer 相关的题,也有一道涉及多模态的题。看到这些题的时候,会明显感觉到考试范围已经不只是传统软件架构知识了。

这其实也合理。

现在很多系统已经不只是“业务系统 + 数据库 + 缓存 + 接口”这么简单。越来越多项目会接入大模型能力,可能涉及文本生成、向量检索、多模态理解、智能测试、智能客服、知识库问答等场景。

架构师如果完全不了解这些内容,后面做系统设计时确实会越来越吃力。

案例题对我来说还是有一些难。

选择题更多是知识点识别和判断,案例题则更像是把知识放进一个具体场景里,让你分析系统问题、补全架构设计、选择方案、说明理由。

这个部分很考验表达能力,也考验对架构方法的熟练程度。

有时候不是完全不知道,而是知道一些点,但要在有限时间里组织成比较完整、规范、有条理的答案,并不容易。

这也提醒我,备考不能只停留在“看过概念”。案例题需要练的是:

  • 能不能看懂业务场景。
  • 能不能识别系统中的关键矛盾。
  • 能不能把架构方案和问题对应起来。
  • 能不能用比较规范的语言写出答案。

这和实际做架构也很像。真实工作里,知道某个技术名词没有太大意义,关键还是能不能把它放到合适的系统问题里。

这次考试让我比较在意的一点,是 AI 相关内容的出现频率。

选择题里出现了 Transformer、多模态,论文题里也直接出现了“向量数据库”和“多模态大模型在移动智能测试框架中的应用”。

这说明考试已经不只是把 AI 当成一个新名词,而是在尝试把它放进架构设计语境里。

比如向量数据库不是单独存在的知识点,它背后对应的是:

  • 文本向量化。
  • 相似度检索。
  • RAG 检索增强生成。
  • 知识库问答。
  • 语义搜索。
  • 大模型应用的数据底座。

多模态大模型也不是简单知道“能处理图片和文本”就够了。它进入移动智能测试框架时,可能会涉及:

  • UI 截图理解。
  • 测试步骤生成。
  • 异常页面识别。
  • 测试用例自动补全。
  • 文本、图像、操作行为的联合分析。

这些东西已经开始和软件工程、测试框架、系统架构结合起来了。

论文题:四个方向都挺有代表性

Section titled “论文题:四个方向都挺有代表性”

这次论文题是四选一,题目大概是:

  1. 六边形架构设计。
  2. 向量数据库。
  3. 论高并发系统设计。
  4. 论多模态大模型在移动智能测试框架中的应用。

这四个题其实很有代表性。

六边形架构偏架构思想,重点是领域逻辑和外部依赖的隔离。

高并发系统设计是传统架构高频题,缓存、限流、削峰、异步、分库分表、读写分离、降级熔断这些内容都能展开。

向量数据库和多模态大模型则明显代表新趋势,考察的是架构师能不能把 AI 相关能力纳入系统设计。

如果从稳妥角度看,高并发系统设计可能是很多人比较熟悉的方向。它素材多、案例多,也比较容易结合实际项目经验展开。

但从趋势角度看,向量数据库和多模态大模型这两个题很值得重视。

它们释放了一个信号:以后软考高级架构师可能会越来越多地考察 AI 时代下的软件架构能力。

这次考完,最大的感受不是某一道题难不难,而是知识体系真的需要更新。

传统架构能力还是基础。数据库、缓存、消息队列、微服务、高并发、安全、可用性、可扩展性,这些东西不会过时。

但只靠这些已经不够了。

现在还要补上大模型相关的工程知识:

  • Transformer 的基本概念。
  • 向量数据库和语义检索。
  • RAG 应用架构。
  • 多模态模型的输入输出方式。
  • AI 能力如何接入现有业务系统。
  • 模型服务的成本、延迟、稳定性和安全边界。

这些内容不一定都要学到算法研究层面,但作为架构师,至少要知道它们能做什么、不能做什么、适合放在系统里的哪个位置、会带来哪些工程风险。

这次软考高级架构师考试给我的一个提醒是:

架构师的知识边界正在被 AI 拉宽。

选择题里出现 Transformer 和多模态,论文题里出现向量数据库和多模态大模型,这些都说明 AI 已经逐渐进入软件架构的主干知识里。

对我来说,选择题感觉还可以,案例题仍然需要继续练。更重要的是,后面复习和学习时,不能只看传统架构内容,也要把 AI 工程化、大模型应用架构、向量检索和多模态场景补起来。

考试只是一个节点。

真正值得记录的,是它让我看到技术趋势已经走到试卷上了。

接触 Vibe Coding 八个多月后的感受

接触 Vibe Coding 已经八个多月了。

回头看,这段时间给我带来的变化非常大。它不只是让我多认识了一些 AI 工具,也不只是让我写代码的速度变快了。更重要的是,它改变了我看待开发这件事的方式。

以前我更关注技术本身。

我会想这个功能应该怎么实现,代码怎么写,框架怎么选,接口怎么设计,数据库结构怎么拆。很多时候,注意力会自然落在“如何把代码写出来”这件事上。

而现在,我越来越多地开始关注产品本身。

这个功能为什么要做?用户会怎么使用?流程是不是顺?页面是不是清楚?这个需求背后真正要解决的业务问题是什么?这些问题慢慢变得比“代码怎么写”更靠前。

这就是 Vibe Coding 对我最大的影响。

在更早的时候,我使用 AI 的方式其实很简单。

去年的上半年,AI 对我来说更多还是一个开发辅助工具。它主要停留在 Web 式的 Chat 形态里,我会问它一些问题,让它帮我解释概念、检索资料、分析报错、生成一些代码片段。

那个阶段的 AI 很像一个随时在线的助手。

它能帮我查东西,也能帮我补充思路,但大多数时候,真正的开发过程还是由我自己主导。我要自己拆任务、自己打开项目、自己修改文件、自己调试和验证。

AI 参与了过程,但没有真正进入开发工作流的中心。

那时候我对它的理解也很朴素:它可以提高效率,可以减少搜索成本,可以帮我更快理解一些不熟悉的知识。

但我还没有意识到,它会在后面改变整个开发方式。

后来,Agent 的概念越来越火。

我开始看到各种 CLI 工具出现,也开始频繁听到 token、上下文、模型网关、提示词、工具调用、代码代理这些词。AI 不再只是一个聊天窗口,它开始进入终端、进入编辑器、进入项目目录,甚至可以直接阅读代码、修改文件、运行命令、检查结果。

这和以前完全不一样。

以前是我把问题复制给 AI,然后把答案再搬回项目里。现在则更像是 AI 直接坐进了项目现场,和我一起看代码、改代码、验证代码。

这时我也开始加入 Vibe Coding 的行列。

刚开始的时候,我其实并不知道这些工具应该怎么用。面对各种模型、API、CLI、代理配置,我会有点茫然。它们看起来都很强,但真正落到自己的项目里,还是需要一段适应过程。

我需要理解它们的边界。

哪些事情可以交给它?哪些事情必须自己判断?什么时候应该让它改代码?什么时候只是让它分析?上下文应该怎么给?任务应该怎么拆?

这些并不是看一篇教程就能立刻掌握的。

后来我逐渐知道了 New API 这类整合型网关,也开始理解它们在 AI 工作流中的意义。

模型越来越多,不同模型有不同能力、价格和使用限制。如果每一个工具都单独配置,就会很分散。整合型网关的意义在于,它能把不同模型入口统一起来,让工具调用变得更稳定,也更容易管理。

再后来,我接触到了 Claude Code 这类工具。

它让我真正感受到“AI 参与编码”这件事和普通问答的区别。

普通问答更像是你问一句,它答一句。CLI 编码工具则更像是你把它放进项目里,它可以沿着任务往前走:阅读文件、理解结构、修改代码、运行检查、再根据结果继续调整。

这时候,AI 就不只是回答问题,而是在参与完成工作。

当然,这并不意味着我可以完全放手。

相反,我越来越感觉到,使用这类工具时,人要承担更高层次的判断。你要知道目标是什么,知道验收标准是什么,知道哪里不能乱动,知道生成的代码是否符合项目长期维护的方向。

AI 可以很快,但方向仍然要由人来定。

过去我做一个东西,第一反应常常是技术问题。

页面怎么写?接口怎么接?状态怎么管理?样式怎么调?

现在我会先想产品问题。

这个页面存在的目的是什么?用户第一眼应该看到什么?如果他想继续阅读,路径是不是顺?如果他在移动端打开,会不会困惑?如果内容越来越多,列表是否还能承载?如果未来要部署、维护、持续写文章,流程是不是足够轻?

这种变化很明显。

因为当 AI 可以承担大量具体编码工作后,我的注意力就被释放出来了。我不再需要把所有精力都压在每一行代码上,而是可以站得稍微高一点,看整个产品的结构和体验。

这并不是说技术不重要。

技术仍然重要,而且越到后面越重要。只是技术不再是唯一中心。它更像是实现产品目标的手段,而不是最终目的。

以前我可能会因为某个技术点很有意思就想做点东西。现在我会先问:这个东西解决了什么问题?它对用户、对内容、对长期维护有什么价值?

Vibe Coding 也让我更关注业务流程。

一个功能不是孤立存在的。它前面有入口,后面有结果,中间有状态变化和用户决策。只把某个页面写出来,并不代表功能真的完成。

比如一个博客站,不只是能展示文章就够了。

还要考虑:

  • 新文章怎么创建。
  • 分类和标签怎么维护。
  • 首页如何呈现内容价值。
  • 列表页如何让读者快速判断是否要点进去。
  • 文章页如何让阅读体验稳定。
  • 部署后如何只专注维护内容。

这些都不是单纯的代码问题,而是产品流程问题。

当 AI 能帮我更快完成具体实现后,我反而会花更多时间思考这些流程是否合理。

我会更在意一个功能放在系统里是不是自然,一个页面是不是为后续内容增长留好了空间,一个交互是不是符合读者直觉。

这其实是更接近产品视角的思考。

这八个多月里,我最大的感受是:AI 把很多“执行层面的阻力”变小了。

以前想到一个功能,可能要先考虑技术栈、查文档、写样板代码、调样式、修报错。很多时候,还没真正验证想法,就已经被实现细节消耗掉了。

现在不同了。

我可以更快把想法变成可运行的东西,再通过实际效果判断它是否值得继续优化。

这会让开发节奏发生变化。

以前更像是先想很久,再动手实现。现在更像是先做出一个版本,然后不断观察、调整、迭代。

AI 给我的不是简单的偷懒,而是更短的反馈周期。

当反馈周期变短,人就更容易围绕结果做判断,而不是长时间停留在假设里。

使用 Vibe Coding 越久,我越觉得人并没有变得不重要。

相反,人变得更重要。

因为 AI 可以生成代码,但它不一定知道什么是适合你的。它可以给出方案,但它不知道你真正想要的产品气质。它可以完成任务,但它不会天然理解你的长期规划。

所以,人需要做这些事情:

  • 定义目标。
  • 拆解任务。
  • 判断取舍。
  • 控制范围。
  • 验收结果。
  • 维护产品方向。

如果没有这些判断,AI 很容易把事情做得很快,但不一定做得正确。

这也是我慢慢学到的一点:Vibe Coding 不是随便让 AI 写代码,而是学会用清晰的目标和上下文引导它,把人的判断和 AI 的执行力结合起来。

这段经历让我发生了几个明显变化。

第一,我更愿意从产品角度看问题。

我不再只问“这个功能怎么写”,而是会先问“这个功能为什么存在”。

第二,我更重视流程。

页面、内容、工具、部署、维护,它们应该连成一条顺畅的链路,而不是一个个孤立的点。

第三,我对学习 AI 相关知识更有动力。

从模型到上下文,从 CLI 工具到网关,从提示词到任务拆解,这些内容不再只是概念,而是会真实影响我每天的开发方式。

第四,我开始更相信个人项目的可能性。

以前一个人做完整产品会觉得很重。现在虽然仍然不轻松,但至少很多原本消耗人的细节可以被 AI 分担。一个人的上限,正在被工具重新拉高。

接触 Vibe Coding 的这八个多月,对我来说像是一次开发方式的迁移。

我从把 AI 当作问答工具,慢慢转向把它当作开发协作者。也从更关注技术实现,逐渐转向关注产品本身、业务流程和最终结果。

这种变化不是一夜之间发生的。

它是在一次次尝试工具、配置模型、修改项目、验证结果的过程中慢慢形成的。

现在的我依然还在学习 AI,也还在摸索更适合自己的工作流。但有一点已经很明确:未来的开发不会再回到过去那种完全依赖手工推进的状态。

AI 会继续进入开发流程,而我需要做的,是学会站在更高的位置使用它。

把注意力从代码细节里适当抽出来,更多地放到产品、体验、流程和价值上。

这可能就是 Vibe Coding 最吸引我的地方。

它不是让我不再关心技术,而是让我终于有更多精力去关心技术背后真正要完成的事情。