Claude Code 的 3 个隐藏用法,适合每天写材料的人3 Hidden Uses of Claude Code for Daily Writing Tasks


AI free token/AI免费积分

我第一次把 Claude Code 打开的时候,其实有点尴尬。

因为它的名字里带着 Code,界面又在终端 Terminal 里,看起来就像一个程序员玩具。黑底白字,命令行,项目目录,文件读写,乍一看和每天写材料的人没什么关系。

我当时的第一反应也很普通。

这玩意跟我有什么关系。

我又不是每天都在写代码。

后来我硬着头皮试了一段时间,才慢慢发现一个挺有意思的事。Claude Code 表面上是写代码的工具,但它真正厉害的地方,不只是写代码。它厉害在于,它能看见一个文件夹里的上下文,能读一堆文件,能改文件,能记住规则,还能按你的工作流反复执行同一套动作。

这一下就不一样了。

每天写材料的人,最痛苦的往往不是缺一句漂亮话。真正痛苦的是资料太散、版本太乱、口径前后不一致、改完一版又忘了上一版为什么那么写。普通聊天窗口当然也能帮你写,但它经常像临时外援,聊完这轮就散了。

Claude Code 更像是蹲在你资料文件夹里的一个助手,文件都在它眼前,规则也能长期放在项目里。

我试到这里的时候,才觉得它开始有用了。

不过我也必须先说清楚。Claude Code 对小白有门槛。它不是那种打开网页就能用的聊天框,你至少要能接受终端,能把材料放进一个文件夹,能理解什么叫文件路径。它的原始场景确实更偏代码,但只要把代码项目换成材料项目,很多能力就能迁移过来。

我这篇不写程序员玩法。

不写自动提交代码,不写测试,不写部署,不写那些普通人看完立刻关掉的东西。

我只写我觉得对每天写材料的人最有用的 3 个隐藏用法。每个都尽量写清楚,原来怎么干,现在 Claude Code 怎么介入,落地难不难,省在哪里,容易翻车的点在哪里。

PART 01

把资料文件夹变成一个会说话的材料库

第一个隐藏用法,是把资料文件夹变成一个会说话的材料库。

每天写材料的人,最熟悉的痛苦应该是找资料。桌面一个文件夹,微信下载一个文件夹,浏览器下载一个文件夹,历史版本一个文件夹。里面有 Word、PDF、表格、截图、会议记录、别人发来的参考稿,还有自己半年前写过但已经忘了的草稿。

以前我的做法很原始。要写一个新东西,就开始翻文件。打开一个,扫两眼,不对。再打开一个,里面有点用,但版本太老。再打开一个,标题像我要的,内容又不是。十几分钟过去,真正开始写的情绪已经被磨没了。

普通聊天式 AI 也能帮忙,但它有个问题。你得把资料一段一段复制进去。材料少还行,材料一多就很烦。更麻烦的是,它不知道你的文件夹里还有什么,除非你每次都重新喂给它。

Claude Code 的用法就变了。

你可以直接建一个文件夹,把这次写材料相关的资料都放进去。比如这样。

文件夹结构

material-project
  references
    参考资料1.md
    参考资料2.md
    历史版本.md
  drafts
    初稿.md
  notes
    零散想法.md
  CLAUDE.md

这里面最关键的是 CLAUDE.md。它可以理解成项目说明书,也可以理解成给 Claude Code 的长期提醒。你把这次材料的写作规则、禁用词、格式要求、口径边界、读者对象都写进去。以后 Claude Code 在这个文件夹里工作,就能优先参考这些规则。

比如你可以在 CLAUDE.md 里写。

写作规定(CLAUDE.md 示例)

你现在帮助我整理一组普通办公场景下的 AI 工具文章。

写作要求
使用简体中文
段落正常,不要诗歌体
不要写敏感行业和具体单位
不要使用夸张宣传语
每个观点都要落到具体场景
如果信息不足,先标注待确认,不要脑补

然后你让 Claude Code 先做一件事,不是写正文,而是盘点资料。

提示词

请阅读当前文件夹下 references 和 notes 里的资料,帮我生成一份资料地图。

