Content remix pipeline: a local LLM rewrites one article into LinkedIn, newsletter and summary

Part of AI Tools & Automation — automating real work with local AI models.

Writing an article is the hard part. Turning it into a LinkedIn post, a newsletter intro, and a manager-ready summary is repetitive work that a local model does in seconds. This article builds that content remix pipeline, runs it on real hardware, and measures both speed and quality with actual numbers.

Everything runs on your own machine. Your draft never leaves the building, and each rewrite costs nothing beyond electricity. The same approach scales from one article to a whole content backlog.

Why remix content on a local model?

Marketing teams repurpose constantly. One good article should feed a LinkedIn post, a newsletter, a thread, and a summary. Done by hand, that is an hour of tedious reformatting. Done by a model, it is under a minute.

A cloud model can do this too, but it bills per token and sees your unpublished drafts. A local model removes both problems. You run it once, and every rewrite afterwards is free and private. For an agency handling client material under NDA, that privacy is not optional.

The pipeline and its formats

The pipeline is deliberately simple. It loads the source article once, then sends it to the model with a different instruction for each target format. Each format is just a prompt, so adding a new one takes a single line.

Implementation — the remix engine

The core is one function. It takes the article and a format prompt, then returns the rewrite. Because Gemma-4 is a reasoning model, give it a large max_tokens so it finishes thinking and still produces the final text.

from openai import OpenAI

client = OpenAI(base_url="http://localhost:1234/v1", api_key="not-needed")

FORMATS = {
    "LinkedIn":   "Rewrite the article into an engaging LinkedIn post (max 120 words) with a strong hook.",
    "Newsletter": "Rewrite the article into a friendly newsletter intro paragraph (max 100 words).",
    "Summary":    "Summarise the article in 4 concise bullet points for a busy manager.",
}

def remix(article: str, fmt: str) -> str:
    resp = client.chat.completions.create(
        model="google/gemma-4-12b-qat",
        messages=[{"role": "user", "content": f"{FORMATS[fmt]}nn---n{article}"}],
        max_tokens=2500,      # room for reasoning + the answer
        temperature=0.5,
    )
    return resp.choices[0].message.content.strip()

Real output — unedited samples

Here is the model’s actual LinkedIn rewrite of a benchmark article, straight from the pipeline:

Marketing vs. Reality: Does MTP actually work on AMD? 🔍

I benchmarked LM Studio’s Multi-Token Prediction on an AMD Radeon PRO W7900 using the Qwen3.6-35B-A3B model. Here’s the honest truth: standard decoding held a stable 41.4 tok/s across tasks, showing the power of the MoE architecture — while MTP itself failed to load on this GPU.

Free ebook

Free AI Video, Generated Locally

Working scripts and measured benchmarks. Free.

Your e-mail address

Leave this field empty

Get the ebook

No spam. Unsubscribe at any time.

And the manager summary of the same article:

Both are usable with almost no editing. The model kept the key numbers, adapted the tone to each channel, and added a hook where the format called for one.

Throughput results

Throughput sat between 31 and 35 tok/s across formats. The differences are small, because throughput is a property of the model and GPU, not the prompt. At this rate, a full remix into all three formats finishes in well under a minute, most of which is the model’s internal reasoning.

Quality — LLM-as-a-judge

To measure quality without manual review, the pipeline asks the model to grade each rewrite from 0 to 10. The LinkedIn and newsletter versions scored 9, and the summary scored 7. The lower summary score is fair: compressing an article into four bullets loses nuance, so faithfulness naturally drops.

One honest caveat matters here. The judge is the same local model, so the score is a self-consistency signal, not an objective grade. Treat throughput as the hard number and the judge score as a useful, imperfect proxy. For anything published, keep a human in the loop.

Adapting tone and brand voice

A generic rewrite is a starting point, not a finished post. The difference between bland and on-brand is a short style instruction. Add a system message that describes your voice, and the model applies it to every format at once.

