1
00:00:00,320 --> 00:00:03,020
今天我点开了我的OpenClaw智能体77

2
00:00:03,020 --> 00:00:06,640
她推荐给我的一个Github上的开源项目

3
00:00:06,640 --> 00:00:09,920
实际上她很早就在推荐这个项目了

4
00:00:09,920 --> 00:00:11,780
因为别的事情太多了

5
00:00:11,780 --> 00:00:13,480
所以我没有专门来聊她

6
00:00:13,480 --> 00:00:17,500
她现在的实时热度是9.68万克星

7
00:00:17,500 --> 00:00:21,660
可能我从拍摄编辑到发布这个视频的时候

8
00:00:21,660 --> 00:00:24,020
她可能已经突破10万克星了

9
00:00:24,020 --> 00:00:26,680
但在这个大模型满天飞

10
00:00:26,680 --> 00:00:30,840
各种AI工具像韭菜一样割了一茬又一茬的时代

11
00:00:30,840 --> 00:00:33,600
一个针对代码库的底层工具

12
00:00:33,600 --> 00:00:35,560
能逼近10万斤的量级

13
00:00:35,560 --> 00:00:38,200
这就说明她精准的切中了

14
00:00:38,200 --> 00:00:41,560
全球开发者的某一种集体需求

15
00:00:41,560 --> 00:00:43,260
这个项目叫Graphify

16
00:00:43,260 --> 00:00:46,200
她的核心愿景听上去就像是

17
00:00:46,200 --> 00:00:49,680
为了AI编程时代而量身定制的救世主

18
00:00:49,680 --> 00:00:52,420
她说我们要把你的代码库

19
00:00:52,420 --> 00:00:54,860
变成一个结构化的知识图谱

20
00:00:54,860 --> 00:00:56,700
让AI去查询它

21
00:00:56,700 --> 00:00:58,780
而不是去盲目的搜索它

22
00:00:58,780 --> 00:01:02,820
如果你最近一年经常用AI辅助写代码

23
00:01:02,820 --> 00:01:06,160
那你绝对能对这句话产生强烈的共鸣

24
00:01:06,160 --> 00:01:09,780
我们现在用AI写代码最大的痛点是什么呢

25
00:01:09,780 --> 00:01:12,080
是AI的逻辑不够好吗

26
00:01:12,080 --> 00:01:12,940
不是

27
00:01:12,940 --> 00:01:15,200
而是它根本找不到文件

28
00:01:15,200 --> 00:01:18,320
当你面对一个包含几十个微服务

29
00:01:18,320 --> 00:01:21,300
几百个文件的祖传代码库的时候

30
00:01:21,300 --> 00:01:25,000
AI的上下文窗口就像是一个拿着手电筒

31
00:01:25,000 --> 00:01:26,820
在黑夜里摸索的盲人

32
00:01:26,820 --> 00:01:31,000
他只能看到光斑照亮的那几百行代码

33
00:01:31,000 --> 00:01:35,320
一旦涉及到跨文件的调用和隐蔽的依赖关系时

34
00:01:35,320 --> 00:01:37,160
他就会开始胡说八道

35
00:01:37,160 --> 00:01:40,940
所以如果能有一张上帝视角的地图

36
00:01:40,940 --> 00:01:45,360
把每一个函数每一个类每一个接口是怎么调用的

37
00:01:45,360 --> 00:01:47,440
全部结构化都喂给AI

38
00:01:47,440 --> 00:01:51,540
是不是就意味着AI agent从此打通了任督二脉

39
00:01:51,540 --> 00:01:54,240
获得了完整的工程理解力呢

40
00:01:54,240 --> 00:01:56,880
为了验证这个极度性感的假设

41
00:01:56,880 --> 00:01:59,680
我安排Hermis agent做了一次实验

42
00:01:59,680 --> 00:02:05,440
我让Hermis把Graphify直接接到了我的底层Codex agent里面

43
00:02:05,440 --> 00:02:07,800
当然我自己可以手动测试

44
00:02:07,800 --> 00:02:12,040
不过我对我自己调教的Hermis智能体有足够的信心

45
00:02:12,040 --> 00:02:15,000
所以我交代他把我的真实生产环境

46
00:02:15,000 --> 00:02:18,680
也就是一套名为OmniHunter的量化情报系统

47
00:02:18,680 --> 00:02:20,800
直接扔到了他的手术台上

48
00:02:20,800 --> 00:02:23,440
在这个视频里我会告诉你

49
00:02:23,440 --> 00:02:27,280
当我用9个极其刁钻的真实架构问题

50
00:02:27,280 --> 00:02:30,800
去拷问这个被知识图仆武装起来的AI时

51
00:02:30,800 --> 00:02:32,400
到底发生了什么