每份资料请说明
主要内容
适合用在哪一段
可复用信息
过期或需要核对的地方

请把结果写入 notes/资料地图.md

资料不再是一堆躺在文件夹里的死文件。它变成了一个可以被问、被整理、被复用的材料库。

以前找资料靠记忆。现在先让 Claude Code 读一遍文件夹,生成资料地图。你要写某个段落时,可以继续问它。

提示词

根据 notes/资料地图.md,帮我找出适合支撑开头故事的资料。只列候选,不要写正文。

这件事落地难度中等。它比普通聊天框麻烦,因为你要会建文件夹,也要把材料整理成 txt、md、docx 转文本这类更容易读取的形式。但它不需要编程。你只要能管理文件,就能开始。

效率变化很明显。以前找一轮资料可能 30 分钟,现在 5 到 10 分钟能先定位。更重要的是,它减少启动阻力。很多时候写材料最难的是第一步,一打开文件夹人已经累了。Claude Code 先帮你把路标插好,你再沿着路标往下写。

但所有的东西都不是万能的。

别一开始就把所有文件一股脑塞进去,让它直接生成正文。我一开始就这么干过,结果写出来的东西看起来完整,但旧信息和新信息混在一起,参考稿和当前稿也混在一起。最麻烦的是,它写得很顺,顺到你差点没发现里面有错。这在 AI 大模型的专有名词叫上下文的污染,导致了 AI 模型的降智。

后来我就改了顺序。

先资料地图,再段落大纲,再局部正文。每一步都小一点,错了也好改。尤其是资料地图里,一定要让它标出过期信息和待核对信息。材料工作最怕的不是写得慢,是拿错依据还写得很像真的。

Claude Code 对写材料最有用的地方,很多时候不是代写。

是先帮你把资料摊开。

图片

PART 02

把改稿变成可追踪的版本流水线

第二个隐藏用法,是把改稿变成可追踪的版本流水线。

写材料的人都知道,真正折磨人的不是写第一稿。第一稿再痛苦,至少还算从无到有。更烦的是改稿。改一版,发出去。回来一堆意见。再改一版。又回来一堆意见。改到后面,自己都忘了哪一句为什么这么写,哪一段是后来加的,哪一处是为了回应哪条意见。

传统做法就是另存为。

初稿 v1。修改版 v2。最终版 v3。最终版新 v4。最终版真的能发 v5。

这个文件名体系看起来很熟悉,也很危险。因为文件越来越多,但每个版本之间到底改了什么,没人说得清。你如果临时想回退一句话,可能要打开三个版本人工比对。

Claude Code 在这里有个特别适合材料人的用法。不要只让它生成新稿,而是让它帮你做版本差异说明。

比如你把初稿放在 drafts/初稿.md,把修改稿放在 drafts/修改稿.md,然后问它。

提示词

请比较 drafts/初稿.md 和 drafts/修改稿.md,生成一份版本差异说明。

请按下面格式输出
新增了哪些内容
删除了哪些内容
哪些表达变得更稳妥
哪些地方可能丢失了原来的信息
需要我人工确认的地方

请写入 notes/版本差异说明.md

这件事非常有用。

因为很多时候,我们改材料改到后面,最怕的是误删。你只是想把句子改顺,结果把一个关键信息删没了。你只是想降温,结果把原本有用的具体动作也改没了。

让 Claude Code 做版本差异说明,它就像一个改稿记录员。你不需要完全相信它,但它能提醒你哪里变了,哪里可能有风险。

更进一步,你还可以让它根据修改意见定向改稿。

提示词

请根据 notes/修改意见.md 修改 drafts/初稿.md。

要求
不要直接覆盖原文件
请生成 drafts/修改稿_v2.md
每处较大改动后,在 notes/改动说明.md 里说明对应了哪条修改意见
无法判断的地方标注待确认

这个提示词很关键。

不要直接覆盖原文件。一定要让它生成新版本,这样你有退路。小白用 Claude Code 最容易害怕的地方,就是它会改文件。前期所有动作都要求新建文件,不要覆盖旧文件。

