[Community]From User to Author: Write Your First AI Office Tutorial

Summary: Turn your "I used AI to solve X" experience into a shareable tutorial. By the end of this article, you'll move from "answering colleagues' questions in a group chat" to "publishing consistently on vba.net / Zhihu / WeChat Official Account" — letting one piece of experience help a thousand people.

Key Terms You'll Need

This article is the "community / sharing" piece in the series, so I'll define a few terms in plain English before we start. After this, I'll use them as if we all agree on what they mean:

  • Tutorial = A document that turns "what you know how to do" into "what others can follow step by step to do it too." It sounds fancy, but it's basically pouring the experience in your head out in a way other people can understand and act on.
  • Six-Section Skeleton = The six sections every qualified AI Office tutorial should have: Pain Point Hook / Learning Outcomes / Hands-On Case Study / Principles Recap / Pitfall Guide / Advanced Extensions. Every article in this series follows this structure — copy it, and your framework is solid.
  • Tacit Knowledge = The "feel" hidden in your head that others can't see and you can't fully articulate. For example, "I don't know why, but I can spot the error in this spreadsheet at a glance" — this kind of experience is the hardest to convey, and the most valuable part to extract when writing a tutorial.
  • Prompt Engineering = The craft of clearly stating in words "what you want the AI to do." Learning to write tutorials also trains your prompt engineering — because if you can articulate things clearly, your readers can learn to articulate things clearly to the AI.
  • CTA (Call To Action) = The "click / scan / comment" button or prompt at the end of an article. A good tutorial without a CTA is like a restaurant without waiters — the guests have eaten, but they don't know how to pay.

1. Pain Point Hook (30-Second Resonance)

Ask yourself first — how many of these resonate with you:

  • You're already the resident "AI expert" in your team. Every time someone asks in the group chat "how do I do X in Excel," you fire back three screenshots and solve it — but you have to re-explain every single time. It's exhausting.
  • Your note-taking app is full of "records that make sense to me but not to anyone else." You know they're valuable, but you can't just publish them as-is.
  • You want to start a WeChat Official Account, a Zhihu column, or submit posts to vba.net, but you're stuck on step one: "Is my experience good enough?" "How do I start?" "Do I need to draw diagrams?"
  • You scroll past other people's viral tutorials and think, "I could do that, even better." But you can't figure out how they actually wrote it.
  • You've already written two or three posts, but the view counts are dismal. You're not sure if it's the topic, the writing, or the platform.

If you nodded along — this article is for you.

This article is the complete opposite of the rest of the series: Other articles teach you to "use AI to get work done" — for example, B1 (Expense Reports) teaches you to use AI to organize expense claims, and C1 (Weekly Reports Automation) teaches you to use an Agent to write weekly reports; This article teaches you how to turn "I can use AI to get work done" itself into a tutorial — in other words, a meta-level "teaching others how to teach others."

It sounds convoluted, but this is the critical leap from L3 (Expert) to L4 (Master). L3 means "I can do it." L4 means "I can do it + others can do it by following me + I can set standards and lead a team." Writing tutorials is how you turn "the tacit knowledge in your head" into "explicit, reusable assets within the organization" — and that's one of the core moves of an L4.

Today, this article will help you cross the chasm from "knowing how to do something" to "knowing how to write a tutorial about it." By the end, you'll walk away with four things:

  1. A topic-mining checklist to dig the experience in your head into writable subjects;
  2. A six-section skeleton writing template — fill it in, and you have a complete structure;
  3. An AI-powered illustration workflow to nail step screenshots and diagrams in three steps;
  4. A four-platform publishing checklist covering what to watch out for on vba.net / Zhihu / WeChat Official Account / cnblogs.

No empty encouragement. Just usable templates and examples.