52
00:02:32,820 --> 00:02:35,220
这个结论可能会打破你的认知

53
00:02:35,220 --> 00:02:40,540
它不仅揭示了当前代码图谱的惊人潜能与现实边界

54
00:02:40,540 --> 00:02:45,920
更想我们展示了在通往完全自主的AI软件工程师的道路上

55
00:02:45,920 --> 00:02:49,780
横杠在我们面前的最后一道高墙究竟是什么

56
00:02:49,780 --> 00:02:51,160
在讲实验之前

57
00:02:51,160 --> 00:02:52,980
我必须先花一点时间

58
00:02:52,980 --> 00:02:56,380
向Graphify这个项目的创造者们说一声谢谢

59
00:02:56,380 --> 00:02:59,580
因为当我第一次在本地运行它的时候

60
00:02:59,580 --> 00:03:02,360
它给到我的震撼是无与伦比的

61
00:03:02,360 --> 00:03:05,680
在接下来的时间里我在Omini Hunter

62
00:03:05,680 --> 00:03:07,680
它是我的OpenCloud智能体

63
00:03:07,680 --> 00:03:11,000
在今年3月份参与开发的项目

64
00:03:11,000 --> 00:03:13,000
在这个包含35个核心文件

65
00:03:13,000 --> 00:03:17,500
接近18000行Pathon逻辑的真实项目根目录下

66
00:03:17,500 --> 00:03:20,060
敲下了构建图谱的命令

67
00:03:20,060 --> 00:03:25,000
你猜构建这样一帐包含几十个文件的全局知识图谱

68
00:03:25,000 --> 00:03:26,000
需要多久呢

69
00:03:26,000 --> 00:03:29,320
需要消耗多少大模型的Token呢

70
00:03:29,320 --> 00:03:31,320
答案是不到两秒钟

71
00:03:31,320 --> 00:03:32,720
零个Input Token

72
00:03:32,720 --> 00:03:34,120
零个Output Token

73
00:03:34,120 --> 00:03:35,880
当命令跑完

74
00:03:35,880 --> 00:03:37,940
我的本地多出了三个文件

75
00:03:37,940 --> 00:03:41,840
它们是一个巨大的HTML可视化网页

76
00:03:41,840 --> 00:03:43,840
一个Markdown的架构报告

77
00:03:43,840 --> 00:03:46,600
以及一个庞大的Jason拓普图

78
00:03:46,600 --> 00:03:48,300
打开那份报告

79
00:03:48,300 --> 00:03:49,660
上面冷冰冰的

80
00:03:49,660 --> 00:03:52,620
但又非常具有力量的写着一组数据

81
00:03:52,620 --> 00:03:54,260
280个节点

82
00:03:54,260 --> 00:03:55,640
283条边

83
00:03:55,640 --> 00:03:57,200
35个网络社区

84
00:03:57,200 --> 00:03:58,760
100%提取

85
00:03:58,760 --> 00:04:02,440
那在这280个节点里面

86
00:04:02,440 --> 00:04:04,380
Graphify没有去调用

87
00:04:04,380 --> 00:04:06,480
哪怕一次大原模型的API

88
00:04:06,480 --> 00:04:08,340
那它是怎么做到的呢

89
00:04:08,340 --> 00:04:10,980
它使用了一个名为TreeCeter的

90
00:04:10,980 --> 00:04:12,480
急速解析引擎

91
00:04:12,480 --> 00:04:16,000
它就像是一台工业级的X光扫描仪

92
00:04:16,000 --> 00:04:17,440
把我的Pathon代码

93
00:04:17,440 --> 00:04:20,680
直接剥离成了纯粹的抽象语法术

94
00:04:20,680 --> 00:04:23,180
它精准地扒出了代码里的

95
00:04:23,180 --> 00:04:25,000
类 函数 面量

96
00:04:25,000 --> 00:04:26,940
甚至是Dignote的注释

97
00:04:26,940 --> 00:04:29,980
这就是那句100%提取的含金量

98
00:04:29,980 --> 00:04:32,660
它意味着在这张图谱里

99
00:04:32,660 --> 00:04:34,880
每一条连线 每一个关系

100
00:04:34,880 --> 00:04:36,640
都是在原代码里

101
00:04:36,640 --> 00:04:38,760
白纸黑字写死的物理试试

102
00:04:38,760 --> 00:04:40,380
没有任何一条边

103
00:04:40,380 --> 00:04:43,100
是大模型依靠概率猜出来的

104
00:04:43,100 --> 00:04:44,860
在这个大模型时代

105
00:04:44,860 --> 00:04:47,140
所有的工具都在拼命地

106
00:04:47,140 --> 00:04:48,960
把代码塞给LM

