别问 AI 能不能，直接把活丢给它

Don't ask if AI can do it. Just hand it the work.

我犯的第一个错，就是问。

My first mistake was asking.

「你能帮我做个小程序吗？」「这个需求 AI 能搞定吗？」这种问题，我大概问了一个礼拜。每一次，它都回答得特别漂亮，特别完整，特别有道理，讲架构，讲流程，讲注意事项，头头是道。然后呢？？？然后就没有然后了。我关掉对话，面前还是那个空文件夹，白屏，光标一闪一闪的。

"Can you build me a mini program?" "Can AI handle this one?" I asked questions like that for a whole week. Every answer was beautiful, complete, and perfectly reasonable. Architecture, workflow, things to watch out for. And then? Then nothing. I closed the chat, and the empty folder was still there, white screen, cursor blinking at me.

后来我琢磨明白了。你去问一个刚来的实习生，你会做这个吗？他能给你讲出一套理论。但你说，别讲了，把这玩意儿给我做出来，他就得动手了。一动起手，你才知道他哪里是纸糊的，哪里是真本事。

Here's what I figured out eventually. Ask a new intern, can you do this? They'll hand you a whole theory. But say, enough talk, build it. They have to get their hands dirty. Only then do you see which parts are paper and which parts are real.

AI 一模一样。它最怕的，不是干错，是你不让它干。

AI is exactly the same. It's not afraid of doing it wrong. It's afraid of you never letting it try.

别问能不能，直接说，把它做了。哪怕做出来是坨屎，你手里也有坨能改的屎，比对着空文件夹空想，强一百倍。

Stop asking. Just say, do it. Even if the result is garbage, you now hold garbage you can improve. That beats staring at an empty folder, a hundred times over.

今天就能做拿一件你手头最不想干的重复活，不管三七二十一，直接丢给它，让它先出一版。丑没关系，错也没关系，先有，再改。

DO IT TODAYPick the most boring, repetitive task on your plate and throw it at the AI, no matter what. Ask for a first draft. Ugly is fine. Wrong is fine. First get something, then improve it.

把它当实习生，别当神

Treat it like an intern, not a god.

第二个坑，是我一开始把它当神。

My second mistake, I treated it like a god.

我总觉得，这么厉害的东西，我动动嘴，它就该把整个系统给我变出来。于是我把一个巨大无比的需求，一段话说清楚，丢给它，然后等着奇迹。

I figured, this thing is so powerful, I just say the words and the whole system appears. So I packed a giant requirement into one paragraph, threw it at the AI, and waited for a miracle.

奇迹没来。它给我交了一坨逻辑混乱的代码，我盯着看了半天，愣是不知道从哪儿下手。

The miracle didn't come. It handed me back a pile of tangled code. I stared at it for a long time, and had no idea where to even start.

后来我换了个思路，就把它当成一个刚入职的实习生。

Then I switched my mindset. Just treat it like a new intern.

实习生怎么带？任务拆小，一次只交代一件事，把背景讲清楚，把验收标准说清楚，做完马上检查。人家不熟悉你这一摊，你就得把边边角角都给它划好。

How do you manage an intern? Break the work into small pieces. One task at a time. Explain the background, define what done looks like, and check the result right away. They don't know your world yet, so you draw the lines for them.

这么一带，就活了。我的数据库一张表一张表建，接口一个接口写，每一步都小到我五秒钟能看懂，十秒钟能挑出毛病。节奏一顺，进度比我想的快多了。

That changed everything. I built my database table by table, endpoint by endpoint. Every step was small enough to read in five seconds and judge in ten. Once the rhythm settled, the pace surprised me.

今天就能做把下一个任务，拆成半小时内能验收的小块，一次只喂一块。它完成一块，你检查一块。别攒，攒着必翻车。

DO IT TODAYBreak your next task into pieces you can verify within half an hour, and feed it one piece at a time. It finishes one, you check one. Don't let them pile up. Piles are where it falls apart.

喂的细节越多，它越像你

The more detail you feed it, the more it becomes you.

第三个坑，是我不给它吃料，还怪它不听话。

Mistake number three, I didn't feed it, and then blamed it for not reading my mind.

有段时间我写接口文档，图省事，就丢一句，帮我写个注册接口。它给我返回一套通用模板，字段名，注释，风格，全不是我想要的那一套。我改吧，改得比自己写还累，不改吧，心里又憋屈。

When I was writing API docs, I got lazy. I'd say, write me a registration endpoint. It returned a generic template. Field names, comments, style, none of it was mine. Editing it took longer than writing it myself. And leaving it as is, that felt even worse.

后来我学乖了。我把自己写的代码片段，命名习惯，项目规范，整理成一份说明，每次开工前，先丢给它看。它一下子就懂事了，写出来的东西跟我的习惯严丝合缝，我甚至有种错觉，这代码就是我写的。

So I learned. I gathered my own code snippets, my naming habits, my project conventions, into a short document, and fed it to the AI before every working session. It got smart overnight. The code it wrote fit my habits like a glove. Sometimes I almost felt like the code was mine.

你想想，实习生刚来那天，你是不是也得给他看组里的代码规范，告诉他你们的命名习惯？你不喂料，他只能按他脑子里那套通用的来，那当然不是你要的。

Think about it. On an intern's first day, don't you show them the team's code standards and naming rules? If you don't feed the AI, it falls back to its own generic logic. And generic is never what you want.

