The Repurposing Multiplier
After this you can take one asset you already did the thinking for and re-express it across several channels so each version reads native to where it lands, instead of producing a dozen thin variants that all carry the same idea in a worse shape.
Repurposing gets sold as a volume play: write one thing, run it through a tool, walk away with twelve. That framing is the trap. The multiplier in "repurposing multiplier" is not the count of outputs. It is how far one genuinely strong idea can travel before it stops being worth reading. You are multiplying reach on a fixed amount of original thinking, not manufacturing more thinking. The whole technique falls apart the moment you forget which of those two you are doing.
Start from what makes the source worth repurposing at all. A pillar asset earns the name because it has depth the channels do not: a specific argument, real data, a point of view someone sat with. Justin Welsh's "playing the hits" repurposing system, the one many operators learn the pattern from, runs exactly this way. A deep piece becomes the spine, and the channel versions are re-cuts of it. The system works. But the step the tools market as the labor-saver, "generate ten AI variations of this," is the step where the voice quietly dies, because variation-by-default is the model doing the one thing it does without help: producing the average version of your idea, ten times, each a little blander than the last. Depth was the asset. The variation step spends it.
The distinction that separates the two paths is grammar. Every destination has its own. A thread is not a shortened essay, a LinkedIn post is not a clipped newsletter, a short clip is not a podcast with the boring parts removed. Each has a native shape: how it opens, how much context it can assume, what earns attention in the first line, how it ends. Repurposing done right re-expresses the idea inside that grammar. Repurposing done wrong shrinks one format into another and ships the seams. A blog crammed into a tweet does not read as a tweet. It reads as a crammed blog, and everyone can tell. The model is genuinely good at re-expression when you ask it for the destination's native form, and lazily bad when you ask it to "convert," because "convert" is a truncation instruction and truncation is not translation.
One more boundary keeps this honest, because it is the one people collapse most often. Repurposing is not distribution. Re-expressing the pillar into a thread, a post, and a clip produces files. Getting those files in front of people is a separate problem with separate machinery: scheduling, platform APIs, retry logic when an upload fails, the timing of when each goes live. Conflating them is how teams end up "automating repurposing" and quietly meaning "auto-posting," which is where the volume-as-strategy failure sneaks back in through the side door. Keep the generation step and the publishing step in different boxes; they fail differently and you want to debug them separately.
Where it breaks
The technique assumes a pillar with depth to spend. Run it on a thin source and it inverts cleanly into its own failure mode: atomizing a shallow post into eight channel versions does not multiply reach, it multiplies mediocrity across eight surfaces, and now the same forgettable idea is forgettable in more places. Repurposing has no opinion about whether the source was worth repurposing. It faithfully carries whatever you feed it. Garbage in is garbage in eight formats. So the gate is upstream: if the pillar would not stand on its own as your single best piece this month, repurposing is not your move yet. There is also no point where the channel count starts adding value on its own; past the handful of destinations your audience actually lives in, each extra format is maintenance you took on for a reach gain that already plateaued. Which destinations you anchor on matters more than how many. A long-form video or a podcast transcript compounds, and large language models now train on transcripts, while a LinkedIn post from last Tuesday is already dead. A durable repurposing strategy treats the long-half-life asset as the hub and the ephemeral channels as spokes, not the reverse. And the failure here is quiet. A crammed-blog tweet still posts, the variation step still returns ten clean drafts, the clip still renders. Nothing errors. You read it from the symptom side instead: engagement that does not match the quality of the original thinking, which usually means the channel versions lost the thing that made the pillar worth cutting up.
The fix is to make the model re-express, not convert, and to name each destination's grammar explicitly so the default-average path is closed off. Paste your pillar, then paste this block and fill the destination list with the two or three channels your audience actually reads:
Here is a pillar asset I already did the thinking for:
<paste the full pillar — the real argument, the data, the point of view>
Re-express the SAME core idea into each destination below. For each one:
- Open in that destination's native grammar (its own hook, its own first line), do not reuse the pillar's opening.
- Keep the load-bearing specifics — the numbers, the named claim, the actual point of view. If a specific does not fit the format, cut the format's scope, not the specific.
- Match the destination's length and shape because it earns attention there, not because you are trimming to fit.
Destinations:
1. <e.g. LinkedIn post — one idea, story-led, conversational>
2. <e.g. X thread — sequential, each post stands alone, no "in this thread">
3. <e.g. short-video script — spoken cadence, hook in the first line>
Do NOT produce variations of the same version. Produce one re-expression per destination, each native to its channel.
Then list, in one line each, what you deliberately dropped from the pillar to fit each destination — so I can check you cut scope, not substance.Without the variation ban, the model hands you ten flavors of one average draft and calls it repurposing. The drop-list does the other half: it forces every cut into the open, so you can see whether a destination lost scope (fine) or lost the specific that carried the idea (regenerate that one). Cap regeneration at a single retry per destination. Past that the model drifts toward its own mean and starts inventing problems the first draft did not have.
Worked example
IllustrativeIllustrative. A constructed run to show the habit, not a real campaign.
A founder records a 40-minute conversation about why their team killed a feature that tested well. The lazy move is to hand the transcript over with "turn this into a tweet, a LinkedIn post, and a clip." The model truncates: the tweet becomes the first two sentences of the transcript with the rest chopped off, the LinkedIn post is the transcript with paragraph breaks added, the clip is the longest uninterrupted talking stretch. All three post. None of them land, because all three are the recording with parts removed.
Run it transcript-first and re-expressed instead. The transcript is the pillar; each destination gets rebuilt in its own grammar.
LinkedIn post (story-led, one idea): We shipped a feature that won its A/B test, then killed it three weeks later.
The test caught the click. It never saw what happened after, and after was where the feature quietly made activation worse. It nudged people into a flow they did not finish, so the result was a win on the metric we measured and a loss on the one we actually cared about.
Now we run one check before calling anything a win: name the downstream behavior the change should move, and refuse to ship the test until it measures that, not the click in front of it. It buys a slower read. It has already caught two more "wins" that would have shipped.
What is the last A/B win your team shipped that measured the click instead of the outcome?
X thread (sequential, each post stands alone): 1/ We shipped a feature that won its A/B test and killed it three weeks later. The test was not wrong. It measured the wrong thing. 2/ It caught the click. It never saw what happened after the click, which is exactly where the feature made activation worse. 3/ The fix is not a better test. It is naming the downstream behavior the change should move before you run it, then measuring that. 4/ We now refuse to call anything a win until the metric is the outcome, not the click in front of it. Two more "wins" have failed that check since.
Compare that to the crammed version of the same LinkedIn post, where the transcript was shrunk rather than rebuilt:
Crammed (shrink, not re-express): "In today's conversation we discussed our recent feature decision and the testing process behind it. We covered several important learnings about measurement that may be useful for other teams as they think about their own experimentation." [the recording, compressed: no hook, no specific, no shape that belongs to LinkedIn]
Readers register a filed-down repurpose as thin even when they cannot name why — the hook that belonged to the destination never got built, the specific that carried the pillar got trimmed to make it fit. That loss lands the same whether a human does it in a hurry or a model does it on a "convert this" instruction, which is why the instruction that holds the depth is re-express, never convert.