When I finish a long article, there's always a small voice saying it should live somewhere else too. A newsletter, a short social post, maybe a thread. For a long time I handled that by copying paragraphs out of the article and trimming them until they fit. The result read exactly like what it was: leftovers.
These days I treat repurposing as its own writing job, with a short process. It takes less time than the copy-and-trim approach, and the smaller pieces actually stand on their own.
Start from the outline, not the text
The first thing I do is ignore the finished prose and look at the skeleton. Since my drafts are Markdown files, I can pull the headings out with one command:
grep -E '^#{2,3} ' article.md
That prints every H2 and H3 line, in order. Seeing the structure without the sentences around it helps me answer one question: which of these sections could make sense to someone who never reads the full article? Usually it's two or three of them. Those become the starting points for the shorter formats.
If I want the list in a scratch file to write notes next to it, I redirect it:
grep -E '^#{2,3} ' article.md > repurpose-notes.md
Write one sentence per format first
Before I write any of the new pieces, I write a single sentence for each one that says what a reader gets from it. For an article about building a writing routine, that might look like this:
- Newsletter: why my routine only works because it's boring
- Short post: the one rule I'd keep if I dropped everything else
- Thread: five steps, one per post, each usable alone
- Comment/reply bank: two lines on picking a fixed start time
If I can't write that sentence, the format gets skipped. Not every article needs to become a thread. Forcing it is where the leftover feeling comes from.
Rewrite the opening for each audience
The article's first paragraph was written for someone who clicked a headline and is ready to read for several minutes. A newsletter reader opened an email from someone they know. A social post reader is scrolling and gives me a second, maybe two.
So each format gets a new opening, written from scratch. For the newsletter I usually start with something personal and short, like what made me write the piece. For a short post I start with the most concrete line I have, often a rule or a small result, and leave the explanation for the second sentence.
I never reuse the article's first paragraph in any of them. It's almost always the wrong length and the wrong tone.
Keep one detail, drop the rest
Long articles earn their length with examples, caveats, and side notes. Short formats can't carry all of that. My rule is to keep exactly one specific detail per short piece: one example, one command, one before-and-after sentence.
A single specific detail does more for a short post than three general points. A line like "no email before ten" is more useful to a reader than "I protect my mornings, avoid distractions and plan ahead".
Link back only when it helps
It's tempting to end every repurposed piece with "read the full article". I only do that when the short version genuinely leaves the reader with a question the article answers. If the short piece is complete on its own, I let it be complete. People notice when a post exists only to send them somewhere else.
Keep all versions together
Every repurposed version goes in the same folder as the original article, with the format in the file name:
routine-article/
article.md
newsletter.md
short-post.md
thread.md
That way, when I update the article later, I can see right away which smaller pieces might need a change too. It also stops me from repurposing the same section twice by accident.
What changed for me
The biggest difference is that I no longer think of the shorter pieces as summaries. Each one is a small, separate piece of writing that happens to share an idea with a longer one. That shift made them easier to write, and honestly more fun, because I get to approach the same idea from a slightly different side each time.
Top comments (0)