这里第二个翻车点也很典型。

别让它自己判断哪些修改意见已经完成。它可以帮你对应修改意见,但最终你要人工确认。尤其是那种比较模糊的意见,比如再稳妥一点、再简洁一点、再突出重点一点。AI 很容易给你改得看起来顺了,但原本的重点也被磨掉了。

所以我现在会多加一个动作。

提示词

请根据 notes/修改意见.md 和 drafts/修改稿_v2.md,生成一份修改意见响应表。

每条修改意见对应
是否已处理
对应修改位置
仍需人工确认的问题

这个表特别适合写材料的人。它不只是告诉你改了什么,还告诉你每条意见有没有被回应。以前我人工做这件事,至少要 20 分钟。现在让 Claude Code 先出一版,3 到 5 分钟能看清大概。

效率上,这个工作流能省很多隐形时间。以前对比两个版本,可能要 20 分钟。现在几分钟就能出差异说明。以前根据修改意见改稿,可能要从头到尾扫一遍。现在可以先让 Claude Code 按意见生成一版,你再重点看待确认处。

成本变化更明显的是返工。少漏一条修改意见,少误删一段关键内容,少发错一个版本,这些都是真成本。

我之前有一次改稿就很典型。原本只是想把语言写得更自然,结果改完以后,发现一个关键限制条件被我顺手删掉了。如果不是重新对照旧稿,大概率就漏过去了。后来我才意识到,写材料最怕的不是写得慢,是改着改着把边界改没了。

所以现在我会把 Claude Code 当成一个版本管理员。

它不替我做最终判断。

它帮我回答一个很具体的问题。

这一版到底动了哪里。这个问题看似朴素,但对每天改材料的人非常值钱。

图片

PART 03

把写作习惯固化成自己的材料自检机器人

第三个隐藏用法,是把写作习惯固化成自己的材料自检机器人。

这个用法我觉得最适合长期写材料的人。

很多人写材料不是不会写,是每次都犯相似的错。比如开头太空,标题太虚,段落太长,结论太满,案例没有数据,句子像模板,前后说法不一致。每次被指出来以后,当下很痛,下次又忘。

我以前也这样。

改完一篇,觉得自己记住了。过几天再写,老问题又回来了。后来我发现,靠脑子记写作规则不靠谱。规则必须放进系统里,每次写完都跑一遍。

Claude Code 在这里有两个东西特别适合,一个是 CLAUDE.md,一个是斜杠命令。斜杠命令可以理解成你自己做的快捷指令。比如你可以做一个 /check-draft,每次输入这个命令,它就按固定规则帮你检查文稿。

你可以在项目里建一个类似这样的命令文件。

命令路径

.claude/commands/check-draft.md

里面写清楚检查规则。

检查规则

请检查我指定的文稿,重点看以下问题。

是否有空泛开头
是否有过度宣传
是否有敏感信息
是否有事实不确定但写得太满的地方
是否有重复段落
是否有只有观点没有场景的段落
是否有读者看完不知道怎么操作的地方

输出时请按问题严重程度排序。
每条问题包含
原文片段
问题说明
修改建议

以后你写完一篇稿子,不用每次重新输入一大段检查要求,直接调用这个命令,让它辅助检查指定文件。

如果你还想更进一步,可以做一个专门的材料辅助审稿子代理 Subagent。子代理可以理解成一个带固定身份和任务边界的小助手。它不负责写稿,只负责挑毛病。你可以给它定义成材料质检员,让它每次都站在挑刺视角看稿子。

但这里我建议小白别一开始就上子代理。先从 CLAUDE.md 和一个固定检查提示词开始。能跑起来,比搭得花哨更重要。

最简单的版本是这样。

提示词

请检查 drafts/当前稿.md。

请只做审稿,不要直接重写全文。
重点检查
读者能不能看懂
有没有太高阶的概念
有没有缺少具体操作
有没有写得像宣传稿
有没有前后重复
有没有需要删除的敏感信息

请输出修改清单,不要输出完整改写稿。

