有了 AI 加持，学习新技术效率提升很明显

@liuzimin 是的。举例，前几天我在手动编译 ffmpeg ，打 dockfile 。
中间遇到问题问 AI ，折腾了一天还没搞好。

后来发现 github 上有现成的 dockerfile ，拿来直接用了。

还有一次，利用 Mongodb_restore 命令在不同库之间导数据，遇到报错问 AI ，尝试各种参数都不解决。后来执行 Mongodb_restore --help ， 一看就知道该用哪个参数了。

我想根因在于，大模型核心里面还是概率预测 token ，那么它预测出来的答案，和我遇到的问题的背景信息很难匹配（比如我的 Mongodb_restore 是特定的版本，有特定的参数）。

AI 很容易张冠李戴

@liuzimin 那可能 AI 读取的 CSDN 的

@liuzimin 这其实也给我们程序员提了个醒：在遇到问题的时候，先初步判断下这个问题是否适合用 AI 来找答案。如果一股脑地找 AI ，问题解决不了不说，还会丧失咱们本有的技能

原来学习之前需要先提供权威文件给 ai 啊?!怪不得我的 ai 一直在胡说八道,虚构一些不存在的知识误导我学习

是的，至少 LLM 在 Coding 领域的落地已经是非常可观的了。相当于有个耐心的老师傅时时刻刻陪着你学，帮你扫清小障碍。

真的感恩技术带来的便利。

但是，估计也会带来内卷和竞争。就看谁在 llm 帮助下学的快，学的多。

@albin504 是的。感觉只能靠 AI 提供个思路，不能完全依赖它。真正分析问题还是要靠自己。

@YanSeven 我理解，至少现在来看，即使有了大模型，程序员也得学习新技术，只是侧重点不同。现在需要学的是原理性的、框架性的、需要具备技术选型、优劣判断的能力。

举例，我最近在学习 nvidia GPU 编程的技术。 我如果不系统学习的话，遇到一个特定的问题，AI 是不会提供 GPU 解决思路的，即使提供的，我也可能因为拿捏不准不敢用到生产环境。 我需要具备评判 AI 给出的方案的优劣、是否适配业务的能力。

@YanSeven Coding 是很牛。 这里有个前提，方案还是得靠程序员设计。设计好了合适的方案，AI 来执行实施（ coding ）。

@crocoBaby #11 之前我让 ai 直接启动一个项目，他写的代码全是上个版本的很多不兼容也处理不了，后来每次启动新项目都先把最新版本的 repo 直接 clone 到本地，然后出现问题让他直接阅读源代码，比 context7 好用一点，就是 token 可能有点爆炸

@xctcc 你相当于把源码写进 prompt 了,肯定 token 爆炸,这种情况我建议你本地部署 LLM 做,无限 token

@crocoBaby 给 AI 喂权威资料，现在已经成为 AI 训练的一个难题了。 以公司内部的知识库资料训练为例，假如我们要高很多一个公司内部的行政小助理，训练会遇到以下问题：
（ 1 ）公司内部的知识库上有多篇文章提到公司的考勤制度，其中一些文章写的制度已经过时了，这时候 AI 就需要去判断该采信哪个信息源。
（ 2 ）有些政策和特定的毕竟信息强相关（类似于不同的软件版本不同的参数），在提问时如果没给出很具体的背景信息，AI 只是根据概率给出了概率较大的答案，这时候很可能是错误的答案
（ 3 ）有些知识库的内容本身就是错误的（就是你提到的不权威）

@albin504 我昨晚 youtube 刚好刷到一个 RAG 的教程,应该可以解决你现在遇到这个问题,把你公司的知识库转向量存 db,然后每次推理的时候在 prompt 带上 db 的向量

同样的感受，ai 加速了学习和吸收知识的速度

@albin504 其实就是要求每个入行者都得变成以前的资深程序员。市场以后在招聘的时候也会提高招聘门槛。

@dearmymy #2 你是不是在找 figma 的 mcp ～

@crocoBaby 嗯嗯，谢谢，抽空我也看看。这方面我是门外汉，我只是拼感觉提的几个问题。

@albin504 我也是门外汉,最近才开始学这方面的知识,有好的技巧欢迎分享

