> log #07 — (Re)Training GPTs + Brand Voice [ + a LLM Glossary ]
Or: retraining loops are the only way to stop GPT drift.
Use Case: (RE)Training a Custom GPT for LinkedIn Content
I needed a way to draft LinkedIn posts that actually sounded like me.
Not “generic AI marketer voice,” but sharp, playful, and supportive — the way I write when I’m in flow.
The problem: LLMs default to polished and safe.
They smooth over edges, fall back on clichés, and drift into “ChatGPT voice” if you don’t constrain them.
So this log documents my attempts to:
Upload my own posts as training data.
Add guardrails to force the style.
Test conversation starters as reusable prompt shortcuts.
The goal wasn’t to automate LinkedIn completely.
It was to create a voice engine that gives me consistent drafts in my style — drafts I can ship faster, or edit into final form without rewriting from scratch.
Why Retraining Matters (for Marketers like Me)
Large Language Models (LLMs) don’t “know” your voice. By default, they sound polished, safe, and vaguely professional — basically “ChatGPT in a blazer.”
That’s because of how they’re trained:
Transformers: the architecture that looks at sequences of tokens all at once, using self-attention to weigh context.
Tokens: the chunks of text the model predicts, one after another.
Parameters: billions of internal weights that encode the patterns. (OpenAI hasn’t disclosed GPT-4’s count, but estimates place it in the hundreds of billions.)
Training Objective: base models are trained on next-token prediction, then refined with techniques like Reinforcement Learning from Human Feedback (RLHF) to align with human preferences and reduce harmful content.
Here’s the important part: when you create a Custom GPT, you are not retraining or fine-tuning the model. The underlying weights never change. What you’re really doing is:
Adding custom instructions (your style guide, guardrails).
Uploading reference materials (your LinkedIn posts, PDFs).
Configuring a system prompt that tells the GPT how to behave.
This is closer to building a specialized interface than training a new model. Think of it like:
Prompts = campaign briefs.
Guardrails = brand guidelines.
Iteration = the feedback loop.
And just like any brand system, if you don’t check back in, the GPT drifts. Which is why “retraining” really means iterating on guardrails until the voice sticks.
Use Case: Training a Custom GPT for LinkedIn Content
I needed a way to generate consistent drafts in my own style: sharp, playful, supportive. Not generic AI marketer voice.
Attempt 1: Default GPT
Action:
Uploaded training examples + gave it a simple brief.
Result:
Polished and professional, but too generic.
Think: “confetti cannons” and “you’re doing better than you think.”
Takeaway: Baseline worked, but sounded like ChatGPT in a blazer.
Attempt 2: Heavy Guardrails
Action:
Added strict instructions:
One sentence per line.
Short sentences. Fragments allowed.
Cite stats. Use arrows for rhythm.
Result:
Closer to my style — but too rigid.
Less fun. GPT started to feel like a rules lawyer.
Takeaway: Guardrails improved fidelity, but too many killed the spark.
Attempt 3: Conversation Starters
Action:
Defined pre-prompted buttons inside the GPT:
→ Write a warm, supportive post
→ Write a stat-driven post
→ Rewrite as a playful hot take
→ Write an analogy post (food, nostalgia, pop culture)
Result:
Much more flexible. Captured the full range of my voice without boxing it in.
Outputs weren’t perfect — but they were consistent, close, and easy to edit.
Takeaway: Simplicity wins. Guardrails work best when they’re light-touch.
📝 Notes
Custom GPTs don’t change model weights. They’re instructions + references on top of GPT-4.
Prompts draft, guardrails constrain, iteration improves.
Guardrails = voice guidelines. Too few = bland. Too many = brittle.
Conversation starters = reusable shortcuts to keep variety without drift.
⚡ Outcome: Went back to simple conversation starters. Posts sound like me, not ChatGPT. Guardrails make the difference — but only if they leave room for play.
Glossary of LLM Jargon You Can Casually Drop on Zoom
P.S. On LLMs, accuracy & hallucinations:
After drafting this log with GPT-5, I ran the technical section back through Claude to check for hallucinations or sloppy phrasing.
It flagged a few things — like the fact that GPT-4’s parameter count isn’t public, and that Custom GPTs don’t actually fine-tune the model weights. Those edits are now in this version.
Why mention this?
Because double-checking across LLMs is a good best practice:
→ Different models have different training data, alignment methods, and biases. Cross-referencing them helps catch blind spots and keeps you honest.
→ One model’s “confident explanation” might be another model’s “not quite right.”
So if you’re publishing work that leans technical (or reputation-critical), it’s worth the extra step. Treat LLMs like interns: useful, fast, and creative — but always check their work.