这个工作流的价值非常稳定。每次写完材料,你都能让 Claude Code 按同一套规则扫一遍。以前靠自己肉眼看,很容易漏,因为你刚写完时已经默认它是通顺的。AI 没有这种心理包袱,它会比较冷地指出问题。

这里第三个翻车点,是自检规则写得太泛。

比如你只写帮我检查一下,它就会给你一堆正确但没用的建议。什么语言更流畅,结构更清晰,逻辑更紧凑。听起来都对,但你不知道怎么改。

自检规则一定要硬一点。

要能逐项判断。

比如有没有具体场景,是否存在绝对化表达,是否有待确认信息,是否有重复段落,读者看完能不能照着做。这种规则才适合做成命令。

落地难度中等。固定提示词最容易,CLAUDE.md 也不难,斜杠命令和子代理稍微有门槛。小白可以分三步走。先用固定提示词,熟了以后写进 CLAUDE.md,再慢慢做成命令。

效率变化不只是省时间。以前你可能要找别人帮你看,或者隔一天自己再看。现在写完以后先跑一遍自检,10 分钟内能找出一批明显问题。真正贵的是质量成本。很多材料不是写不出来,是发出去以后才发现有低级问题。自检越早,返工越少。

我最喜欢这个用法的原因,是它会把你的经验留下来。

每次翻车以后,把原因补进检查规则。比如这次被说太空,就加一条检查是否有具体场景。下次被说太满,就加一条检查绝对化表达。慢慢地,这套自检规则会越来越像你自己的工作经验库。

这比单次生成一篇稿子更值钱。

稿子会过期。规则会沉淀。

图片

PART 04

如果你第一次用,只按这 4 步来

我知道,讲到 CLAUDE.md、斜杠命令、子代理,很多小白可能已经开始紧张了。

所以这篇到这里,我不想继续往复杂里讲。第一次用 Claude Code 写材料,可以只做 4 步。

第一步,建一个干净文件夹。里面只放这次任务相关的资料,不要把一堆历史文件都塞进去。

第二步,写一个 CLAUDE.md。只写最关键的规则,读者是谁,不能写什么,输出格式是什么,哪些地方要标注待确认。你不会写没关系,你直接把要求提给 Claude Code,让它帮你完成这个工作,它会比你完成的更出色。

第三步,先让它做资料地图。别让它直接写正文。先看资料有没有读对,旧信息有没有标出来。

第四步,每次让它改文件,都要求新建版本,不要覆盖原稿。改完以后,让它生成差异说明和待确认清单。

这 4 步跑通,就已经够用了。

你不用一开始就学全套高级玩法。普通人用 Claude Code,最重要的不是把它玩到多深,而是先让它安全地嵌进一个材料文件夹里。能读,能整理,能新建版本,能指出问题,这就已经比普通聊天框更稳了。

图片

最后

写完这篇,我对 Claude Code 的感受其实很简单。

它不是写材料的魔法棒。也不是程序员专属的黑盒工具。

它更像一个坐在你资料文件夹旁边的助手。你把资料摆好,把规则写清楚,把边界说清楚,它就能帮你读资料、管版本、做自检。它不一定每次都对,也不应该替你做最终判断,但它能把最容易乱的那部分工作先整理出来。

对每天写材料的人来说,这件事比单纯生成一段漂亮文字更重要。

漂亮文字很快就会过期。资料地图、版本说明、自检规则,这些东西会留下来。下一次你再写同类材料时,不用完全从头开始。

这才是 Claude Code 对普通办公人最有价值的地方。

别被 Code 这个名字吓住。也别把它神化。

你可以先拿一个不敏感的小文件夹试一轮。放几份公开资料,写一个简单 CLAUDE.md,让它生成资料地图,再让它改一小段文字,最后让它做自检。如果这一轮能跑通,你就会发现,Claude Code 真正隐藏的用法不是写代码。是把写材料这件事,从一堆散乱文件和临时聊天,变成一个能复用、能追踪、能自检的工作现场。

 

The first time I opened Claude Code, I was actually a little embarrassed.

Because its name contains Code and its interface lives inside a Terminal, it looks like a programmer's toy. Black background, white text, command line, project directory, file reads and writes — at first glance, it has nothing to do with someone who writes reports for a living.