2. Learning Outcomes (What You'll Walk Away With)

After this article, here's what we'll be able to do:

  • Recognize what a good tutorial looks like — understand why the six-section skeleton helps readers follow along instead of forgetting everything after reading.
  • Dig out at least 3 writable topics from "I helped a colleague fix an Excel file" — the mining method + topic checklist template.
  • Use the six-section skeleton template to draft a 2,000-word outline in 30 minutes — starter and closer sentence patterns provided for each section.
  • Get all the illustrations done with AI tools — step screenshots with annotations, diagrams, before/after comparisons. No Photoshop required.
  • Understand the publishing differences across four platforms — vba.net / Zhihu / WeChat Official Account / cnblogs each have their own readers, tone, and traffic logic, and you'll know how to adapt the same tutorial for each.
  • Build the mindset that "every tutorial you write is an asset deposited" — not relying on inspiration, but on process, making tutorial writing a muscle memory like "writing weekly reports."

The rest of this article is all real, actionable steps, and every template and checklist can be copied and used directly.

3. Hands-On Case Study (Follow Along and Write)

Preparation: Our "Walkthrough Story"

To make sure the four steps below all run smoothly, let's lock in a real scenario that runs through the whole article:

Scenario: Your colleague Xiao Wang asks for your help — every week she has to put together a "team weekly attendance report" by manually merging, cleaning, and deduplicating four Excel files from four branch offices (the formats aren't even the same), then calculating attendance rate and late rate. Running it in Excel takes her 3 hours every time, and the formatting often doesn't line up. You take one look, ask her to send you the four branch files, and using AI + Power Query (Power Query = the tool inside Excel specifically built for tidying, aligning, and merging messy data; built into Excel since 2016), you finish it in 15 minutes, with a one-click refresh to keep it running. Xiao Wang's eyes light up: "You're amazing!" Then she asks: "Can you teach this method to everyone?"

The rest of this article uses this real scenario to demonstrate how to turn "I helped you fix a spreadsheet once" into "a publishable tutorial."

3.1 Topic Mining: Dig 3 Writable Topics Out of "Helping a Colleague Fix a Spreadsheet"

Most people get stuck at step one: they feel they have "nothing worth writing about." The truth is — every time you help a colleague solve a problem, there's at least one tutorial topic hiding behind it. The key is to dig.

Step One: Record the Raw Scenario (2 minutes)

You're not writing a tutorial yet — just jotting things down. Create a memo titled "Problems I've Helped XX Solve." Every time you help a colleague, drop in one line with just four elements:

Element Example (using the attendance scenario)
Who ran into what problem Admin colleague Xiao Wang
The specific scenario Weekly attendance sheets from 4 branch offices, with inconsistent formats
How it was done before (the pain) Manual copy-paste, 3 hours/week, frequent errors
How I solved it with AI + tools (the win) Power Query merge + AI cleaning, done in 15 minutes

Don't underestimate this step. If you can't write a tutorial, it's almost never because you can't write — it's because you don't have material. This table is your "material mine."

Step Two: Three-Question Filter (5 minutes)

Not every raw note is worth writing about. When you have one entry, ask yourself three questions:

  1. Will other people also run into this problem?

    • "Only Xiao Wang's company has it" → Too specific, don't write.
    • "Any admin handling attendance across multiple branches will" → Common enough, worth writing.
    • "Anyone who has to merge Excels weekly will" → Even more universal, even more worth writing.

  2. How much time will this save / how many pitfalls will it avoid?

    • More than 2 hours saved per week → Worth writing.
    • That's 100+ hours per year — that's a number. Put it in the title and summary, and readers immediately get the value.

  3. Can I explain it clearly right now?

    • If yes → Write directly.
    • If not quite → Run through it once, map out the sticking points, then write.
    • If completely unclear → Not your topic. Put it back.

Step Three: One Raw Note, Three Different Angles

The same raw note — "helping Xiao Wang merge attendance sheets" — can be mined into at least three different topic angles:

Angle Sample Title Target Reader
Trick angle "Merging 4 Branch Office Attendance Excels: From 3 Hours to 15 Minutes" Admins / HR
Methodology angle "Weekly Consolidated Reports with Power Query: Write It Once, Auto-Run Every Week" Power users who want to learn automation
AI-application angle "AI + Power Query Together: The Right Way to Merge and Clean Excels" People already using AI

Three angles, three reader groups, three platforms for distribution. One raw note, three pieces of output. That's the biggest difference between an L4 (Master) and an L1 (Beginner): the reuse mindset.

Topic Mining Checklist (copy and use directly):

  • Who did I help solve what problem?
  • Will other people also run into this problem? (Common ground)
  • How much time did this save? (Quantified)
  • Can I clearly explain every step? (Executable)
  • What other angles can this same raw note be written from? (Reuse)

3.2 Writing: Use the Six-Section Skeleton to Draft a Tutorial (Outline in 30 Minutes)

You've mined your topic — now it's time to write. Don't open Word just yet — build the skeleton first.

The six-section skeleton isn't a rigid rule — it's the reader's reading rhythm:

  • First, tell me "why this is worth reading" (pain point);
  • Then, tell me "what you'll be able to do after reading" (outcome);
  • Then, teach me "step by step how to do it" (case);
  • After that, I'll ask "why does this work?" (principles);
  • When I start, you have to warn me "where are the common pitfalls" (pitfalls);
  • After I finish, you tell me "where else can I go from here" (extensions).

Template (Fill It In Directly)

Below is the six-section skeleton template for a tutorial, with starter and closer sentence patterns provided for each. Just fill in your material:

Section 1: Pain Point Hook (~200 words)

Purpose: Make readers feel within 30 seconds "this is exactly me."

Starter Sentence Patterns (pick one):

  • "Have you ever run into XX..." (scene resonance)
  • "Last week / last month, I helped colleague YY with ZZ..." (story opening)
  • "Many people think XX is hard, but actually..." (counter-intuitive opener)

Closer Sentence Pattern:

  • "If you nodded along, don't worry — let's tackle this step by step."

Watch out for:

  • Don't stack jargon. The first time a term appears, follow it immediately with a plain-language explanation.
  • Don't make it long. Readers skim and leave — hit the pain point within 200 words.

Section 2: Learning Outcomes (~100–150 words)

Purpose: Give readers a "what you'll walk away with" list to reduce drop-off.

Starter Sentence Pattern:

  • "By the end of this article, you'll walk away with at least three things:"

Closer Sentence Pattern:

  • "The rest is all real, actionable steps, and every prompt / config can be copied and used as-is."

Template:

1. Nail down XXX (a specific capability, not "understand XXX")
2. Take home XXX (a concrete deliverable)
3. See clearly XXX (a cognitive upgrade)

Section 3: Hands-On Case Study (~1,000–1,500 words, the heaviest section)

Purpose: Walk readers through it hand-in-hand, so they can reproduce it after closing the document.

Structure:

  1. Prep: environment / accounts / prerequisites (readable in 30 seconds)
  2. Step 1: what to do + where to click + screenshot number
  3. Step 2: ...
  4. ... until you reach the result
  5. Verification: how to confirm you did it right

Starter Sentence Pattern:

  • "Let's use a real scenario — XXX — and run through it."

Closer Sentence Pattern:

  • "At this point, you've completed 80% of the work. Let's talk about the principles behind it."

Gold Standard:

  • Steps are clearly numbered, avoid vague connectors like "then / next";
  • Every step gets one image, with red boxes / arrows highlighting the key part;
  • For key operations, give an "expected result" — tell readers what their screen should look like after this step.

Section 4: Principles Recap (~200–300 words)

Purpose: Upgrade readers from "knowing what" to "knowing why."

Starter Sentence Patterns:

  • "Why does XXX work? The truth behind it is..."
  • "You think the AI is doing XXX, but actually it's..."

Closer Sentence Pattern:

  • "Remember this one sentence, and next time you run into a similar problem, you'll be able to judge for yourself whether to use it."

Section 5: Pitfall Guide (~200–300 words)

Purpose: Tell readers in advance about the pitfalls you've stepped on, to lower their dropout rate.

Structure: About 5 items, each independent, with "symptom + cause + fix."

Sentence Pattern:

  • "Pitfall 1: XXX. Symptom is... cause is... fix it this way..."

Sources of pitfalls:

  • Errors / sticking points you hit during this hands-on session;
  • High-frequency questions in reader groups;
  • Differences across versions (Excel / WPS / different AI tools).

Section 6: Advanced Extensions (~150–200 words)

Purpose: Point the way for readers who've finished and want to go deeper, and it's a great place for internal links to drive traffic.

Starter Sentence Pattern:

  • "At this point, you've already XXX. One step further, there are three directions you can go..."

Closer Sentence Pattern:

  • "You're already on your way. See you in the next article, XXX."

Core playbook:

  • Internal-link to other articles in this series (leave a hook);
  • Leave a CTA (comment / scan / click);
  • Close with an encouraging line, no empty encouragement.

Hands-On Example: Build the Skeleton in 30 Minutes

Using the topic "Merging Multi-Sheet Attendance Files with Power Query," I'll run through the template above — see what 30 minutes can produce:

[Sample Draft]Merging Multi-Branch Attendance Files: Nail It in One Click with Power Query

Section 1: Pain Point Hook "You've been there — HQ asks you to consolidate the weekly attendance from 4 branch offices, each Excel has a different format: some Sheet names are '1 月', some are 'January', some have merged cells, some names have extra spaces... You spend 3 hours copy-pasting by hand, your boss says 'adjust the format a bit,' and everything collapses back to square one."

Section 2: Learning Outcomes "By the end of this article, you'll walk away with three things: ① A Power Query script that 'write it once and it auto-runs every week'; ② A clear view of where AI helps in this process; ③ Three of the most common beginner pitfalls, dodged."

Section 3: Hands-On Case Study (omitted — see your own full version)

Section 4: Principles Recap "The reason Power Query can 'write once, auto-run every week' is that it turns 'data cleaning' into a 'visual step chain.' Every step you can see, edit, and reuse — same idea as writing a VBA macro (an automation script in Excel), but with a much lower learning curve. What AI does here is help you generate M functions (M is Power Query's scripting language — an order of magnitude easier to learn than VBA) in plain language, no syntax memorization needed."

Section 5: Pitfall Guide "Pitfall 1: The folder path has Chinese characters / spaces, and the script errors out directly. Rename to English / underscores. Pitfall 2: Branch sheets have merged header cells that Power Query can't read. Unmerge them manually first. Pitfall 3: The data source changes a column name, and the refresh breaks. In Power Query, switch 'column-name references' to 'column-index references.'"

Section 6: Advanced Extensions "After this article, you already know how to use Power Query for 'reusable' data cleaning. The next step is to learn DAX (DAX = the formula language in Power Pivot / Power BI for calculations, similar to Excel functions but more powerful) for YoY / MoM attendance comparisons, or chain the whole flow with Power Automate so it auto-runs — a Monday morning email lands in your boss's inbox automatically. To keep going, see B26 "Write Power Query M Queries with AI" / B22 "Write DAX Measures with AI" in this series."

See — once you lay out the six-section skeleton, the structure becomes clear at a glance, and the word count naturally hits 1,500+. All that's left is filling in the step-by-step details for "Section 3" — and that's the illustration step covered in the next sub-section.

3.3 Illustrations: Nail Step Screenshots and Explanations with AI in Three Steps

Many beginners hit a wall when it comes to illustrations: "I don't know Photoshop!" "Drawing a diagram takes hours!"

The truth is: in the AI era, 80% of tutorial illustrations don't need Photoshop. Here's how to nail it in three steps.

Step One: Screenshot + Red-Box Annotation (5 minutes per image)

Don't take a "naked screenshot." When readers see a screenshot without any indication of where the focus is, they'll scroll past immediately.

The right way:

  • Use Windows Snipping Tool (search "Snipping Tool" or press Win + Shift + S) or Snipaste (a free screenshot tool with pinning and annotation) to capture the screen;
  • Use red boxes / arrows to circle the focus point — Paint 3D or Snipaste can both do this in 30 seconds;
  • Only keep the key area in the screenshot — don't photograph the entire desktop (readers' eyes get distracted by irrelevant info).

Example:

Screenshot caption template: "In Excel, click Data → From Table/Range. The Power Query editor pops up — this step loads the current Sheet as a query source."

Image: An Excel screenshot, with a red box around the "Data" tab, and a red arrow on the "From Table/Range" button.

Step Two: Generate Diagrams with AI (2 minutes per image)

Whenever you need a "flowchart / comparison / layered diagram," don't draw it — let AI generate it.

Pick one of three tools:

  • Whimsical / Excalidraw: web-based hand-drawn style flowcharts, the free tier is enough;
  • Mermaid: draw with code, rendered directly in Markdown, ideal for "process flows / sequence diagrams";
  • SmartArt built into PowerPoint / Keynote: built into Office / WPS, just pick a template and replace the text — 5 minutes per diagram.

AI Prompt Template (copy directly):

Please draw a flowchart describing the process of "using Power Query to merge multi-sheet attendance files."
Requirements:
1. Horizontal layout, 5 nodes;
2. The nodes in order: ① Prepare the folder → ② Load the 4 branch sheets → ③ Unified cleaning → ④ Append merge → ⑤ Load back to Excel;
3. Each node has a one-sentence description of what to do;
4. Output as Mermaid code, which I'll paste directly into Markdown.

Paste the Mermaid code from the AI into Markdown, the flowchart renders automatically — that's the kind of "looks professional" diagram you see in tutorials, with just 2 minutes of real work.

Step Three: Comparison Images (Showing "Before vs. After")

The most persuasive element in a tutorial is the comparison image — one showing "manual method, 3 hours," the other showing "AI method, 15 minutes." You don't need AI for this — use PowerPoint directly:

  • Left: An "overtime until late at night" icon, labeled "Before: 3 hours/week" — with a screenshot / sketch;
  • Right: A "done with a cup of coffee" icon, labeled "After: 15 minutes/week" — with an AI-generated caption;
  • Middle: a thick arrow, labeled "AI saves you 2.75 hours."

A clear "before vs after" image is more persuasive than ten lines of text. No one in a tutorial article doesn't love a "before vs after" comparison.

Illustration Workflow Checklist:

  • Step screenshots: red boxes / arrows highlighting the key area;
  • Diagrams: use Whimsical / Mermaid / PowerPoint SmartArt, generated with AI;
  • Comparison images: "before vs after" in PowerPoint, one image worth 1,000 words;
  • Each image gets a one-line caption telling readers "what this image is saying."

3.4 Publishing: Notes for vba.net / Zhihu / WeChat Official Account / cnblogs

The last step is to publish the tutorial. The same tutorial, posted on different platforms, needs a few tweaks — each platform's reader tastes, recommendation algorithms, and formatting requirements are different.

Platform 1: vba.net (Your Home Turf)

  • Suitable content: Hard-core tutorials focused on AI + office software automation (Excel / Power BI / VBA / Power Query / Office JS, etc.);
  • Reader profile: Advanced users in the office automation circle, comfortable with jargon;
  • Publishing tips:
    • Use the main category "AI Office" and subcategory "Community";
    • Make titles value-quantified — e.g., "Merging 4 Attendance Files: From 3 Hours to 15 Minutes," not "How to Efficiently Merge Excel";
    • In the summary, clearly state "what you'll walk away with," with numbers;
    • Use Markdown for the body, with clear paragraph headings, and numbered annotations on illustrations;
    • At the end, internal-link to other articles in this series to retain readers.

Platform 2: Zhihu

  • Suitable content: Topics with a "sense of question," a touch of counter-intuition or opinion;
  • Reader profile: Younger-leaning, likes to nitpick, enjoys "story + practice";
  • Publishing tips:
    • Make titles into questions — "How can I use AI to merge attendance files from 4 branch offices down to 15 minutes?" gets more clicks than "AI Attendance Merging Tutorial";
    • The first 3 lines must hook readers — tell a story / throw out data / be counter-intuitive, don't explain concepts upfront;
    • Bold key conclusions in the body — Zhihu users skim-read;
    • At the end, hang "related questions" links to ride the traffic;
    • Don't make it too long — Zhihu users have less patience than WeChat Official Account readers.

Platform 3: WeChat Official Account

  • Suitable content: Story-driven, emotionally resonant, with quotable one-liners;
  • Reader profile: Fragmented reading, primarily mobile, medium patience;
  • Publishing tips:
    • The first 200 words must hook — otherwise readers close the tab immediately;
    • Keep paragraphs short (3–5 lines per screen on mobile), sparse illustrations (long blocks of text on a small screen scare readers off);
    • Mild clickbait titles are okay, but don't fabricate — WeChat Official Account forwarding relies on "trustworthiness";
    • At the end, a CTA is required (follow / star / comment / scan) — WeChat Official Account's closed loop lives in the private domain;
    • Format with 135 Editor / Xiumi, leave plenty of white space.

Platform 4: cnblogs

  • Suitable content: Technical, solid in detail, with code / formulas / raw data;
  • Reader profile: Developers / technical office users, comfortable with jargon, allergic to fluff;
  • Publishing tips:
    • Technical details must be solid — version numbers, error messages, and citation sources, all clearly labeled;
    • VBA / M functions / DAX code blocks can be pasted directly, rendered with Markdown;
    • Don't be too clickbaity with titles — cnblogs readers dislike exaggerated expression;
    • Tag accurately (e.g., Power Query, Excel Automation, AI Office) to help on-site search;
    • Reply to comments carefully — cnblogs readers love high-quality discussions.

One-Draft-Multi-Post Editing Checklist (run through 5 minutes before posting on each platform):

  • Title: numbers / value-quantified (vba.net) + question-form (Zhihu) + story-form (WeChat OA) + technical-form (cnblogs)
  • First 200 words hook (especially important on Zhihu / WeChat OA)
  • Illustration density: sparse on WeChat OA, can be dense on cnblogs
  • CTA: required on WeChat OA, optional on the others
  • Tags / categories: tune individually for each platform

4. Principles Recap

Why are "knowing how to do something" and "knowing how to write a tutorial about it" two different things?

Because the essence of writing a tutorial is turning tacit knowledge into explicit knowledge.

When you yourself do "merge 4 attendance files," the steps in your head might look like this:

"Open the 4 files → see which ones have different formats → unify the name column → copy into one file → calculate attendance rate → check if anything is missing"

You can understand this yourself, but anyone following along gets stuck at step 3 and quits.

Writing a tutorial means breaking this "vague experience" down, step by step, into something like:

  1. Put the 4 files in the same folder, named attendance_branchname.xlsx;
  2. Open Excel → Data → From Folder → select that folder;
  3. Power Query auto-detects the 4 files, click "Transform Data";
  4. ...

Every step is executable, verifiable, repeatable — that's the conversion from "experience" to "tutorial."

In the AI era, this matters more than ever:

  • AI massively boosts the production rate of "experience," but if experience isn't captured, it's gone with the person;
  • Writing a tutorial = amplifying "the time AI saved you" by another 100x (1 person knows → 1,000 people know);
  • A good tutorial's reach far exceeds a single internal sharing session — this is the "multiplier effect" of an L4 (Master).

Remember one sentence: Knowing how to do something only helps yourself; knowing how to write a tutorial about it helps an entire group.

5. Pitfall Guide

Writing tutorials is harder than writing articles because they have to be "executable." Below are 5 pitfalls that 90% of beginners step on:

  1. Pitfall 1: The topic is too big — "let one article explain all of AI Office."

    • Symptom: You write 10,000 words and cover everything, but nothing in depth.
    • Cause: Greed.
    • Fix: One tutorial solves one problem. Merging attendance is about merging — don't slip in "and by the way, here's some VBA."

  2. Pitfall 2: Steps jump around, assuming the reader is "as familiar as you are."

    • Symptom: Readers get stuck at step 3 and quit, commenting "what is this even explaining?"
    • Cause: Expert Blind Spot — where you're familiar, you subconsciously skip.
    • Fix: After writing, send it to a real beginner to follow along. Wherever they get stuck, fix it. This is the gold standard of an L4 (Master): write so that even "yourself three months from now" can understand it.

  3. Pitfall 3: No "Pitfall Guide" section, so readers hit a snag and give up.

    • Symptom: Readers follow the steps, hit an error, and leave.
    • Cause: You haven't stepped on the pit they're stepping on right now.
    • Fix: Section 5 must be written. List every error, sticking point, and version difference from this hands-on session.

  4. Pitfall 4: Screenshots are too busy, the focus is hard to see.

    • Symptom: The whole screenshot is covered in red boxes / arrows, and readers don't know where to look.
    • Cause: Wanting to highlight everything.
    • Fix: One image, one focus point. Multiple focus points? Split them into multiple images.

  5. Pitfall 5: Tool versions not labeled, so readers on different versions get different results.

    • Symptom: Readers say "I don't have this button."
    • Cause: Excel 2016 / 2019 / 365, WPS — menu positions differ across versions.
    • Fix: State the environment at the start — "This tutorial is based on Excel 365 + Power Query. Other versions may have slightly different menu positions." Same for AI tools: clearly state which version you used (GPT-4o / Claude 3.5 / Qwen), and paste the full prompt.

6. Advanced Extensions

At this point, you're no longer "someone who can use AI," but "someone who can use AI + teach others to use AI." This is the critical leap from L3 (Expert) to L4 (Master).

Three paths to continue from here:

Path A: Serialized Tutorials (Turn 1 Piece Into 10)

Build a series around "AI + office automation," with each piece solving one specific scenario. For example, an "AI Office in a Week" series:

  • Monday: Use AI to write weekly reports (C1 reference)
  • Tuesday: Use AI to organize expense reports (B1 reference)
  • Wednesday: Use AI to take meeting minutes (C2 reference)
  • Thursday: Use AI to clean data (B2 reference)
  • Friday: Use AI to design PowerPoint (B9 reference)

One series = one positioning + one batch of readers. Far more impactful than "one piece here, another there."

Path B: From Written Tutorials to Video Tutorials

The same script, plus screen recording and voiceover, becomes a video tutorial. AI tools can now auto-voice and auto-subtitle — you just read the script once, and 3 hours later you have a video.

  • CapCut / Baidu DuJia Creator: AI auto-subtitling and background music;
  • OBS Studio: free screen recording;
  • ElevenLabs / Microsoft Azure TTS: AI voiceover, near-human naturalness.

Written-tutorial readers: 100. Video-tutorial readers: maybe 10,000. A 100x amplification of reach.

Path C: You Learn by Teaching — Reverse-Upgrade Yourself

The biggest hidden benefit of writing tutorials: you get stronger too.

  • You find yourself unable to explain midway → go back and chew on the principles again;
  • A reader's comment opens up a new scenario → your cognitive boundary widens;
  • Multiple tutorials strung together become your personal "knowledge system" — the moat of an L4 (Master).

Three-Paths Recap:

  • Path A: serialize, expand horizontally (write more);
  • Path B: go video, reach broader (let more people see);
  • Path C: systematize, deepen vertically (make yourself stronger).

Newbie advice: start with Path A (easiest to pick up, lowest marginal cost), then Path C once you have some accumulation (build a system), and do Path B (video amplification) once you have enough reach.

You're already on your way. Don't wait for "inspiration to strike." Starting today, every problem you help a colleague solve, write it up into an 800-word short tutorial using the six-section skeleton and publish it. Stick with it for 3 months, and you won't be "the person who answers questions in the group chat" — you'll be "the columnist with a regular column on vba.net."

The next article, F2 "Build Your Personal AI Office KB", talks about how to consolidate these tutorials and experience into your own knowledge base — what you've written stops being scattered and becomes ready at hand whenever you need it.

You've already crossed from "user" to "sharer." Next step, we'll talk about "how a sharer goes global."