In the previous post, we covered step one: stop using chat boxes (ChatGPT, Doubao, and the like) and switch to local AI tools such as Codex, Claude Code, and Cursor. That piece got strong feedback in our community and WeChat groups. It also surfaced two recurring reactions.
The first comes from people without a technical background. After installing Claude Code or Cursor, they conclude these are clearly tools for writing code. They cannot picture how to apply them to their own work, try briefly, and quit. The second comes from programmers who already use Claude Code every day. They assume the article does not apply to them and keep using chat boxes for non-coding tasks.
These two reactions look unrelated, but they point to the same shift in how work should run: externalize first, then execute. This post is about that mindset. Externalization is the means; reuse is the goal; the Skill is the container. Writing Skills is a simple habit anyone can adopt so AI gets better over time and actually fits daily work. The Skills here are not the viral how-to-search or how-to-post-on-Xiaohongshu templates. They are work Skills: how to run domain research, how to write without sounding like AI, and similar.
Externalize First, Then Execute
Most of the time we work like this: get a task, maybe plan in our head if it is complex, otherwise just start. Research a trip, buy a train ticket, cook a dish. Nobody writes a document first that says here is my detailed plan for tomato and egg stir-fry. We chop and cook. We only externalize, write down how something is done, when we want to share: this city is great, turn the guide into a Xiaohongshu post; this dish is excellent, write the recipe for a friend.
That is natural because we have memory. Next time we remember what worked and what traps we hit. As we said in the last post, in most products AI has no memory. Each new chat starts from a blank slate plus your prompt. If it falls into a trap on the first research pass and you do not record that trap in a document, it will fall into the same trap again. The idea is simple; it is also the key to using AI well.
Externalization is the prerequisite for reuse. Only by accumulating lessons and good methods does AI get smarter and more useful. That is also why we argue for local tools like Codex instead of cloud chat boxes like ChatGPT. Locally you can persist lessons as files and tell AI to read last time's file first, so it does not repeat the same mistake. That is reuse.
For most of us this is a hard habit to adopt because externalize-then-execute feels alien compared with normal life. Make a plan before buying a train ticket? That sounds like busywork. But it is often standard practice. When we hire a cleaner, we spell out expectations: do not miss grease behind the range hood; scrub inside and outside the toilet. We may not put it on paper, but we are externalizing standards and method. When we mentor an intern, we teach tricks and pitfalls by hand. We are already using externalize-then-execute; we just have not written it into a formal document.
Programmers are an even clearer example. Their work is externalize-then-execute all day. They cannot micromanage the CPU directly; they control the machine through programs. A program is externalization in a precise language that tells the computer how to complete a task, and therefore it can be reused directly. Programmers are used to this mindset, which gives them an advantage in the AI era. It also comes with a trap we discuss below.
Externalize to Accumulate Reuse; Documents and Skills Are the Container
Back to the opening problem. For people who are not building software, the point of using AI inside Claude Code is not writing programs. Code is neither the goal nor the focus. You can use these tools like a chat app and throw the same prompts at them: plan my day in Seattle tomorrow; here is today's blood test report, flag anything odd. AI may write code along the way, but code is only a step toward the outcome. Side note: Codex, Claude, and Cursor all have desktop apps now with friendly UIs; you do not have to live in a terminal.
Moving the same prompts into Claude Code improves the experience, for example AI can read your local lab report, but that alone is not a step change. The step change comes from long-term accumulation and reuse. You spend half an hour connecting AI to company email once; next time you say read my inbox and do X without redoing setup. That accumulation and reuse require externalization.
If you view connect AI to company email in ordinary terms, the outcome is downloaded mail and the task ends. From an externalize-and-reuse view, the output is not only this batch of messages. You also produce a guide document so the next run can fetch mail without rediscovering every trap. The doc might say: use Outlook, not the Mac default client; give this username; approve on the phone app; then download. Once the doc exists, your prompt becomes read connect_mail.md and sync mail. After reading, AI follows the instructions, skips traps, and finishes. The first pass, explore plus write the doc, is externalization. The second pass, follow the doc, is reuse.
In that example the container for accumulation is not code but knowledge in document form. It can be technical, like how to connect Outlook, or non-technical: research habits (search in Chinese and English), review habits (run a devil's advocate pass on logic), writing norms (one-page meeting briefs), even manager preferences (light blue palette, avoid absolute wording). When these abstractions become reusable, a tuned AI can chain complex work: research the company wiki, search the web, execute the task from the boss's email, draft a deck that matches company style. You focus on review and direction. Native Doubao or ChatGPT cannot match that unless you also capture how the task was done, not only the deliverable.
Technicians and programmers often fall into a trap here: only code counts as something you can accumulate and reuse. That matches how practiced they are at externalize-then-execute in software. Daily work turns ideas into programs before the machine runs them, which trains a reflex: if we want reuse, it must become code. Hence AI is for coding. For knowledge outside code, programmers and non-programmers start on similar ground. Programmers may actually find it harder to accept that document reuse can matter more than code reuse.
Using Claude Code to write code is valuable. Using it only for code wastes most of its value. The larger opportunity is a general AI workspace that externalizes and automates knowledge work outside software development. It happens to be good at code too. That blind spot is worth correcting if you are a programmer.
How to Write and Organize Skills
Above we used documents as the example for knowledge captured while using AI. In practice the form can vary. It aligns with the popular Skill idea, and we keep that name here. The key to accumulation with AI is writing good Skills.
One caveat: vendors like Anthropic and OpenAI often design products to lock you in. They may require a specific YAML format for Skills. AI is flexible. The core of a Skill is content, not format. A poorly written Skill in the official YAML will not work on Claude. What matters is describing in natural language what outcome you want and what to watch for. If the content is there, you can skip vendor format, skip install steps, or even skip the word Skill and still use AI smoothly.
A good Skill has three elements.
First, success criteria. Tell AI what the end state should satisfy, not a step-by-step SOP. This mirrors delegating to a person. With a cleaner you say grease on the range hood must be gone front and back; you do not list which cleaner, pressure, and order for every surface. Micromanagement is tiring and weak. The same applies to AI. Detailed how-to often hurts. Better to state what you want and let AI figure out how. That style is called prompt for enablement.
Second, known pitfalls and mistakes. This is where accumulated experience shows up fastest. For the cleaner: do not only wipe the front of the hood; the back is greasy too. For AI: if Claude overuses em dashes in writing, add do not use em dashes. If Tavily beats Google in your research, add prefer Tavily for search. Only record mistakes AI actually made. Do not pre-list guesses about errors it might make. Modern models are strong; low error rates mean a long list of hypothetical failures becomes noise.
Third, deterministic tools. Example: call Google with a keyword and return results. That path is fixed; you should not rediscover it every session. Give AI a ready tool and say use this for search. Forms vary: Feishu CLI wired into Codex; Tavily via MCP in config; Gmail via Codex connectors. For unsupported cases, like WeChat chat history, AI can search the web or you build a CLI or MCP. The form matters less than making a low-intelligence, high-repeat action callable reliably instead of re-explored each time.
When you finish a task with a local AI tool, capturing a Skill is easy: add one line to your prompt, write this up as a Skill. You may notice we did not spell out the three elements in that prompt. That is intentional reuse. There is already a Skill for writing Skills. Give AI this link or a local copy. For the email example: explore how to connect company email, follow the guide at that URL, and after success write a Skill for next time. AI will summarize lessons and update the doc so future runs inherit them.
I also published an Outlook Skill on GitHub. You can inspect how success criteria are stated, which tools are provided, and how those tools handle deterministic steps.
Once Skills accumulate, organization is straightforward. Skills are natural-language documents. If AI can read the doc and call the tools, the Skill works.
My layout: put all Skills under one folder, add index.md that says which Skill to open in which situation. Example index. Point to that index from AGENTS.md or CLAUDE.md. Codex loads AGENTS.md on each new session. Prompt: sync Outlook mail using the Skill. Codex reads AGENTS.md, then Skills/index.md, then the Outlook Skill file, then runs the CLI to fetch mail. Under the hood AI reads docs step by step like a person. No heavy discovery layer and no need to obey a vendor-specific Skill format.
Skill Accumulation Is the Lever for Using AI Well
Skills let AI reuse and compound what it learns during work. Build a new reflex: knowledge work can be automated and reused. If you have done a task two or three times, or expect to repeat it, write the Skill first and let AI execute against it. That does not slow you down. Append to your prompt: using the Skill-writing Skill, draft a Skill first, follow it, then update the Skill with what you learned.
The externalize-then-execute habit changes how fast your AI stack improves. You hand off more execution and keep judgment work for yourself.
PS: I collected and open-sourced a dozen Skills [on GitHub]. Use them directly or as references for how to write Skills.
Comments