Lesson 6 of 87 min read

Long form once, short form everywhere

Repurpose one blog post or README into a thread, a LinkedIn post, a Bluesky post and a dev.to or Hashnode cross-post with the right canonical URL.

In this lesson you will

  • Turn one long piece into several short posts without rewriting from scratch
  • Cross-post to dev.to or Hashnode with a canonical URL pointing to your original
  • Plan the order and timing of a repurposed piece across your networks

Writing a long technical post takes hours. A tutorial, a postmortem, a deep dive into why you rewrote your parser. Most developers publish it on their blog, post the link once, and move on. A week later the post has had its moment and the hours are spent.

That is a poor return on the most valuable thing you make. A good long post holds a dozen short posts inside it: the key finding, the surprising number, the mistake, the code snippet, the diagram. This lesson shows you how to pull those out, how to cross-post the full piece to developer platforms without hurting your own site, and how to space it all out so one piece of writing feeds a week or two of posts.

The repurposing math

Here is why this matters for a solo builder. Suppose a long post takes four hours and a short post takes twenty minutes from scratch. Writing six short posts from scratch costs two hours of new thinking. Pulling six short posts out of a long one you already wrote costs maybe forty minutes, because the thinking is done; you are only cutting and reshaping.

More important than time: the short posts are better. They come from material you researched and tested for the long piece, so they carry real detail. And each short post points back to the long one, so readers who want depth have somewhere to go.

What you can pull out of one long piece:

Piece of the articleBecomes
The main finding or argumentA thread on X or Bluesky, and a LinkedIn post
One surprising number or resultA single short post
A mistake you made along the wayA short "lesson" post
A code snippet or commandA screenshot post with the text in a reply
A diagramAn image post
The question it answersA reply in a community thread where someone is asking it
The whole articleA cross-post on dev.to or Hashnode, plus a link post

The same works for a README. A good README has a one-line pitch, a "why this exists", a quick start and a list of features. Each of those is a post.

Extract, don't summarize

The common mistake is to "summarize" the article into a post: "In my new post I talk about testing, performance and deployment. Read it here." Summaries describe the article. Nobody stops for a table of contents.

Extract instead. Take one specific idea from the article and make it the whole post. The post should be useful even if nobody clicks the link.

Summary (weak):
New blog post: everything I learned about making our CLI
start faster. Covers profiling, lazy imports and more.

Extract (strong):
Our CLI took 900 ms to print --help.
Most of it was importing modules that --help never uses.
Lazy-loading them cut it to under 200 ms.
The full profiling walkthrough is on the blog:

(This is a hypothetical CLI. Use your own measured numbers.)

Extracts also age well. A summary post is tied to the day the article came out. An extract like "lazy-loading cut startup from 900 ms to under 200 ms" is just as useful three months later, which means you can reuse it when the topic comes up again, link it in a reply to someone with the same problem, or turn it into a slide in a talk. Keep a running list of your best extracts per article, so you are not rereading the whole piece to find them next time.

A useful rule: if a post only makes sense after reading the article, it is a summary. If it makes sense on its own and the article is a bonus, it is an extract.

Cross-posting and canonical URLs

dev.to and Hashnode are good homes for long technical writing. Their readers came to read articles, they render Markdown and code blocks properly, and posts can surface in their feeds and tags. Many developers publish the same article there as well as on their own blog.

The worry is duplicate content: if the same article lives at three URLs, which one should search engines show? The answer is a canonical URL.

A canonical URL is a way of telling search engines "this page is a copy; the original lives over there". Technically it is a rel="canonical" link in the page's head that points to the preferred URL. When dev.to or Hashnode publish your article with a canonical URL pointing to your blog, search engines are told to treat your blog as the original and consolidate signals there, instead of choosing between the copies themselves. Search engines treat it as a strong hint rather than an absolute command, but it is the standard, documented way to handle cross-posts.

How to do it in practice:

  1. Publish on your own site first, so the original URL exists.
  2. On dev.to, set the canonical URL field to your blog post's URL. dev.to supports it in the post settings and as canonical_url in the front matter of the Markdown editor.
  3. On Hashnode, use the option to mark the article as originally published elsewhere and give the original URL.
  4. Check the copy after publishing: view the page source of the cross-post and confirm the canonical link points to your site.