My first reaction back then was also pretty ordinary.

What does this thing have to do with me?

It's not like I write code every day.

Later, I forced myself to try it for a while and slowly discovered something interesting. On the surface, Claude Code is a tool for writing code, but what it is truly great at is not just writing code. What it is great at is that it can see the context inside a folder, read a bunch of files, modify files, remember rules, and repeatedly execute the same set of actions according to your workflow.

That changes everything.

For people who write materials every day, the most painful part is often not lacking a beautiful sentence. What is truly painful is that materials are too scattered, versions are too messy, wording is inconsistent across different versions, and after revising one version, you forget why the previous version was written that way. An ordinary chat window can certainly help you write, but it often feels like a temporary outside helper — once the conversation ends, it's gone.

Claude Code is more like an assistant that sits inside your material folder. The files are all right in front of it, and the rules can stay in the project long term.

That was when I started to feel it was actually useful.

But I also have to be clear upfront. Claude Code has a learning curve for beginners. It is not the kind of chat box you open in a browser and use immediately. At minimum, you need to be able to accept using a terminal, put materials into a folder, and understand what a file path is. Its original scenario really is more code-oriented, but if you replace a code project with a material project, many of its capabilities can carry over.

This article is not about programmer use cases.

I'm not writing about auto-committing code, testing, deployment, or any of those things that ordinary people close immediately after reading.

I am only writing about the 3 hidden use cases I think are most useful for people who write materials every day. For each one, I will try to explain clearly: how it was done before, how Claude Code gets involved now, whether it is hard to implement, where the time savings are, and where things are likely to go wrong.

PART 01

Turn a material folder into a material library that can talk to you

The first hidden use case is turning your material folder into a material library that can talk to you.

For people who write materials every day, the most familiar pain should be searching for materials. One folder on the desktop, one folder for WeChat downloads, one folder for browser downloads, one folder for historical versions. Inside, there are Word documents, PDFs, spreadsheets, screenshots, meeting notes, reference drafts sent by others, and drafts you wrote six months ago but have already forgotten about.

My old approach was very primitive. When I needed to write something new, I would start digging through files. Open one, glance at it, not right. Open another one, it's somewhat useful, but the version is too old. Open another one, the title looks like what I need, but the content is not. Ten-plus minutes go by, and the motivation to actually start writing is already worn away.

Ordinary chat-based AI can also help, but it has a problem. You have to copy and paste materials in piece by piece. If there isn't much material, it's fine. Once there is a lot, it becomes annoying. What's worse, it doesn't know what else is in your folder unless you feed it everything again each time.

With Claude Code, the approach changes.

You can simply create a folder and put all the materials related to this writing task inside it. For example, like this.

Folder structure

material-project references reference-material-1.md reference-material-2.md historical-versions.md drafts first-draft.md notes scattered-thoughts.md CLAUDE.md

The most important thing here is CLAUDE.md. You can think of it as a project manual, or as a long-term reminder for Claude Code. You write into it the writing rules, forbidden words, formatting requirements, boundary constraints, and target readers for this material. From then on, when Claude Code works in this folder, it can prioritize these rules.

For example, you can write this in CLAUDE.md.

Writing rules (CLAUDE.md example)

You are now helping me put together a set of articles about AI tools for ordinary office scenarios. Writing requirements Use Simplified Chinese Use normal paragraphs, not poetry style Do not write about sensitive industries or specific organizations Do not use exaggerated promotional language Every point must be tied to a concrete scenario If information is insufficient, mark it as pending confirmation first, do not fill in gaps by guessing

Then you ask Claude Code to do one thing first — not write the main text, but take stock of the materials.

Prompt

Please read the materials in references and notes in the current folder and generate a material map for me. For each piece of material, please state Main content Which section it is suitable for Reusable information Outdated or needs-verification points Please write the result to notes/material-map.md

The materials are no longer a pile of dead files lying in a folder. They become a material library that can be asked, organized, and reused.

In the past, finding materials relied on memory. Now, Claude Code reads through the folder first and generates a material map. When you need to write a certain section, you can keep asking it.

