Lesson 3 of 87 min read
The release is the post
Turn every release into posts without extra writing. Translate changelog lines into user benefits, one change per post, with a screenshot or clip.
In this lesson you will
- Turn a changelog entry into a user-facing benefit
- Split a release into one-change posts and a short thread
- Set up a repeatable release-to-post routine you can keep
You already write about your work every time you ship. Release notes, commit messages, pull request descriptions, the changelog. That text is accurate and detailed, and almost nobody outside the repo reads it. Meanwhile you stare at an empty post box wondering what to say.
The fix is to stop treating posts as a separate kind of writing. A release is the post. Your job is translation: take what you already wrote for maintainers and reshape it for users. This lesson gives you the translation rules, a thread template, and a routine that turns every release into drafts in minutes.
Changelog language vs user language
Changelogs are written from the inside. They describe what changed in the code. Posts need to describe what changed for the person using it. The facts are the same; the subject of the sentence is different.
| Changelog line | Post line |
|---|---|
| Refactored auth middleware to support scoped tokens | You can now give a script a key that can only read, never publish |
| Added retry with exponential backoff to webhook delivery | If your server is down for a minute, webhooks now arrive when it's back |
| Fixed race condition in cache invalidation | Fixed: edits sometimes took a few minutes to show up. They're instant now |
| Bumped minimum Node version to 22 | Heads up: the next version needs Node 22 or newer |
Three translation rules cover most cases:
- Make the user the subject. "You can now…", "Your X no longer…". If the sentence is about your code, rewrite it until it is about their day.
- Name the old pain. "Edits sometimes took minutes" tells people why they should care, and tells the ones who hit that bug that it is gone.
- Keep one honest technical detail. Developers trust specifics. "Exponential backoff" can stay in the second line or the thread, as long as the first line says what it means for them.
Not every change deserves a post. Internal refactors, dependency bumps and test changes usually do not, unless they change something users can feel. A good filter: would a user notice this if you did not tell them? If yes, or if it fixes something they complained about, it is a post.
One change per post
The most common mistake is posting the whole release as one block: "v2.4 is out! New: A, B, C, D, E. Fixed: F, G." Five items in one post means none of them gets read. The reader sees a list and moves on.
Instead, pick the single most useful change and give it its own post. Then decide what to do with the rest:
- Two or three notable changes: one post each, spread across the week. A release can feed your whole week.
- One big change and several small ones: a thread. The big change is the first post; each small one gets a short line after it; the last post links the full changelog.
- Only small changes: one "small fixes this week" post, written as a list of user-facing lines, with the most-requested fix first.
Breaking changes and security fixes
Two kinds of change break the "most useful first" rule. A breaking change gets its own post before or on release day, written plainly: what breaks, who is affected, what to do, and where the migration notes are. Do not bury it in a thread about new features; people who skim will miss it and file angry issues later. A security fix gets a short, factual post that says to upgrade and which versions are affected. Keep exploit details out of the post until users have had time to update; link the advisory instead.
Spreading a release over several days also solves the "what do I post on Thursday?" problem. You already shipped Thursday's post on Monday.
Show it working
A screenshot or a short clip does more than a paragraph. For developer tools, the best visuals are boring and real:
- Before and after: the old error message and the new one, the old output and the new output.
- A terminal recording of the command doing the new thing, a few seconds long.
- A code snippet image for a new API or config option, small enough to read on a phone.
- A screen clip of a UI change, cropped tight around the part that changed.
Code as an image or as text? On networks without code formatting, a clean screenshot reads better than a pasted block. Always also put the real code somewhere copyable: the docs, the changelog, or the first reply. People who want to try it should not have to retype from a picture.
Keep visuals honest. Use real output from the real build, not a mockup. If the feature is still rough, show it rough and say it is early.
A thread template for releases
When a release has one headline change and a few smaller ones, use this structure. It works on X and Bluesky as a thread, and collapses into a single post on LinkedIn.
1/ [The most useful change, as a user benefit, in one line.]
[One sentence of why: the old pain.]
[Screenshot or clip.]
2/ How it works: [one honest technical detail, two lines max].
3/ Also in this release:
- [Smaller change as a user benefit]
- [Smaller change as a user benefit]
- [Fix someone asked for]
4/ Full changelog and upgrade notes: [link]
[Optional: who asked for this, if they're happy to be thanked.]
Rules for the template: the first post must stand alone, because most people will only see that one. No "a thread" filler or emoji as the opener; the opener is the news. Keep each post short enough that it is not cut off in the feed.
Worked example: one of our changelog entries
Our public changelog lists what we ship, grouped by week. Here is how we turn one entry into posts, using a real release: workflow templates for industries. The changelog line is written for people who already use the product; the posts are written for people who might.
The changelog version, roughly:
Workflow templates: start an automation from a ready-made
template for your industry (new listing, new car in stock,
latest work on Instagram, new release -> changelog posts).
Each one drafts posts and waits for your approval.
The X thread we drafted from it:
1/ You can now start an automation from a template instead
of a blank canvas. Pick one, connect what triggers it, done.
2/ Each template drafts the posts and holds them for your
approval. Nothing publishes on its own.
3/ The one we use ourselves: "New release -> changelog posts".
Give it your GitHub releases feed and every release becomes
a draft thread and a post, waiting for you to approve.
4/ All templates and how they work: [link to changelog]
The LinkedIn post, aimed at founders and team leads:
Most teams know they should announce every release.
Most don't, because writing the posts is the step that
gets skipped when the release is late.
We shipped workflow templates so that step writes itself:
connect your releases feed, and each release becomes a draft
post for every network you connect. You approve, it goes out.
Notice what changed between the three. The changelog lists. The X thread leads with what you can do and adds one honest detail per post. The LinkedIn post leads with the team problem, because that reader cares about process. None of them invented anything; all three come from the same entry.
Make it a routine
Translation gets fast when it is a routine. Here is ours, roughly, and a version you can copy:
- When the release is tagged, open the release notes and mark the changes a user would notice.
- Pick the headline change. Write its post line with the translation rules.
- Capture one visual while the feature is fresh in your terminal or browser.
- Draft the thread with the template, or one post per change if you are spreading them over the week.
- Adjust per network: thread on X and Bluesky, single post with the "why" on LinkedIn.
- Schedule the posts, the headline first.
Budget 20 to 30 minutes per release by hand. If you release weekly, that is your entire posting week covered. The workflow at the end of this lesson cuts the drafting step further, but the translation rules still matter: they are how you judge the draft.
Recap
- Your release notes are already written. Posts are translation, not new writing.
- Make the user the subject, name the old pain, keep one honest technical detail.
- One change per post; spread a release across the week or use a short thread.
- Show real output: before and after, terminal clips, tight screenshots.
Exercise
Turn a release into a thread
- Open the notes of your most recent release (or your last few merged pull requests if you do not tag releases).
- Mark every change a user would notice. Rewrite each as a user-facing line with the translation rules: user as subject, old pain named.
- Pick the most useful one as the headline. Fill in the four-part thread template from this lesson.
- Paste the thread into the free X thread maker to split it into posts and check none is cut off.
- Take one screenshot or short screen recording of the headline change from your real build.
- Done looks like: a ready thread of three to five posts, a visual, and a list of leftover changes you can post later in the week.
Go further
New release to changelog posts in FoPost
FoPost has a workflow template called "New release → changelog posts". It watches your releases feed (for GitHub, the releases.atom feed of your repo), turns each new release into a short thread for X and a post for LinkedIn and your other networks, and holds every draft for your approval. Open workflows, pick the template, paste your feed URL and choose your accounts. See automations for how workflows run.
Check yourself
1What is the main difference between a changelog line and a post line?Show answer
The changelog makes the code the subject; the post makes the user the subject and names the pain the change removes.
2What should you do with a release that has five notable changes?Show answer
Give the most useful one its own post or thread opener and spread the others across the week, instead of listing all five at once.
3Why should the first post of a thread stand alone?Show answer
Most people only see the first post in their feed, so it must carry the news without the rest.
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.