107
00:04:48,960 --> 00:04:51,160
让它去总结去泛化

108
00:04:51,160 --> 00:04:54,960
而Graphify却保持了一种极其罕见的

109
00:04:54,960 --> 00:04:57,280
甚至有些古典的极简与刻制

110
00:04:57,280 --> 00:04:58,960
它拒绝幻想

111
00:04:58,960 --> 00:05:00,020
它只提过

112
00:05:00,000 --> 00:05:01,800
用100%确定性的结构

113
00:05:02,560 --> 00:05:04,600
这种纯文本的零成本

114
00:05:04,860 --> 00:05:07,420
毫秒级零幻觉的提取能力

115
00:05:07,680 --> 00:05:10,500
是他能拿到10万颗星的绝对底气

116
00:05:11,000 --> 00:05:12,040
在这个瞬间

117
00:05:12,280 --> 00:05:13,320
看着屏幕上那张

118
00:05:13,560 --> 00:05:15,360
结构严密的Jason图谱

119
00:05:15,620 --> 00:05:17,400
我甚至觉得我的AI Agent

120
00:05:17,660 --> 00:05:19,460
马上就能天下无敌了

121
00:05:19,960 --> 00:05:21,240
但工具再好

122
00:05:21,500 --> 00:05:23,800
究竟是要在真实战场上检验的

123
00:05:24,320 --> 00:05:25,600
让我用一分钟介绍一下

124
00:05:25,860 --> 00:05:26,620
它的测试把体

125
00:05:26,880 --> 00:05:27,640
OmniHunter

126
00:05:28,160 --> 00:05:29,180
这不是一个玩具

127
00:05:29,180 --> 00:05:31,480
它是一套每天早上在我的

128
00:05:31,740 --> 00:05:33,280
局域网的DEV服务器上

129
00:05:33,780 --> 00:05:34,820
全自动运转的

130
00:05:35,060 --> 00:05:36,600
Door Agent的情报系统

131
00:05:37,380 --> 00:05:39,160
这个系统每天要吞吐来自

132
00:05:39,420 --> 00:05:39,940
Github

133
00:05:40,180 --> 00:05:40,960
Hanker News

134
00:05:41,220 --> 00:05:41,980
Archive论文库

135
00:05:42,240 --> 00:05:42,740
甚至是

136
00:05:43,000 --> 00:05:45,060
华尔街日报的13种异购数据

137
00:05:45,820 --> 00:05:46,840
在它的内部有

138
00:05:47,100 --> 00:05:49,140
4个不同分工的AI智能体

139
00:05:49,400 --> 00:05:49,920
在进行

140
00:05:50,180 --> 00:05:50,940
异步协作

141
00:05:51,460 --> 00:05:53,500
他们有自己的搜MD核心宪法

142
00:05:54,020 --> 00:05:56,580
有互相校验的红队审查机制

143
00:05:56,820 --> 00:05:57,600
有一个负责

144
00:05:57,600 --> 00:05:59,900
核心反升性计算的

145
00:06:00,160 --> 00:06:01,700
V9.1数学引擎

146
00:06:02,200 --> 00:06:06,560
最终将所有情报汇聚到一个包含100多项预测状态的

147
00:06:06,820 --> 00:06:08,360
Master Lock Jason账本里

148
00:06:09,120 --> 00:06:11,160
面对这样一个充满时序状态

149
00:06:11,420 --> 00:06:13,220
文件互相交织的系统

150
00:06:13,220 --> 00:06:16,800
即便是写了十几年代码的资深人类架构时

151
00:06:17,060 --> 00:06:20,140
如果不用ID顺藤摸瓜的看上两天

152
00:06:20,380 --> 00:06:22,440
也会觉得像是在看天书

153
00:06:22,940 --> 00:06:26,280
于是我把Graphified的能力包装成了一个名叫

154
00:06:26,540 --> 00:06:27,560
Graphified Scale

155
00:06:28,060 --> 00:06:32,680
挂载到了底层为minimax M2.7模型的Codex框架上

156
00:06:32,940 --> 00:06:33,960
我补充一下

157
00:06:34,220 --> 00:06:37,540
用能力普通的minimax M2.7是我刻意安排的

158
00:06:37,800 --> 00:06:38,820
如果用墙模型

159
00:06:39,080 --> 00:06:41,640
例如CPT5.6或者Opus 5

160
00:06:41,900 --> 00:06:45,220
那我这个小型的代码库可能就不需要Graphified了

161
00:06:45,480 --> 00:06:49,580
我设计了9个真实并且硬核的架构问题

162
00:06:49,840 --> 00:06:52,640
比如这个系统的真正执行入口在哪里

163
00:06:52,900 --> 00:06:56,480
状态持久化操作到底有哪几个文件负责