Prompt

Based on notes/material-map.md, help me find materials suitable for supporting the opening story. Only list candidates, do not write the main text.

This is moderately difficult to implement. It is more troublesome than an ordinary chat box, because you need to know how to create folders, and you also need to organize materials into forms that are easier to read, such as txt, md, or Word documents converted to text. But it does not require programming. As long as you can manage files, you can start.

The efficiency change is obvious. In the past, one round of searching for materials might take 30 minutes. Now, you can locate things in 5 to 10 minutes. More importantly, it reduces the friction of starting. Often, the hardest part of writing materials is the first step — by the time you open the folder, you are already tired. Claude Code plants the signposts for you first, and then you write along them.

But nothing is perfect.

Don't stuff all your files into it at the very beginning and let it directly generate the main text. I did this at first, and the result looked complete, but old information and new information were mixed together, and the reference draft and the current draft were also mixed together. The worst part was that it wrote so smoothly that you almost didn't notice the errors. In the terminology of large AI models, this is called context pollution, which causes the AI model to become less intelligent.

Later, I changed the order.

First the material map, then the paragraph outline, then local sections of the main text. Keep each step small, and it's easier to fix mistakes. In particular, in the material map, you must make it mark outdated information and information that needs verification. In material work, the scariest thing is not writing slowly — it is using the wrong basis while making it look very convincing.

Claude Code's most useful function for writing materials is often not ghostwriting.

It is first helping you lay out the materials.

图片

PART 02

Turn revision into a trackable version pipeline

The second hidden use case is turning revision into a trackable version pipeline.

People who write materials know that what really torments you is not writing the first draft. No matter how painful the first draft is, at least it's something from nothing. What's more annoying is revision. Revise one version, send it out. A pile of feedback comes back. Revise again. Another pile of feedback comes back. By the later rounds, you yourself forget why a certain sentence was written that way, which paragraph was added later, and which part was meant to respond to which piece of feedback.

The traditional approach is Save As.

Draft v1. Revised v2. Final v3. Final new v4. Final really-can-send v5.

This file-naming system looks familiar and is also dangerous. Because the files keep multiplying, but no one can clearly say what changed between each version. If you suddenly want to revert one sentence, you may have to open three versions and compare them manually.

Here, Claude Code has a use case that is especially suitable for people who write materials. Don't just have it generate a new draft — have it produce a version-difference explanation for you.

For example, put the initial draft in drafts/initial-draft.md and the revised draft in drafts/revised-draft.md, then ask it.

Prompt

Please compare drafts/initial-draft.md and drafts/revised-draft.md and generate a version-difference explanation. Please output it in the following format Newly added content Deleted content Which expressions became more solid Which places may have lost original information Places that need my manual confirmation Please write it to notes/version-difference-explanation.md

This is extremely useful.

Because many times, when we revise materials over and over, what we fear most is accidentally deleting something. You only meant to smooth out a sentence, and you end up deleting a key piece of information. You only meant to tone it down, and you end up removing a concrete action that was originally useful.

Having Claude Code produce a version-difference explanation is like having a revision recorder. You don't need to trust it completely, but it can remind you where things changed and where there may be risk.

Going further, you can also have it make targeted revisions based on the feedback.

Prompt

Please revise drafts/initial-draft.md according to notes/revision-feedback.md. Requirements Do not overwrite the original file directly Please generate drafts/revised-draft-v2.md After each significant change, explain in notes/change-log.md which piece of feedback it corresponds to Mark places that cannot be determined as pending confirmation

This prompt is critical.

Do not overwrite the original file directly. Always have it generate a new version, so you have a way back. The thing beginners fear most with Claude Code is that it modifies files. In the early stages, all actions should require creating new files and never overwriting old ones.

Here is the second typical pitfall.

Don't let it decide on its own which feedback items have been fully handled. It can help you map changes to feedback, but ultimately you need to manually confirm. Especially with vague feedback like "make it more solid," "make it more concise," or "make the key points stand out more." AI can easily make things look smoother, but the original focus can also be ground away.

So now I add one more step.

Prompt

