Many people want AI to write more like themselves.
The most common approach is to start with a style description.
For example:
Make it more conversational.
Don't be too formal.
Write like I usually do on my public account.
Less AI flavor.
These instructions help, but only to a limited extent.
Because a person’s own style often isn’t something they have fully figured out in advance. You develop it through multiple rounds of editing—removing what you don’t like and keeping the rhythm you prefer.
writing-style-skill captures exactly this.
It doesn’t assume you can write a complete style guide from the start.
It lets AI write a draft first, you edit it until satisfied, then it diffs the “AI original” and “your final version,” extracts new rules from the differences, and writes them back into SKILL.md.
This article explains it, connecting well with what we’ve been doing: using real edits to distill a public account’s style.
1. Clarify the Source First
The writing-style-skill repository is here:
https://github.com/jzOcb/writing-style-skill
The repo structure is simple:
SKILL.md
README.md
scripts/observe.py
scripts/improve.py
If you want to install it, you can give this address to AI:
https://github.com/jzOcb/writing-style-skill
Then say:
Help me install the writing-style-skill from this repo.
The core idea of this Skill is clearly stated in the README:
AI writes the first draft using SKILL.md
You edit until satisfied
Diff the two versions
Extract rules
Update SKILL.md
Next time it's more accurate
This is not just a prompt.
It adds a feedback loop.
2. It Starts with an Empty Style Template
SKILL.md isn’t initially a fixed style for someone.
It’s more like a fillable template.
It contains several sections:
Voice Dimensions
Roles and Audience
Writing Rules
Forbidden Words
Sentence Preferences
Formatting Standards
Auto Learning
I especially like the Voice Dimensions section.
It lets you score several dimensions from 1 to 10:
formal_casual
technical_accessible
serious_playful
concise_elaborate
reserved_expressive
This is easier to execute than vague instructions like “make it more natural.”
“Natural” means different things to different people.
For some, natural means relaxed and chatty.
For others, natural means concise and precise.
For others, natural means sharp opinions.
Scoring isn’t perfect, but at least it turns vague preferences into discussable parameters.
3. Technical Implementation: How It Learns Rules from Edits
This repo isn’t just SKILL.md; it also has two scripts:
scripts/observe.py
scripts/improve.py
Don’t look at these two scripts separately.
They form a loop:
Record original and final drafts
Find differences
Let the model extract rules
Write stable rules back to SKILL.md
Let’s look at observe.py first.
It records two versions.
One is original, the AI-generated first draft.
The other is final, your edited and finalized version.
When recording, it saves the content as JSONL logs.
Each record contains:
timestamp
type
content_hash
file
content
context
char_count
This step may seem engineering-heavy, but it solves a practical problem: style can’t be summarized just from memory.
Without records, “learning your style” becomes a vague impression.
Today you might dislike long sentences.
Tomorrow you dislike empty phrases.
The day after you think the headline is off.
Eventually, the rules get messy.
The value of observe.py is to keep every edit.
Later, when analyzing style, you don’t have to rely on memory—you can directly see the real differences.
Next, improve.py.
It collects recent final records, finds differences from original, then calls an LLM CLI to analyze.
It supports several invocation methods:
claude
llm
IMPROVE_LLM_CMD
To be clear: it doesn’t write a complex algorithm to judge style.
It organizes the “edit differences” into prompts and lets the model extract rules.
Extracted rules are graded:
P0 High confidence
P1 Medium confidence
P2 Low confidence
P0 rules can be automatically written back.
P1 rules require manual confirmation.
P2 rules are kept for observation.
This grading is very practical.
Because something changed in one edit doesn’t mean it’s a stable style.
You might delete a certain transition word just because it doesn’t fit this article.
But if you delete the same type of transition word ten times in a row, then it can become a rule.
So the technical implementation can be understood as:
observe.py records evidence
improve.py extracts rules from evidence
SKILL.md supports the next writing round
This isn’t AI “remembering your style” out of thin air.
It turns every real edit into the source for the next writing rules.
4. How It Fits Public Account Writers
I think this Skill is especially good for one thing: distilling your public account editing habits.
For example, you can run it like this:
Step 1: Let AI write a first draft.
Step 2: Edit it carefully into a publishable version.
Step 3: Record original and final.
Step 4: After several articles, run improve.py to summarize.
Step 5: Write stable recurring rules back into your public account Style Guide.
We’ve actually done similar things before.
For example, you notice some neat transitions feel too AI-like.
You also find stacking short sentences of a few words looks AI-generated.
You realize installation instructions shouldn’t be written as command-line tutorials but explained to beginners as “give the GitHub address to AI.”
These all come from real edits.
The value of writing-style-skill is to turn this process into a tool.
Not relying on temporary memory every time.
5. Its Limitations
This repo has scripts, but it’s not magic that automatically gets smarter.
It requires three prerequisites.
First, you must actually edit.
If you don’t edit, there’s no final version.
No final means no learnable differences.
Second, you need enough samples.
One or two edits are just clues.
Only repeated occurrences should become rules.
Third, rule extraction is done by an LLM.
This means it might overgeneralize or treat a one-off edit as a general preference.
So the P0/P1/P2 grading is necessary.
Humans still need to make the final call.
6. Insights for Writing Skills
The most valuable thing about writing-style-skill is that it doesn’t treat style as a one-time configuration.
It treats style as something that evolves.
This is important for writing your own Skills.
Many Skills try to be complete from the start:
What is my style?
Who is my audience?
What sentence structures do I like?
What words do I hate?
Of course, you can write that.
But a better approach is to leave a learning entry for the Skill.
For example:
After each edit, save the original and final drafts.
Summarize repeated edits weekly.
Only write preferences that appear multiple times into formal rules.
Put one-off edits into observation.
This is closer to real writing than writing a “style manual” out of thin air.
Style isn’t something you say.
Style is something you edit out.
7. My Judgment
writing-style-skill isn’t like shuorenhua that directly helps you edit Chinese, nor like humanizer that gives a full checklist of AI traces.
It’s more like a small training ground.
AI writes.
You edit.
Scripts record it.
The model extracts rules from the edits.
This approach fits well with our upcoming public account article production process.
After finishing an article, publishing shouldn’t be the last step.
You should also keep track of “why I edited this way.”
The more you keep, the more your own Skill grows.