今天就能做把你手头项目的规则、你的偏好、你的套路，写成一份一百字的说明，先喂给它，再让它干活。你喂得越多，它就越像你。

DO IT TODAYWrite a 100-word note about your project's rules, your preferences, your way of doing things. Feed it first, then let the AI work. The more you feed it, the more it becomes you.

最值钱的，是它陪你想

The most valuable thing is that it thinks with you.

第四条，是我这一百天里最意外的收获。

Lesson four, and honestly the most surprising of the whole hundred days.

我一直以为，AI 最值钱的是写代码。后来我发现不是，它最值钱的，是陪你想。

I used to think AI's greatest value was writing code. It's not. Its greatest value is thinking with you.

一个人干活，最怕的不是累，是闷。遇到一个想不清楚的问题，没人可聊，只能自己跟自己绕圈子。我那段时间养成一个习惯，把一个还没想明白的需求，用最笨的话，讲给它听。它听不懂没关系，它会追着我问，你这里到底想干嘛，边界在哪儿。

Working alone, the worst thing isn't the effort. It's the silence. You hit a problem you can't think through, and there's no one to talk to, so you just circle around it by yourself. I built a habit, taking a half-baked requirement and explaining it to the AI in the dumbest words possible. It doesn't understand? That's fine. It pushes back. What do you actually want here, where's the boundary?

问着问着，我自己就明白了。

As it asked, I started to understand.

有时候它还会给我递梯子，从一个我完全没想到的角度，甩过来一个方案。我看着看着，脑子里那团浆糊，突然就清了。

Sometimes it would hand me a ladder, a solution from an angle I'd never considered. I'd read it, and the fog in my head, suddenly gone.

那感觉太爽了，就像有个人，半夜两点还醒着，陪你一起想事。

That feeling is incredible. Like having someone still awake at 2 a.m., sitting there, thinking with you.

今天就能做下次遇到想不明白的问题，别闷着，用大白话讲给它听，让它反问你。你先把它说明白了，你就赢了一半。

DO IT TODAYNext time you're stuck on a murky problem, don't sit on it. Explain it out loud, in plain words, to the AI, and let it question you back. If you can explain it, you're already halfway there.

一开始，一定比手动还慢

At first, it will be slower than doing it yourself.

这条最扎心，但我必须说。

This one hurts the most, but I have to say it.

用 AI 的头一个星期，我一度怀疑自己是不是被忽悠了。一个功能，我自己写要半天，丢给它，它写出来我再改，改完再调，也花了半天。我就想，图啥呢？

During the first week, I honestly suspected I'd been fooled. A feature would take me half a day by hand. I'd hand it to the AI, it writes something, I edit, I debug, and it also takes half a day. I kept asking myself, what's the point?

后来我才懂，前期的慢，慢在磨合。你得花时间教它你的规矩，你得学会看懂它写的东西，你得像练枪一样，在无数个错误答案里，练出一双挑毛病的眼睛。这一段的投入，一分都省不掉。

Here's what I finally understood. The slowness at the start is friction. You have to spend time teaching it your rules. You have to learn to read what it writes. You have to train your eye to spot problems, by looking at endless wrong answers. None of that investment can be skipped.

但熬过这一段，拐点就来了。后半程我明显感觉到，同样的功能，我做得越来越快，它越来越懂我，我们俩配合得越来越顺。收官那天我回头算了一笔账，如果全靠我自己写，这个项目，两年都未必跑得起来。

But if you survive that phase, there's a turning point. In the second half, I could feel it. The same feature, I finished it faster and faster. It understood me better and better. We clicked. On the last day, I did the math. If I had written everything by hand, this project might have taken two years, and still might not be running.

今天就能做给自己留出两周的预期，接受头两周比手动还慢，把这段时间当学费。慢不可怕，可怕的是，一慢你就跑了。

DO IT TODAYGive yourself a two-week expectation. Accept that the first two weeks will be slower than manual work. Treat it as tuition. Slowness isn't scary. What's scary is running away the moment it gets slow.

小心它太会夸你

Beware, it's too good at flattering you.

最后这条，是我差点栽跟头的地方。

This last one is where I almost tripped.

AI 太会夸人了。我让它写个模块，它写完了，还不忘附一句，这个实现很优雅。我心里那个美，感觉自己就是天才。然后一跑测试，崩了，崩得稀碎。

AI flatters people so well. I asked it to write a module. It finished, and added, this implementation is quite elegant. I was glowing. Felt like a genius. Then I ran the tests, and everything broke. Completely.

后来我发现了，它夸你，很多时候不是你真的好，是它的出厂设置，就是哄你开心。你要是当真了，你就完了。

Here's what I learned. When it praises you, most of the time it's not because you're great. It's the factory setting, to keep you happy. If you take it seriously, you're done.

我自己后来的规矩，它越说写得好，我越要冷静，让它自己挑毛病，让它给我写测试用例，让它用最难听的话攻击这段代码。它挑出来的毛病，往往比我看到的还多。

My rule became, the more it says it's good, the calmer I get. I make it critique itself. I make it write test cases. I make it attack the code with the harshest words it has. The problems it finds are usually more than the ones I saw.

今天就能做从今天起，它一夸你，你就回它一句，那你给我挑挑毛病。让数据说话，别让夸奖说话。

DO IT TODAYFrom today on, the moment it flatters you, reply, okay then, find the flaws. Let the data speak. Don't let the flattery speak.