Based on notes/revision-feedback.md and drafts/revised-draft-v2.md, generate a feedback response table. For each piece of feedback, state Whether it has been handled Corresponding revision location Questions that still need manual confirmation

This table is especially suitable for people who write materials. It doesn't just tell you what changed — it tells you whether each piece of feedback was addressed. In the past, doing this manually took me at least 20 minutes. Now Claude Code produces a first version, and in 3 to 5 minutes I can see the overall picture.

In terms of efficiency, this workflow saves a lot of invisible time. In the past, comparing two versions might take 20 minutes. Now, a difference explanation is ready in minutes. In the past, revising according to feedback meant scanning the whole document from start to finish. Now, you can first have Claude Code generate a version based on the feedback, and then you focus on the pending-confirmation spots.

The more obvious cost change is in rework. Missing one piece of feedback, accidentally deleting one key passage, sending out the wrong version once — these are all real costs.

I once had a very typical revision experience. I only meant to make the language more natural, but after the revision, I discovered that a key limiting condition had been deleted along the way. If I hadn't gone back to compare with the old draft, it would very likely have slipped through. Later I realized that in material writing, the scariest thing is not writing slowly — it is gradually revising away the boundaries.

So now I treat Claude Code as a version manager.

It doesn't make the final judgment for me.

It helps me answer a very specific question.

What exactly changed in this version. This question seems simple, but for people who revise materials every day, it is extremely valuable.

图片

PART 03

Turn your writing habits into your own material self-check robot

The third hidden use case is turning your writing habits into your own material self-check robot.

I think this use case is the most suitable for people who write materials over the long term.

Many people don't struggle because they can't write materials — they keep making the same mistakes every time. For example, openings that are too vague, titles that are too empty, paragraphs that are too long, conclusions that are too absolute, cases without data, sentences that feel like templates, and wording that is inconsistent between the front and the back. Every time it gets pointed out, it stings in the moment, and the next time you forget again.

I used to be like this too.

After revising one piece, I thought I had remembered. A few days later, the same old problems came back. Eventually I realized that relying on my brain to remember writing rules is unreliable. The rules must go into a system, and every time you finish writing, you run through them again.

Here, Claude Code has two features that are especially suitable: CLAUDE.md and slash commands. A slash command can be understood as a custom shortcut you create yourself. For example, you can create a /check-draft command. Every time you enter this command, it checks your document according to fixed rules.

You can create a command file like this in your project.

Command path

.claude/commands/check-draft.md

Inside it, write the checking rules clearly.

Checking rules

Please check the document I specify, focusing on the following issues. Is there a vague opening Is there excessive promotion Is there sensitive information Is there information that is uncertain but stated too definitively Are there repeated paragraphs Are there paragraphs with only opinions and no scenarios Is there any place where readers finish reading but don't know how to act Please sort the output by severity of the issue. Each issue should include The original text excerpt Problem description Revision suggestion

From then on, when you finish a draft, you don't need to re-enter a long set of checking requirements each time. You can directly call this command and have it assist in checking the specified file.

If you want to go further, you can create a dedicated material review subagent. A subagent can be understood as a small assistant with a fixed identity and a bounded task scope. It is not responsible for writing — it is only responsible for finding faults. You can define it as a material quality inspector and have it always review the draft from a critical perspective.

But here, I suggest beginners not jump straight to subagents. Start with CLAUDE.md and one fixed checking prompt. Being able to make it run matters more than building something fancy.

The simplest version looks like this.

Prompt

Please check drafts/current-draft.md. Only review, do not rewrite the full text directly. Focus on checking Can readers understand it Are there concepts that are too advanced Is there a lack of concrete operational steps Does it read like promotional copy Is there repetition Is there sensitive information that should be deleted Please output a list of fixes, not a full rewritten version.

The value of this workflow is very stable. Every time you finish writing a piece of material, you can have Claude Code scan it according to the same rules. In the past, relying on your own eyes made it easy to miss things, because right after finishing, you already assume the text is smooth. AI doesn't carry that psychological baggage, so it points out problems more coldly.

The third pitfall here is writing the self-check rules too vaguely.