164
00:06:56,480 --> 00:06:59,800
如果外部的Graph搜索API失效了

165
00:07:00,060 --> 00:07:02,880
整个代码库的错误链条会怎么传导

166
00:07:03,400 --> 00:07:06,200
然后我设置了极其严格的对照组

167
00:07:06,460 --> 00:07:09,020
第一组我把AI关在小黑屋里

168
00:07:09,280 --> 00:07:10,560
它没有任何图谱

169
00:07:10,820 --> 00:07:12,360
只能像我们人类程序员一样

170
00:07:12,600 --> 00:07:14,920
使用传统的Graph全局搜索

171
00:07:15,160 --> 00:07:16,700
CAD查看文件

172
00:07:16,960 --> 00:07:20,040
或者基于正责的Find来寻找答

173
00:07:20,540 --> 00:07:23,620
第二组我允许AI随意调用图谱工具

174
00:07:23,620 --> 00:07:27,720
它可以让图谱找出两个节点之间的最短路径

175
00:07:27,980 --> 00:07:31,820
或者解释某个模块的全部临界节点

176
00:07:32,580 --> 00:07:34,880
好了我端起咖啡按下回车

177
00:07:35,140 --> 00:07:36,940
让这两个平行宇宙里的AI

178
00:07:37,180 --> 00:07:40,000
开始对着同一个代码库进行解析

179
00:07:40,780 --> 00:07:43,580
当最终的结果呈现在我的屏幕上时

180
00:07:43,840 --> 00:07:45,380
我盯着日志看了很久

181
00:07:46,140 --> 00:07:47,940
先看前8道基础问题

182
00:07:48,460 --> 00:07:49,980
看完这张表你会发现

183
00:07:50,240 --> 00:07:52,040
两组答案的实质性内容

184
00:07:52,300 --> 00:07:53,320
几乎完全一致

185
00:07:54,140 --> 00:07:56,440
有四道题两组答一字不差

186
00:07:56,700 --> 00:07:59,260
有三道题两组答大致一致

187
00:07:59,760 --> 00:08:02,060
但Base Line这一边反而列得更全

188
00:08:02,580 --> 00:08:05,660
只有一道题两组答描述的层不同

189
00:08:06,160 --> 00:08:06,940
其实两组都对

190
00:08:07,180 --> 00:08:08,980
但对的是不同的代码层

191
00:08:09,740 --> 00:08:11,800
这是8道题的整体画面

192
00:08:12,300 --> 00:08:14,360
在进入物理指标对比之前

193
00:08:14,860 --> 00:08:16,400
请先把这一张表的画面

194
00:08:16,660 --> 00:08:17,420
记在脑子里

195
00:08:17,940 --> 00:08:19,220
没有图谱的基线组

196
00:08:19,480 --> 00:08:21,020
耗时142秒

197
00:08:21,020 --> 00:08:23,840
消耗了48494个Token

198
00:08:23,840 --> 00:08:27,420
带了图谱的强化组耗时148秒

199
00:08:27,680 --> 00:08:30,240
消耗了36787个Token

200
00:08:31,000 --> 00:08:32,540
从物理指标上看

201
00:08:32,800 --> 00:08:34,080
图谱确实帮AI

202
00:08:34,340 --> 00:08:36,640
节省了整整24%的Token

203
00:08:36,900 --> 00:08:38,180
因为在强化组里

204
00:08:38,180 --> 00:08:40,220
AI不需要像无头仓一样

205
00:08:40,220 --> 00:08:42,020
把整个文件打印出来看

206
00:08:42,520 --> 00:08:44,580
它直接通过查询图谱节点

207
00:08:45,080 --> 00:08:46,620
砍掉了大量失措的对话

208
00:08:46,880 --> 00:08:48,160
和无效的Cat操作

209
00:08:48,660 --> 00:08:49,180
但是

210
00:08:49,440 --> 00:08:50,980
如果你回头再看一遍

211
00:08:51,480 --> 00:08:53,280
上面那8道题的对比表

212
00:08:53,780 --> 00:08:54,820
并且把它们交出的

213
00:08:55,060 --> 00:08:56,600
实质性架构答案

214
00:08:56,860 --> 00:08:57,880
拿出来对比一下

215
00:08:58,400 --> 00:09:00,180
你会感觉一种奇妙的失落感

216
00:09:00,440 --> 00:09:00,960
就是

217
00:09:01,220 --> 00:09:02,740
两组几乎打拼

218
00:09:03,500 --> 00:09:05,820
无论是找核心文件的调用链

219
00:09:06,060 --> 00:09:07,340
追溯系统入口

220
00:09:07,600 --> 00:09:10,420
还是排查API的故障传导路线