If you do not have your own blog, you can skip canonicals: pick one platform as the home of the article and link to it from everywhere else. You can still move later, but setting up your own site early means your writing builds up in a place you control.

A few cross-posting habits: keep the title the same or very close, keep the first paragraph the same, and add a short line at the top or bottom that says where the original lives. Adapt tags to each platform's tag set; dev.to, for example, limits how many tags an article can have.

Sequence and spacing

Do not post everything on the same day. A repurposed article works best spread out. A sequence that works for a solo builder:

DayPost
Day 1Publish the article on your blog. Post the main finding as a thread on your reach network, with the link at the end
Day 1 or 2Cross-post to dev.to or Hashnode with the canonical URL
Day 2LinkedIn version: the finding plus why it matters to a team
Day 3 or 4One surprising number as a single short post
Day 5 to 7The mistake or lesson as a short post
Week 2The code snippet or diagram, and replies in communities where the question comes up

Spread across your four weekly slots from lesson 4, one article can fill most of two weeks. That is the repurposing math in practice.

Worked example: one of our blog posts

We use this process on our own blog. Here is the shape of it, using a kind of post we publish often: a practical guide for creators or builders. Say we publish a long guide on writing release posts (in effect, lesson 3 of this course as a blog post).

From that one guide, the drafts look like this.

The X thread opener:

Your changelog is already a week of posts.
You just have to change who the sentence is about.
"Refactored auth middleware" -> "You can now give a
script a key that can only read."
Thread on the three rewrite rules:

The LinkedIn post:

Most teams skip announcing releases. Not because they
don't care, but because writing posts is the step that
gets dropped when the release runs late.

The fix we use: treat release notes as a first draft.
Make the user the subject, name the old pain, keep one
honest technical detail. Full guide on our blog.

The Bluesky post:

Changelog line: "Fixed race condition in cache invalidation"
Post line: "Fixed: edits sometimes took minutes to show up.
They're instant now."
Same fact. One of them gets read.

And the full guide goes to dev.to or Hashnode, with the canonical URL pointing back to the blog, so the original stays the one search engines treat as primary.

Notice that each short post is an extract. Someone who never clicks still learns one rewrite rule. That is the test.

Recap

  • One long piece holds a week or two of short posts. Extracting is faster than writing new.
  • Extract one idea per post so it works without the click; don't summarize.
  • Cross-post to dev.to or Hashnode with a canonical URL pointing to your original.
  • Space the pieces out over days, not all at once.

Exercise

Turn one article into four posts

  1. Pick a long piece you have already written: a blog post, a README, a long issue comment or a design doc you can share.
  2. List every extractable piece using the table in this lesson: main finding, surprising number, mistake, snippet, diagram, question answered.
  3. Turn the main finding into a thread with the free X thread maker.
  4. Write the LinkedIn version and check it with the free LinkedIn post formatter; write a short version and check it with the free Bluesky post formatter.
  5. Write down where the original lives and what canonical URL you would set on a dev.to or Hashnode cross-post.
  6. Done looks like: a thread, a LinkedIn post, a Bluesky post, a one-line canonical plan, and a posting sequence across the next week or two.

Go further

Bring a source into the FoPost composer

In FoPost you can paste an article URL into the composer's source step and get a draft for each connected network written from that article, which you then edit and approve. You can also publish the long version to dev.to or Hashnode as an article, with the canonical URL pointing to your original. Start from new post from a source.

Check yourself

  1. 1What is the difference between extracting and summarizing?

    A summary describes the article and only makes sense with the click; an extract takes one idea and makes it useful on its own.

  2. 2What does a canonical URL tell search engines?

    That the page is a copy and the original lives at the canonical URL, so signals should go to the original. Search engines treat it as a strong hint.

  3. 3Why spread a repurposed article over several days?

    Each piece gets its own moment in the feed, and one article can fill your posting slots for one to two weeks.

Academy

Keep reading, free

Tell us a little about you and the rest of this lesson, and every lesson in every course, opens on this device. No account and no card.

What describes you best?
Where do you post today? Pick any that apply.
What do you want most right now?

We use your answers to suggest lessons and to improve the Academy. They are never shown publicly. Read our Privacy Policy.