For example, if you only write "help me check it," it will give you a pile of correct but useless suggestions. Things like "make the language smoother," "make the structure clearer," "make the logic tighter." They all sound right, but you don't know how to act on them.

Self-check rules must be more concrete.

They need to be judgment item by item.

For example: whether there is a concrete scenario, whether there are absolute expressions, whether there is pending-confirmation information, whether there are repeated paragraphs, and whether readers can follow the text after reading it. Rules like this are suitable for turning into commands.

The difficulty of implementation is moderate. A fixed checking prompt is easiest, CLAUDE.md is not hard either, and slash commands and subagents have a slightly higher learning curve. Beginners can do it in three steps. First use a fixed prompt, then once you're comfortable, write it into CLAUDE.md, and then gradually turn it into a command.

The efficiency change is not just saving time. In the past, you might have needed someone else to review it, or you'd wait a day and look at it again yourself. Now, after finishing, you run a self-check first and can find a batch of obvious problems within 10 minutes. What is truly expensive is the quality cost. Many pieces of material are not hard to write — the problem is discovering low-level issues only after they've been sent out. The earlier the self-check, the less rework.

The reason I like this use case most is that it preserves your experience.

Every time something goes wrong, add the cause to the checking rules. For example, if this time someone said it was too vague, add a rule to check whether there is a concrete scenario. Next time someone says it's too absolute, add a rule to check for absolute expressions. Over time, this set of self-check rules will increasingly resemble your own work-experience library.

That is worth more than generating a single draft.

Drafts expire. Rules accumulate.

图片

PART 04

If you're using it for the first time, just follow these 4 steps

I know that by the time I mention CLAUDE.md, slash commands, and subagents, many beginners may already be getting nervous.

So at this point, I don't want to keep making things more complicated. The first time you use Claude Code to write materials, you can just do 4 steps.

Step 1: Create a clean folder. Put only materials related to this task inside it. Don't stuff a pile of historical files into it.

Step 2: Write a CLAUDE.md. Write only the most critical rules: who the readers are, what you cannot write, what the output format is, and which places need to be marked as pending confirmation. It's fine if you don't know how to write it. Just present your requirements directly to Claude Code and let it help you complete this task — it will do a better job than you.

Step 3: Have it make a material map first. Don't let it write the main text directly. First check whether the materials have been read correctly and whether old information has been flagged.

Step 4: Every time you ask it to modify a file, require it to create a new version and not overwrite the original. After the revision, have it generate a difference explanation and a pending-confirmation list.

Once these 4 steps work, that's already enough.

You don't need to learn the full set of advanced tricks at the start. For ordinary people using Claude Code, the most important thing is not how deeply you master it — it's first getting it to sit safely inside a material folder. Being able to read, organize, create new versions, and point out problems already makes it more reliable than an ordinary chat box.

图片

Finally

After writing this article, my feeling about Claude Code is actually quite simple.

It is not a magic wand for writing materials. Nor is it a black-box tool exclusive to programmers.

It is more like an assistant sitting next to your material folder. If you lay out the materials, write the rules clearly, and state the boundaries clearly, it can help you read materials, manage versions, and run self-checks. It is not always right, and it shouldn't make the final judgment for you, but it can organize the part that is easiest to turn into chaos.

For people who write materials every day, this matters more than simply generating a beautiful piece of text.

Beautiful text expires quickly. Material maps, version explanations, and self-check rules — these things stay. The next time you write similar material, you don't have to start completely from zero.

This is where Claude Code is most valuable for ordinary office workers.

Don't be scared off by the name Code. And don't mythologize it either.

You can start with a small, non-sensitive folder and try one round. Put a few public materials in it, write a simple CLAUDE.md, have it generate a material map, then have it revise a short passage, and finally have it run a self-check. If this round works, you will discover that Claude Code's truly hidden use case is not writing code. It is turning the task of writing materials — from a pile of scattered files and temporary chats — into a work environment that can be reused, tracked, and self-checked.

暂无评论,快来发表第一条评论吧!No comments yet. Be the first!

📮 需求咨询📮 Inquiry