221
00:09:10,680 --> 00:09:11,960
拥有图谱的AI和

222
00:09:12,220 --> 00:09:14,260
只拿了Grab搜索工具的AI

223
00:09:14,520 --> 00:09:15,800
给出的答案质量

224
00:09:16,060 --> 00:09:17,340
找出的文件行号

225
00:09:17,580 --> 00:09:19,640
竟然几乎是一模一样的

226
00:09:19,900 --> 00:09:21,680
甚至在某些具体问题上

227
00:09:21,940 --> 00:09:25,260
基线组的纯文本搜索还略占上风

228
00:09:25,780 --> 00:09:26,300
比如在找

229
00:09:26,540 --> 00:09:28,080
状态持久化文件时

230
00:09:28,600 --> 00:09:31,160
纯搜索找出了6个关联文件

231
00:09:31,160 --> 00:09:34,240
而过度依赖局部图谱的强化组

232
00:09:34,480 --> 00:09:35,520
只找出了4个

233
00:09:36,020 --> 00:09:37,040
为什么会这样呢

234
00:09:37,560 --> 00:09:39,360
因为我们在无意中低估了

235
00:09:39,600 --> 00:09:40,880
现代AI的基础能力

236
00:09:41,400 --> 00:09:42,420
这前8个问题

237
00:09:42,680 --> 00:09:44,480
本质上都是在做一件事

238
00:09:44,720 --> 00:09:46,780
就是在代码库里找特征

239
00:09:47,540 --> 00:09:50,100
这就像你要在一座巨大的图书馆里

240
00:09:50,360 --> 00:09:51,640
找一句莎士比亚的名言

241
00:09:52,400 --> 00:09:53,940
图谱组相当于拿到了一本

242
00:09:54,200 --> 00:09:56,240
极其精密的数字索引卡片

243
00:09:56,760 --> 00:09:57,780
而基线组呢

244
00:09:58,040 --> 00:09:59,580
基线组虽然没有卡片

245
00:10:00,000 --> 00:10:03,140
但它拥有一秒钟翻完十万页书

246
00:10:03,140 --> 00:10:05,100
并且过目不忘的超能力

247
00:10:05,100 --> 00:10:08,480
连Millimax M2.7都能轻易做到

248
00:10:08,480 --> 00:10:10,720
对于目前的顶级大模型来说

249
00:10:10,720 --> 00:10:12,820
找文件 找大码行号

250
00:10:12,820 --> 00:10:14,840
找显性的函数调用

251
00:10:14,840 --> 00:10:17,000
早就不再是它的核心瓶颈了

252
00:10:17,000 --> 00:10:18,940
图谱在这类任务上

253
00:10:18,940 --> 00:10:21,760
只能让它变得更优雅 更省Token

254
00:10:21,760 --> 00:10:25,200
但并不能让它产生质的认知飞跃

255
00:10:25,200 --> 00:10:27,240
这就是这十万星神器

256
00:10:27,240 --> 00:10:29,180
给我的第一个深刻反思

257
00:10:29,180 --> 00:10:31,180
那就是Graph Knowledge

258
00:10:31,180 --> 00:10:34,640
不是Agent的提升自动化效率的淫带

259
00:10:34,640 --> 00:10:38,180
在找的维度上 其实AI早就赢了

260
00:10:38,180 --> 00:10:40,700
如果实验到这里就结束了

261
00:10:40,700 --> 00:10:43,380
那这就只是一个略显平庸的测试

262
00:10:43,380 --> 00:10:47,500
但是在这份文件里 隐藏着第九题

263
00:10:47,500 --> 00:10:50,400
这第九题是ChatGBT帮我

264
00:10:50,400 --> 00:10:53,440
review实验方案时 坚持让我加进去的

265
00:10:53,440 --> 00:10:56,540
它问了一个直击软件工程灵魂的问题

266
00:10:56,540 --> 00:11:00,300
就是假设我要重构Fusion V6 Pi

267
00:11:00,300 --> 00:11:03,780
这个最核心的反升性计算引擎模块

268
00:11:03,780 --> 00:11:07,160
请你告诉我 改动它会牵连炸掉

269
00:11:07,160 --> 00:11:10,880
全系统里的哪些外部文件和数据流呢

270
00:11:10,880 --> 00:11:13,520
这叫变更影响分析

271
00:11:13,520 --> 00:11:16,880
这不是简单搜索 而是在回答一个工程问题

272
00:11:16,880 --> 00:11:20,960
就是修改一个模块会影响哪些其他部分

273
00:11:20,960 --> 00:11:22,960
在跑这道题的时候

274
00:11:22,960 --> 00:11:26,500
强化组的AI显然意识到这是一个重量级任务

