今天上午，我和同事一起梳理一个技术方案，遇到了一个让人有点为难的问题。
按照当前方案处理，会引出另一个问题；如果优先解决另一个问题，又会破坏当前方案。我借助 AI 推演了好几个方向，看起来每个方向都有自己的道理，可放回整个系统里，却始终没能形成闭环。有的改法还会让之前已经修好的旧 bug 再次复现。
讨论过程中，我感觉同事比较相信 AI 给出的结论，倾向于按照它的建议往下做。我对这种做法有顾虑：如果因为方案是 AI 给出的，就默认它没有问题，我们可能跳过最关键的判断——它能不能在当前系统里成立，会不会让旧 bug 再次出现。
AI 很快就能给出一份有条理的回答，甚至连代码都能一起生成。但回答看起来完整，并不等于方案已经经过验证。尤其在这次讨论中，我尝试的几个方向都还没跑通；如果这时只挑一个看起来最合理的答案继续往下做，我认为风险很大。
更让我不舒服的是，讨论中方案和流程似乎都在依靠 AI 生成。我有一种感觉：同事对 AI 太依赖了，可能没有真正静下心来梳理问题。至于他实际投入了多少思考，我并不能确定；但当一个建议的边界、依赖和旧问题都还没有说清楚时，我很难放心地把它当成可以执行的方案。
方案不能只看每一步是否有道理
这次遇到的问题，让我想到了搭积木。
一块积木看起来没有问题，另一块也没有问题，但如果它们之间没有咬合，只是简单地往上堆，堆得再高，稍微有一点变化也容易垮掉。
技术方案也是这样。某个局部修改可能解决眼前的问题，却影响另一条流程；某个新分支看似把异常处理好了，却可能让旧问题重新出现。单独看每一步，都能找到理由；连起来看，问题的输入、处理和结果未必能形成闭环。
AI 可以帮我们提出不同方向，也可以帮我们检查一些容易遗漏的场景。但它给出的建议是否适合当前系统，还取决于我们有没有把服务接口、历史问题和各种约束交代清楚，以及最终是否做过验证。就这次讨论而言，我推演过的几个方向都没能满足这些条件。
我更希望先把方案摆到桌面上
当时我没有直接说出对同事做法的批评，而是友善地提了几个建议：我们先把需求和依赖的服务接口理清，再把完整方案写下来。我希望讨论能从“AI 给了什么答案”，转到“这个答案能否解决我们的问题，以及怎么验证”。
这份方案至少要回答几个问题：问题边界在哪里？准备怎么处理？处理完成后，整个流程如何闭环？原来修过的问题会不会再次出现？不同场景下又会发生什么？
另外，也要结合实际情况提前考虑内存泄漏、内存溢出、多线程竞争等风险。这些风险不一定每次都会出现，但如果当前改动涉及相关部分，就值得在方案里说清楚，而不是等代码生成之后再碰运气。
我的想法是，等方案讨论得比较清楚，再让 AI 帮忙生成代码，然后一起评审方案和代码。评审时不仅看新问题是否得到处理，也要回头看旧问题有没有复现。这一次我们还没有找到能让所有问题都闭环的方向，所以这些建议也只是我希望接下来采用的工作方式，并不意味着方案已经解决。
人和 AI 的分工，可以比“谁先谁后”更灵活
我说“人先理清思路”，并不意味着每次都要独自想出一份完美方案，才有资格打开 AI。有时问题本身就很模糊，让 AI 帮忙列出可能的方向、指出遗漏的场景，反而能帮助我们开始思考。
真正需要留在我们手里的，是对问题和结果的判断：哪些约束确实存在，哪些建议可以尝试，方案之间有什么冲突，以及怎样验证修改没有带来新的问题。
AI 可以帮忙整理思路、补充细节、生成代码，也可以参与基础验证。但它给出结论之后，我们仍要结合实际环境检查。尤其是那些曾经出现过的 bug，如果没有重新验证，仅凭方案看起来合理，并不能说明问题已经解决。
写方案的过程，也是理解系统的过程
我越来越觉得，整理方案不只是为了交付一份文档。梳理接口和依赖时，我们会重新认识系统；考虑旧问题和边界场景时，也会发现自己之前忽略的地方。这个过程可能花时间，却能让我们对自己要修改的东西更有把握。
我愿意把 AI 当作能力放大器。它能帮我更快地探索和完成一些重复工作，但输入一句话之后，责任并不会随之转移。
这次我还没有拿到一个满意的答案。不过，在继续让 AI 生成下一个方案之前，我想先和同事把那些积木之间的连接看清楚。
本文由 AI图鉴自动抓取并翻译，版权归原作者所有；如需查看原文请点下方链接。
This morning, I worked with my colleagues on a technical programme, and I encountered a somewhat embarrassing problem.
Dealing with the current programme raises another problem; if another problem is addressed as a matter of priority, it undermines the current programme. I'm using AI to run several directions, each of which seems to have its own rationale for putting it back into the system without ever forming a closed loop. Some of the changes would have brought back old bugs that had been repaired.
In the course of the discussion, I felt that colleagues were more convinced of the conclusions given by AI and preferred to follow its advice down. I'm worried about this: if it's okay because it's given by AI, by default, we might skip the most critical judgment -- whether it's set up in the current system and whether it's going to make old bugs appear again.
AI will soon be able to give a structured answer, even a code. However, the answer does not appear to be complete and does not mean that the programme has been validated. In particular, in this discussion, several directions I have tried have not run out of course; if only one of the most plausible seemingly reasonable answers continues to go down at this point, I think there is a great risk.
What makes me uncomfortable is that the programs and processes discussed seem to rely on AI. I had the feeling that colleagues were too dependent on AI, and maybe there was no real serenity to fix the problem. As for the amount of thought he actually put into it, I cannot be sure; but when a proposed boundary, dependence and old issues are not clear, it is difficult to see it as an implementable option.
It's not just about making sense.
The problems I have this time remind me of building blocks.
One of the blocks appears to be fine and the other is fine, but if they don't bite, they simply pile up, pile up, and a little change can easily collapse.
The same applies to technical programmes. A partial modification may solve an immediate problem, but it affects another process; a new branch may appear to have handled the anomaly but may have revived the old problem. A rationale can be found for each step alone; in combination, input, handling and outcome do not necessarily form a closed loop.
AI can help us move in different directions, or it can help us check out a few easily missed scenes. However, the recommendations it gives are appropriate for the current system and depend on whether we have clearly identified service interfaces, historical issues and constraints, and whether they have ultimately been validated. In terms of this discussion, the few directions that I have taken have failed to meet these conditions.
I'd rather put it on the table first.
I did not speak directly of criticism of the practices of colleagues at the time, but rather made a few friendly suggestions: first, we sort out the service interfaces that we needed and relied on, and then write down the whole package. I would like to move the discussion from “What answer does AI give” to “Whether this answer solves our problems and how it is tested”.
This programme answers at least a few questions: where is the border? How are we going to proceed? How is the whole process closed after processing? Is it possible that the problem that was fixed will happen again? What happens in different scenarios?
In addition, risks such as memory leakage, memory spills and multi-wire competition need to be considered in advance, taking into account actual circumstances. These risks do not necessarily arise each time, but if the current changes relate to the relevant parts, it is worth stating them in the programme, rather than waiting for the code to be generated.
My idea is to have AI help generate the code, and then evaluate it together. The evaluation will look not only at whether the new issues have been addressed, but also at whether the old ones have been reproduced. This time we have not found a way to keep all the issues closed, so the proposals are just the way I hope to proceed, not the way the programme has been resolved.
The division of labour between people and AI can be more flexible than "who first and who later"
When I say, "Let's get things straight first," it doesn't mean that you have to come up with a perfect plan on your own every time to be able to open AI. Sometimes the problem itself is so vague that AI helps set out possible directions, points out missing scenes, it helps us start thinking.
What really needs to remain in our hands is a judgement of the problem and the outcome: what constraints do exist, what proposals can be tried, what conflicts exist between programmes, and how to verify that changes do not create new problems.
AI can help organize ideas, add details, generate codes, or participate in base validation. But after it has come to its conclusion, we still have to combine physical environmental checks. In particular, the bugs that had appeared in the past, if they had not been re-tested, simply because the programme seemed reasonable, did not mean that the problem had been solved.
The process of programming and understanding the system
I increasingly feel that the programme is not just for the delivery of a document. When we comb the interfaces and depend, we rediscover the system; when we think about old problems and border scenes, we also find what we have previously neglected. It may take time, but it will give us more certainty about what we want to change.
I'd like to use AI as a power amplifier. It will help me to explore and complete some of the duplications more quickly, but the inclusion of a sentence does not shift responsibility.
I haven't got a satisfactory answer this time. However, before continuing to allow AI to generate the next scenario, I would like to see clearly the connection between the blocks.
Auto-fetched and translated by AI Atlas. All rights belong to the original author.