你这个数据不太对，dot product 纯 memory bound 的，跑不出来 19 倍差距，明显是刻意避免了优化 cpu 代码(avx 或 O3 开 auto vectorization ）

@qieqie 遇到行家了。我贴一下代码：

```
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <cuda_runtime.h>
#include "common/book.h"

#define N (32 * 1024 * 1024) // 32M elements
#define THREADS_PER_BLOCK 256

// Kernel to initialize data directly on GPU
__global__ void init_data_kernel(float *a, float *b, int n) {
int tid = threadIdx.x + blockIdx.x * blockDim.x;
int stride = blockDim.x * gridDim.x;

for (int i = tid; i < n; i += stride) {
a[i] = 1.0f;
b[i] = 2.0f;
}
}

// Dot product computation kernel (Same as before)
__global__ void dot_product_kernel(float *a, float *b, float *c, int n) {
int tid = threadIdx.x + blockIdx.x * blockDim.x;
int stride = blockDim.x * gridDim.x;

float sum = 0;
for (int i = tid; i < n; i += stride) {
sum += a[i] * b[i];
}

// Shared memory reduction per block
__shared__ float cache[THREADS_PER_BLOCK];
int cacheIndex = threadIdx.x;
cache[cacheIndex] = sum;
__syncthreads();

int i = blockDim.x / 2;
while (i != 0) {
if (cacheIndex < i)
cache[cacheIndex] += cache[cacheIndex + i];
__syncthreads();
i /= 2;
}

if (cacheIndex == 0)
atomicAdd(c, cache[0]);
}

void dot_product_cpu(float *a, float *b, float *c, int n) {
double sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i] * b[i];
}
*c = (float)sum;
}

int main() {
// Host pointers (only for verification)
float *a_host, *b_host, *c_cpu, *c_gpu;
// Device pointers
float *dev_a, *dev_b, *dev_c;

// Allocate host memory (just for CPU verification)
a_host = (float*)malloc(N * sizeof(float));
b_host = (float*)malloc(N * sizeof(float));
c_cpu = (float*)malloc(sizeof(float));
c_gpu = (float*)malloc(sizeof(float));

// Initialize host arrays for CPU calculation
for(int i=0; i<N; i++) {
a_host[i] = 1.0f;
b_host[i] = 2.0f;
}

printf("Vector size: %d elements (%.2f MB per vector)\n", N, (float)N * sizeof(float) / 1024 / 1024);

// --- CPU Computation ---
clock_t start = clock();
dot_product_cpu(a_host, b_host, c_cpu, N);
clock_t end = clock();
double cpu_time = ((double)(end - start)) / CLOCKS_PER_SEC * 1000.0;
printf("CPU Result: %.2f\n", *c_cpu);
printf("CPU Time: %.2f ms\n", cpu_time);

// --- GPU Computation (Zero-Copy Init) ---

// 1. Allocate Device Memory
HANDLE_ERROR(cudaMalloc((void**)&dev_a, N * sizeof(float)));
HANDLE_ERROR(cudaMalloc((void**)&dev_b, N * sizeof(float)));
HANDLE_ERROR(cudaMalloc((void**)&dev_c, sizeof(float)));

start = clock();

// 2. Initialize Data on GPU (No Memcpy from Host!)
int blocksPerGrid = (N + THREADS_PER_BLOCK - 1) / THREADS_PER_BLOCK;
if (blocksPerGrid > 65535) blocksPerGrid = 65535;

init_data_kernel<<<blocksPerGrid, THREADS_PER_BLOCK>>>(dev_a, dev_b, N);
HANDLE_ERROR(cudaGetLastError());

// Reset result
float zero = 0.0f;
HANDLE_ERROR(cudaMemcpy(dev_c, &zero, sizeof(float), cudaMemcpyHostToDevice)); // Tiny copy (4 bytes)

// 3. Compute
dot_product_kernel<<<blocksPerGrid, THREADS_PER_BLOCK>>>(dev_a, dev_b, dev_c, N);
HANDLE_ERROR(cudaGetLastError());
cudaDeviceSynchronize();

// 4. Copy Result Back
HANDLE_ERROR(cudaMemcpy(c_gpu, dev_c, sizeof(float), cudaMemcpyDeviceToHost)); // Tiny copy (4 bytes)

end = clock();
double gpu_time = ((double)(end - start)) / CLOCKS_PER_SEC * 1000.0;

printf("GPU Result: %.2f\n", *c_gpu);
printf("GPU Time (Total including Init on GPU): %.2f ms\n", gpu_time);

// Compare
printf("Speedup (GPU vs CPU): %.2fx\n", cpu_time / gpu_time);

// Cleanup
free(a_host); free(b_host); free(c_cpu); free(c_gpu);
cudaFree(dev_a); cudaFree(dev_b); cudaFree(dev_c);

return 0;
}


```

这个版本是在 GPU 上初始化向量。



AI 给出的第一版是在 CPU 上初始化向量然后 copy 到 GPU ，这个 copy 过程成为了瓶颈（ 200 多 M 数据 copy 花费 64ms ）

@dearmymy 有没有 Adobe AI 软件的 mcp ，能够替代 印刷文件制作的。

降低学习门槛，不像以前问都没有渠道，知识太分散，找都不好找。

哪怕不用 avx intrinsics, -Ofast 这个量级不太差的 cpu 应该 <10ms 。如果数据初始在 host 内存上，加上 h2d d2h 单次运行会比 cpu 直接跑还慢的。
如果你想体验 gpu 的暴力，demo 应该用 GEMM ，还得加 batch

同感，效率神器。以前很多不懂的东西，也不知道有什么关键词搜索，现在 ai 直接点出找问题的方案了。

https://deepwiki.com/

推荐各位一个网站，能够帮你分析源码，还能看 CodeMap

非常赞同，入门新领域快很多。先前遇到没接触过的领域，都不知道怎么入手，查资料都不知道那些专业术语。有 ai 之后描述个大概，ai 就能回答了。

学习速度是提高了，以前还钻研一些细枝末节的东西，现在我都懒得研究了，遇到了再问 ai

有 AI 入门确实快很多，但是基础不牢的话很容易调入 AI 陷阱。典型的例子就是遇到复杂问题的，AI 改一百遍也改不对，此时要你手动分析问题的时候，基础就很重要。
另外就是，看书或者是文档，如果没有详细的查看，光看总结，会错过很多细节，导致自己学的知识点不全面，不牢固。

当然 AI 总体来说对入门或者辅助都是很有用的

cuda 编程相关工作多吗？

@TArysiyehua 34 以前是这样的，复杂问题 ai 改一百遍都不对。 现在几个强的 ai 互相 cr 指出，解决复杂问题的能力大幅度提高了

@TArysiyehua 针对这个情况,纯编程 ai 真是不行,说的就是你 claude,昨天调试遇到一个问题,用 sonnet4.5 死活查不来原因,我都告诉他不对了,还是在那嘴硬.换成 gemini 这种通用大模型,很快就查找出问题了.

@qieqie 大佬说的词我都还没听过，刚开始学了两天

@dxcqcv 不知道。最近业务中用到了 GPU ffmpeg 视频转码。 出于好奇，在了解一些 cuda 编程的知识

AI 确实是加速器，但是细节、品味方面还得自己来。

@Baymaxbowen 谢谢。神器

OP 的领悟很正确，三年前我啃 CSAPP ，1 小时只能啃个 2 页左右，现在有了 llm ，我直接读英文原版，1 小时读 10 页都没太大问题，而且能领悟得更深了，超级爽。ai 时代，底层原理只会越来越重要，代码已经不值钱了，llm 写的代码比任何人类都快且标准，但是它需要资深工程师来引导，一个好的 llm + 资深工程师，比以前的 1 个资深 + 5 个低端工程师效率来得要高得多

@CziL 谢谢分享

是的，以前搜索是为了获得经验和结论，但是这些东西要么散乱、要么隐藏的很深、要么各执一词，人类需要自行收集、整理和总结。现在有 AI 来做这些耗时但成果性较低的工作，几秒就能完成，对效率来说是个质变，还能直接给出可参考的总结结论，人只需要在多个结论中筛选就行，就算有幻觉，提示中让 AI 带上参考链接和来源，再回溯幻觉部分，总的思考成本也比之前大大降低。

但是这都有个前提，就是人类得有分辨 AI 输出结果的能力，如果是纯小白，并且自己没有基础概念、没有辩证的观念和思维逻辑，那么 AI 只会带来更多误导和偏向。普及之后，分化可能更严重，厉害的更厉害，菜的更菜。

大部分问题可以很好解答，但是有些比较复杂的问题，还是可能会出错，需要仔细甄别

看了很多 AI 的帖子，大部分都同意一个观点，就是 AI 替代了初级程序员的角色，在高级程序员的指导下可以更高效的工作。
就一直在想一个问题，AI 替代高级程序员的时间还有多久？工程化能力、框架能力、优劣分辨能力等等，我自己认为并不属于无法数据化、不能喂给 AI 的能力。这条护城河还能维护高级职位多久呢，新人是否还要投入大量时间精力去学习这些东西呢？

@alexhx 科技大佬都说了，未来 10 年大部分职业都会被人工智能取代。
如果要走技术深度路线，新人不学这，那学啥啊？

另外一条路是，培养指挥 AI 办事儿的能力。比如你一个人开一家公司，你懂产品、技术、商业，自己利用 AI 能跑通一个商业模式。

再者就是，向 AI agent 开发方向靠拢

@CziL 请问，你是怎么用 llm 读英文原版的书籍的？整个 pdf 给 llm ，然后要它总结吗？还是自己一页一页的读，然后不懂的问 llm 呢？