275
00:11:26,500 --> 00:11:31,360
我看着它在后台连续触发了三次重量级的图谱查询

276
00:11:31,360 --> 00:11:34,700
它试图用图谱找出Fusion V6 Pi

277
00:11:34,700 --> 00:11:37,760
到其他核心业务脚本之间的路径

278
00:11:37,760 --> 00:11:41,740
这一次图谱能给出一些跨文件的编

279
00:11:41,740 --> 00:11:46,220
但它直接的Graphic Path仍然返回NopathFund

280
00:11:46,220 --> 00:11:49,140
因为HunterPiPiSH是Shell

281
00:11:49,140 --> 00:11:51,220
Fusion V6 Pi是Python

282
00:11:51,220 --> 00:11:56,260
AST解析不会建立Shell到Python的调用编

283
00:11:56,260 --> 00:11:59,180
最终拥有知识图谱的AI

284
00:11:59,180 --> 00:12:03,920
用Graphic JSON整理出了一份完整的分层影响分析报告

285
00:12:03,920 --> 00:12:05,420
直接调用链接

286
00:12:05,420 --> 00:12:06,660
输入依赖

287
00:12:06,660 --> 00:12:07,900
输出依赖

288
00:12:07,900 --> 00:12:09,660
高风险文档约束

289
00:12:09,660 --> 00:12:11,300
核心函数偶合

290
00:12:11,300 --> 00:12:13,020
翻译过来就是

291
00:12:13,020 --> 00:12:16,880
图谱这次不仅找到了文件内部的函数调用

292
00:12:16,880 --> 00:12:20,360
还给了我们一份真实的跨文件影响清单

293
00:12:20,360 --> 00:12:22,580
它不是什么都找不到

294
00:12:22,580 --> 00:12:25,880
它找到了直接调用链加上数据依赖

295
00:12:25,880 --> 00:12:28,320
加上文档约束这三层

296
00:12:28,320 --> 00:12:33,960
但它确实没有找到Shell到Python这种影视的层级关系

297
00:12:33,960 --> 00:12:38,400
所以图谱组仍然比纯Graph的基线组慢了三倍

298
00:12:38,400 --> 00:12:40,800
为什么会发生这种事呢

299
00:12:40,800 --> 00:12:46,640
为什么一个这么强大的代码图谱连基本的跨文件import都连不起来呢

300
00:12:46,640 --> 00:12:52,080
这正是Graphify选择AST-only所付出的影性代价

301
00:12:52,080 --> 00:12:54,380
在这张图谱的认知世界里

302
00:12:54,380 --> 00:12:57,080
它非常清楚Fusion V6 Pi内部

303
00:12:57,080 --> 00:13:00,600
媚函数是怎么调用Compute Matrix的

304
00:13:00,600 --> 00:13:03,500
在文件内部它是全知全能的神

305
00:13:03,500 --> 00:13:07,800
但是它不知道有哪几个外部文件在顶部

306
00:13:07,800 --> 00:13:10,100
偷偷import了Fusion V6

307
00:13:10,100 --> 00:13:11,940
在软件工程学里

308
00:13:11,940 --> 00:13:15,140
这牵扯到一个非常具有哲学意味的差别

309
00:13:15,140 --> 00:13:17,260
就是自知与他知

310
00:13:17,260 --> 00:13:19,480
当我看自己的代码时

311
00:13:19,480 --> 00:13:20,880
我知道我引用了谁

312
00:13:20,880 --> 00:13:22,440
这是显性的自知

313
00:13:22,440 --> 00:13:25,280
但是当我重构一段代码时

314
00:13:25,280 --> 00:13:28,140
我真正害怕的不是我知道我依赖了谁

315
00:13:28,140 --> 00:13:31,320
而是到底有哪些我不知道的陌生角落

316
00:13:31,320 --> 00:13:33,380
在被动的依赖着我

317
00:13:33,380 --> 00:13:35,040
这是隐性的他知

318
00:13:35,040 --> 00:13:38,660
AST-数能瞬间拔出代码的结构

319
00:13:38,660 --> 00:13:41,700
但是要建立精准的他知关系

320
00:13:41,700 --> 00:13:44,940
往往需要极度消耗资源的语言服务器

321
00:13:44,940 --> 00:13:48,120
甚至需要编译器级别的语义分析

322
00:13:48,120 --> 00:13:51,560
或者让大模型介入去做昂贵的推理

323
00:13:51,560 --> 00:13:54,740
Graphify为了保持不到两秒钟

324
00:13:54,740 --> 00:13:57,560
零Token纯本地的极致优雅

325
00:13:57,560 --> 00:14:01,020
AST-only模式选择了一个非常轻量的

326
00:14:01,020 --> 00:14:02,320
结构提取路径