STYLE = ("You are the voice of a developer-tools brand: direct, practical, "
         "lightly witty, no hype, no emoji spam. Prefer short sentences.")

resp = client.chat.completions.create(
    model="google/gemma-4-12b-qat",
    messages=[
        {"role": "system", "content": STYLE},
        {"role": "user",   "content": f"{FORMATS['LinkedIn']}nn---n{article}"},
    ],
    max_tokens=2500,
)

One style block keeps a whole campaign consistent. Because the instruction lives in the system message, you write it once and reuse it across LinkedIn, newsletter, and every other format. That consistency is hard to hold by hand across a busy week.

More formats you can add

The pattern extends to almost any channel. Each new format is one prompt, so the pipeline grows without new code.

• X / Twitter thread: “Turn the article into a 5-tweet thread; number each tweet.”
• YouTube script: “Write a 60-second video script with a hook, three points, and a call to action.”
• Meta description: “Write a 155-character SEO meta description with the focus keyword.”
• FAQ block: “Extract four likely reader questions and answer each in two sentences.”

Notice how the last two feed straight back into publishing. The model can draft the SEO snippet and the FAQ for the very article it just summarised, which closes the loop from draft to published page.

Working with reasoning models

Gemma-4 taught the pipeline one clear lesson. It is a reasoning model, so it spends tokens thinking before it answers. With a small token budget, it runs out mid-thought and returns nothing. The fix is simple: raise max_tokens to around 2 500, which leaves room for both the reasoning phase and the final text.

This trade-off is worth understanding. Reasoning improves the quality of the rewrite, but it costs time and tokens. When you need speed over polish, a smaller non-reasoning model finishes faster, though the output often needs more editing.

Scaling to a content backlog

One article is a demo. The value appears when you point the pipeline at a folder of drafts. A simple loop reads each file, generates every format, and writes the results to disk. Because the model stays loaded, throughput stays steady across the whole batch.

from pathlib import Path

for article in Path("drafts/").glob("*.txt"):
    text = article.read_text(encoding="utf-8")
    for fmt in FORMATS:
        out = remix(text, fmt)
        Path(f"out/{article.stem}_{fmt}.txt").write_text(out, encoding="utf-8")

Run it overnight, and a week of drafts becomes a full set of channel-ready posts by morning. A reviewer then edits rather than writes, which is far faster.

Frequently asked questions

Which model should I use for remixing?

Any capable instruct or reasoning model works. Gemma-4-12b-qat gave strong results here at 31–35 tok/s. If you value speed over depth, a smaller model finishes faster at some cost to polish.

Why did my rewrite come back empty?

Almost always the token budget. Reasoning models think first, so a low max_tokens gets consumed before any answer appears. Raise it to a few thousand and the final text returns.

Can I trust the LLM-as-judge score?

Use it as a signal, not a verdict. Because the judge is the same model, it can be generous with its own work. Pair it with a quick human skim before anything goes live.

Does this keep my drafts private?

Yes. The model runs locally, so unpublished articles never leave your machine. That is the main reason agencies and in-house teams prefer a local pipeline for client material.

Summary

A local content remix pipeline turns one article into many channel-ready formats in under a minute. On a W7900, gemma-4-12b-qat held 31–35 tok/s across LinkedIn, newsletter, and summary formats, and an LLM judge rated the outputs 7–9 out of 10. The rewrites were usable with minimal editing, and the whole process stayed private and free per run. Reproduce every number with the script: 10_remix_benchmark.py.

Companion code — every script and benchmark from this series lives in one repository: github.com/bestin-it/qwen-local-ai-scripts.

Free ebook

Free AI Video, Generated Locally

Run Wan 2.1 in ComfyUI on your own GPU — the scripts I use, measured times, sample clips. No cloud, no API keys.

Your e-mail address

Leave this field empty

Get the ebook

No spam. Unsubscribe at any time.