327
00:14:02,320 --> 00:14:06,700
因此它天然更擅长描述代码内部结构

328
00:14:06,700 --> 00:14:09,380
而不是完整的软件运行依赖

329
00:14:09,380 --> 00:14:10,680
这不是失误

330
00:14:10,680 --> 00:14:12,760
这是极其高级的工程取舍

331
00:14:12,760 --> 00:14:15,860
但正是这个取舍让我们看清了

332
00:14:15,860 --> 00:14:17,920
单纯的静态代码股价

333
00:14:17,920 --> 00:14:22,340
根本无法回答千亿发而动全身的工程因果论

334
00:14:22,340 --> 00:14:26,060
那既然图谱在这场给AI找文件的比赛里

335
00:14:26,060 --> 00:14:27,760
没有能实现降维打击

336
00:14:27,760 --> 00:14:31,060
那它接近10万颗星的光环是虚假的吗

337
00:14:31,060 --> 00:14:32,460
绝对不是

338
00:14:32,460 --> 00:14:36,020
当我关掉命令行在游览器里双接打开

339
00:14:36,020 --> 00:14:37,840
那个不需要任何服务器

340
00:14:37,840 --> 00:14:41,900
直接在本地渲染出来的Graph HTML时

341
00:14:41,900 --> 00:14:44,000
我被深深的震撼了

342
00:14:44,000 --> 00:14:46,420
Omini Hunter这个在我的脑海里

343
00:14:46,420 --> 00:14:49,820
始终由一堆冷冰冰的文件名组成的系统

344
00:14:49,820 --> 00:14:53,160
第一次一种有机生命体的物理形态

345
00:14:53,160 --> 00:14:54,460
展现在了我的面前

346
00:14:55,140 --> 00:14:57,640
在这张宏大的可视化图谱里

347
00:14:57,640 --> 00:15:00,460
Graphify利用内置的Layoutube

348
00:15:00,000 --> 00:15:01,720
India社区发现算法

349
00:15:01,720 --> 00:15:04,440
自动把280个散落的节点

350
00:15:04,440 --> 00:15:07,020
聚类成了35个彩色的群落

351
00:15:07,020 --> 00:15:10,640
而且它神奇的给这些群落打上了标签

352
00:15:10,640 --> 00:15:13,780
这里是Omni Hunter大一统加工法的聚落

353
00:15:13,780 --> 00:15:16,600
那里是反身性计算引擎的聚落

354
00:15:16,600 --> 00:15:21,360
边缘处还有Scott01特权注入通道的护城河

355
00:15:21,360 --> 00:15:24,300
在这一刻我突然明白了我的AI

356
00:15:24,300 --> 00:15:25,900
用Graph搜索代码

357
00:15:25,900 --> 00:15:29,760
和我作为人类看这张知识图谱的本质区别

358
00:15:29,760 --> 00:15:31,780
我再说一遍你体会一下

359
00:15:31,780 --> 00:15:33,660
Graph让AI找

360
00:15:33,660 --> 00:15:35,980
而这张图是让我看

361
00:15:35,980 --> 00:15:39,000
找的时候AI是带有目的性的

362
00:15:39,000 --> 00:15:40,600
它知道它要修一个bug

363
00:15:40,600 --> 00:15:42,440
它要找一行具体的代码

364
00:15:42,440 --> 00:15:45,480
就像我们在黑暗的房间里打着手电筒

365
00:15:45,480 --> 00:15:47,460
手电筒的光斑很亮

366
00:15:47,460 --> 00:15:49,700
但我永远看不见整个房间

367
00:15:49,700 --> 00:15:51,680
AI的全文搜索能力

368
00:15:51,680 --> 00:15:54,140
就是一把极其强大的手电筒

369
00:15:54,140 --> 00:15:57,380
那看的时候我是没有必要去聚光的

370
00:15:57,380 --> 00:16:00,280
当我接手一个庞大的祖传代码库时

371
00:16:00,280 --> 00:16:02,080
我不知道该问什么问题

372
00:16:02,080 --> 00:16:04,200
我需要先站在高处

373
00:16:04,200 --> 00:16:06,400
被那35个色彩斑斓的聚落

374
00:16:06,400 --> 00:16:08,980
被那些密密麻麻的枢纽节点

375
00:16:08,980 --> 00:16:11,240
狠狠的在视网膜上震一下

376
00:16:11,240 --> 00:16:16,000
我需要先在大脑里建立起这座代码城市的轮廓

377
00:16:16,000 --> 00:16:19,440
然后我才能详AI问出那个正确的问题

378
00:16:19,440 --> 00:16:24,060
这才是图谱在当下最无法被替代的价值

379
00:16:24,060 --> 00:16:25,920
在今天这个实验里

380
00:16:25,920 --> 00:16:28,680
图谱展现出的价值更多体现在

381
00:16:28,680 --> 00:16:30,800
帮助人类建立系统认知

382
00:16:30,800 --> 00:16:33,820
而不是直接替代agent的搜索过程

383
00:16:33,820 --> 00:16:36,480
它是给陷入代码泥潭的

384
00:16:36,480 --> 00:16:40,020
试图理解这个软件系统到底在干嘛的人类

385
00:16:40,020 --> 00:16:42,980
提供一个能够站上去的认知高底

386
00:16:42,980 --> 00:16:46,180
最后我想跳出这个具体的开源项目

387
00:16:46,180 --> 00:16:49,100
聊聊我脑海中那个一直回荡的终极问题

388
00:16:49,100 --> 00:16:50,880
在这个7月的早晨

389
00:16:50,880 --> 00:16:54,260
当Codex在他的推理日志里写下那句

390
00:16:54,260 --> 00:16:58,360
AST-only mode no crossfind engines

391
00:16:58,360 --> 00:17:01,960
也就是只基于AST分析模式

392
00:17:01,960 --> 00:17:04,300
不包括跨文件关系编试

393
00:17:04,300 --> 00:17:06,660
它其实在向我们暗示

394
00:17:06,660 --> 00:17:09,980
当今所有AI coding agent的最终瓶颈

395
00:17:09,980 --> 00:17:12,520
我们现在的AI缺知识吗

396
00:17:12,520 --> 00:17:13,420
不缺

397
00:17:13,420 --> 00:17:15,980
他们看代码比我们快一万倍

398
00:17:15,980 --> 00:17:18,920
但AI coding agent可能缺少的

399
00:17:18,920 --> 00:17:22,480
是一个面向软件系统的世界模型

400
00:17:22,480 --> 00:17:24,080
什么是世界模型呢

401
00:17:24,080 --> 00:17:28,180
在物理世界里如果我把桌上的水杯推下边缘

402
00:17:28,180 --> 00:17:29,980
不需要等它掉下去

403
00:17:29,980 --> 00:17:33,080
我的大脑就能推演出水杯碎裂的声音

404
00:17:33,080 --> 00:17:37,860
而在软件世界里改动Fusion V6 Pi里的一个数学权重

405
00:17:37,860 --> 00:17:41,260
会不会导致三天后生成的研究报告里

406
00:17:41,260 --> 00:17:44,580
某一篇学术论文的优先级被错误的降级呢

407
00:17:44,580 --> 00:17:46,580
这种跨越了文件

408
00:17:46,580 --> 00:17:47,420
跨越了时间

409
00:17:47,420 --> 00:17:50,740
甚至跨越了用户行为的动态连锁反应

410
00:17:50,740 --> 00:17:54,880
永远不可能写在静态的语法术和局部连接图里

411
00:17:54,880 --> 00:17:56,960
真正的系统是活的

412
00:17:56,960 --> 00:18:00,520
它的依赖关系存在于运行时的数据流里

413
00:18:00,520 --> 00:18:02,640
存在于用户的点击里

414
00:18:02,640 --> 00:18:05,920
存在于极其脆弱的外部API状态里

415
00:18:05,920 --> 00:18:07,520
当前的外挂图普

416
00:18:07,520 --> 00:18:08,860
无论多么精妙

417
00:18:08,860 --> 00:18:14,000
都只是给代码的股价拍了一张极高分辨率的静态X光片

418
00:18:14,000 --> 00:18:19,560
而真正能让AI从高级打资源进化为独立软件架构式的

419
00:18:19,560 --> 00:18:22,860
不是一张更庞大更致命的静态节点图

420
00:18:22,860 --> 00:18:26,860
而是我们能否为AI构建一个能够模拟代码

421
00:18:26,860 --> 00:18:29,440
在不同环境下如何动态形变

422
00:18:29,440 --> 00:18:32,260
如何传导风险的软件世界模型

423
00:18:32,260 --> 00:18:36,080
这可能是目前最前沿模型内化的能力

424
00:18:36,080 --> 00:18:38,320
但当我们开始意识到

425
00:18:38,320 --> 00:18:40,080
看与找的区别

426
00:18:40,080 --> 00:18:44,440
开始区分静态拓扑与动态因果的鸿沟的时候

427
00:18:44,440 --> 00:18:48,320
其实我们已经站在了下一次认知升级的起点

428
00:18:48,320 --> 00:18:50,300
好的 今天视频就先聊到这里

429
00:18:50,300 --> 00:18:51,660
感谢观看 我们下次再见

（完整 Whisper STT 逐字稿，共 429 段，已存於 /tmp/whisper_luN/luN-yydHpYY.srt）