TL;DR
- Alex Lieberman's Claude workflow uses a three-stage process: ideation (with structured prompts and constraints), drafting (with voice samples and editorial guidelines), and refinement (with specific quality gates)—not just "write me a blog post."
- The secret isn't the AI model; it's the system around it: Lieberman maintains a living style guide, trains Claude on his voice through examples, and implements human-in-the-loop checkpoints that prevent generic output.
- Quality at scale requires constraints, not just prompts: His workflow includes explicit "never do this" rules, minimum standards for originality, and a clear definition of what makes content worth publishing.
- This approach is replicable for product builders: The framework applies beyond content—any AI-assisted workflow needs structured inputs, quality gates, and feedback loops to avoid "slop."
If you've spent any time in product circles lately, you've heard the panic: "AI content is flooding the internet with slop." It's not wrong. Most AI-generated content is generic, derivative, and instantly forgettable. But here's what's interesting: Alex Lieberman, the founder of Morning Brew, has built a Claude-powered content machine that produces hundreds of pieces monthly—and they don't sound like slop.
How? Not by finding a magic prompt. By building a system.
In a detailed breakdown on Lenny's Newsletter, Lieberman pulls back the curtain on his workflow. It's not just useful for content creators. If you're a product builder working with AI—whether you're shipping features, generating user insights, or automating workflows—this case study reveals the architecture of AI systems that actually work.
Let me walk you through what he built, why it matters, and what you should steal for your own products.
The Problem: Why Most AI Content Workflows Fail
Before we dive into Lieberman's solution, let's name the failure mode. Most people approach AI content like this:
- Open ChatGPT or Claude
- Type "Write a blog post about [topic]"
- Get 500 words of bland, generic prose
- Either publish it anyway (bad) or give up on AI entirely (also bad)
The output sounds like slop because the input was sloppy. No context. No constraints. No quality definition. You're asking a probabilistic model to guess what you want, and it guesses... average.
Lieberman's insight: AI is a tool, not a strategy. The quality of your output is determined by the system you build around the tool. And that system needs three things:
- Structured inputs (not vague prompts)
- Quality gates (not blind trust)
- Feedback loops (not one-and-done generation)
Let's break down how he implements each.
Stage 1: Ideation—Structured Constraints Beat Open-Ended Prompts
Lieberman doesn't start with "give me content ideas." He starts with a structured ideation framework that includes:
- Topic clusters: Predefined themes aligned with his audience's interests
- Format constraints: Specific content types (threads, carousels, long-form posts)
- Audience context: Who's reading, what they care about, what they already know
- Differentiation requirements: What angle makes this idea worth creating
He feeds Claude a prompt that essentially says: "Here are my topic areas, my audience, and my recent content. Generate 20 ideas that fit these constraints and don't repeat what I've already covered."
The key: specificity. He's not asking for generic ideas. He's asking for ideas that fit a precise spec. The AI isn't being creative in a vacuum; it's being creative within guardrails.
This is where most product builders go wrong with AI features. They treat the model like a magic oracle. "Just let the AI figure it out!" But AI models are correlation engines. They need structure to produce quality. If you're building AI into your product, your job isn't to expose raw model outputs—it's to design the constraints that make those outputs useful.
Stage 2: Drafting—Voice Isn't a Vibe, It's Data
Once Lieberman has an idea, he moves to drafting. This is where his system gets really interesting.
He doesn't just tell Claude "write in my voice." He provides:
- Voice samples: 5-10 examples of his own writing, annotated with what makes them work
- Style guidelines: Explicit rules ("Use short sentences," "Start with a hook," "Avoid jargon")
- Anti-patterns: A list of things to never do ("Don't use corporate speak," "Don't be overly formal," "Don't hedge every statement")
This is crucial. Voice isn't a vibe you describe; it's a pattern you demonstrate. Telling an AI "be conversational" is useless. Showing it ten examples of conversational writing—and explicitly labeling what makes them conversational—gives it something to pattern-match against.
Lieberman also includes a "minimum bar" in his prompts: the draft must include at least one original insight, one concrete example, and one actionable takeaway. If the output doesn't meet that bar, it doesn't move forward.
My Take: This Is How AI Features Should Work
I think this is the most underrated insight in the entire workflow. As product builders, we're obsessed with making AI features feel "magical"—just describe what you want, and it happens! But that's not how professionals use tools. Professionals want control.
When I'm designing AI-assisted features, I don't optimize for zero-input magic. I optimize for structured input with high-leverage output. Give users a way to define their constraints, provide examples, and set quality bars. The AI handles the grunt work within those boundaries.
Lieberman's drafting stage isn't hands-off. It's high-leverage. He spends 10 minutes setting up the prompt, and Claude does 90 minutes of drafting work. That's the right trade-off.
Stage 3: Refinement—Quality Gates Prevent Slop
Here's where Lieberman's system diverges most sharply from typical AI workflows: he doesn't publish drafts.
Every Claude output goes through a refinement process:
- Self-review prompt: He asks Claude to critique its own draft against the style guide and identify weak points
- Human review: He reads the piece and marks sections that feel generic or off-brand
- Targeted revision: He prompts Claude to rewrite specific sections, not the whole piece
- Final polish: He personally edits for flow, tone, and brand alignment
The result: content that reads like Lieberman wrote it, because he did—with Claude as a co-pilot, not a ghostwriter.
This is the part most people skip. They generate, they publish, they wonder why it sounds like slop. Quality at scale doesn't mean "generate more, faster." It means "generate good first drafts, faster, then refine them."
If you're building AI products, this should shape your UX. Don't hide the refinement step. Make it easy. Give users tools to iterate, not just generate. The best AI products aren't one-shot outputs; they're editing interfaces.
The System Architecture: What Product Builders Should Steal
Let's zoom out. What makes Lieberman's workflow work isn't Claude. It's the system design. Here's the blueprint:
1. Maintain a Living Style Guide
Lieberman has a document that defines his voice, his audience, his constraints, and his anti-patterns. It evolves as he learns what works. Every prompt references it.
For product builders: If you're building AI features, your users need a way to define their "style guide"—their preferences, constraints, and quality standards. This could be explicit (settings, examples) or implicit (learned from usage), but it has to exist.
2. Use Examples, Not Descriptions
Lieberman doesn't tell Claude "be engaging." He shows it engaging writing and says "like this."
For product builders: Few-shot learning (providing examples) is almost always more effective than zero-shot prompting (just describing what you want). Design your AI features to let users provide examples.
3. Implement Quality Gates
Lieberman has explicit criteria for what makes a draft "good enough to refine." If it doesn't meet the bar, he regenerates.
For product builders: Don't just generate and display. Evaluate outputs against quality criteria (even simple heuristics) and surface confidence scores or quality indicators to users.
4. Build Feedback Loops
Lieberman tracks what works. He notes which prompts produce better outputs, which topics resonate, which formats perform. He feeds that back into his system.
For product builders: AI features improve through feedback. Instrument your features to learn from user behavior, and use that data to refine your prompts, models, or UX.
Why This Matters Beyond Content
Lieberman's workflow is nominally about content creation, but the principles apply to any AI-assisted product:
- Customer support automation: You need structured inputs (customer context, issue type), quality gates (confidence thresholds, escalation rules), and feedback loops (CSAT scores, resolution rates).
- Code generation: You need examples (existing codebase patterns), constraints (style guides, performance requirements), and review processes (linting, testing, human approval).
- Data analysis: You need context (business goals, metric definitions), validation (sanity checks, anomaly detection), and iteration (refining queries based on results).
The pattern is the same: AI is the engine, but the system is the product.
The Hard Part: Discipline Over Shortcuts
Here's what's hard about Lieberman's approach: it requires discipline. You have to build the style guide. You have to curate examples. You have to review outputs. You have to iterate on prompts.
Most people (and most product teams) want the shortcut. "Can't we just plug in GPT-4 and ship?" Sure. And your output will sound like everyone else's.
The teams winning with AI right now aren't using better models. They're using better systems. They're treating AI as a component in a larger workflow, not as a magic wand.
If you're building products with AI, the question isn't "How do we use AI?" It's "What system do we build around AI to deliver quality at scale?"
Practical Steps to Build Your Own Content Machine (or Any AI Workflow)
If you want to replicate Lieberman's approach—whether for content, product features, or internal tools—here's where to start:
- Define your quality bar: What does "good" look like? Write it down. Be specific.
- Collect examples: Gather 10-20 examples of high-quality outputs (your own work, competitors, anything that meets your bar).
- Document anti-patterns: What should the AI never do? What makes output feel generic or off-brand?
- Structure your prompts: Include context, constraints, examples, and quality criteria in every prompt.
- Build a review process: Don't publish raw outputs. Review, refine, iterate.
- Track and improve: Note what works, what doesn't, and feed that back into your system.
This isn't fast. But it's leverage. You invest upfront in building the system, and then you can scale quality output far beyond what you could produce manually.
The Future of AI Products: Systems, Not Magic
Lieberman's content machine is a microcosm of where AI products are heading. The novelty of "look, AI can do X!" is wearing off. Users are getting sophisticated. They can spot slop. They want quality.
The products that win won't be the ones with the fanciest models. They'll be the ones with the best systems—the ones that make it easy to provide context, set constraints, review outputs, and iterate.
If you're building AI products, stop thinking about models and start thinking about workflows. The model is a commodity. The system is your moat.
Alex Lieberman figured this out for content. The same principles apply to whatever you're building. The question is: are you building a magic wand, or are you building a system?
Because magic wands run out of magic. Systems scale.
Frequently Asked Questions
What makes Alex Lieberman's AI content workflow different from typical AI writing tools?
Lieberman's workflow uses a three-stage system with structured inputs, quality gates, and feedback loops, rather than just prompting an AI to write. He maintains a living style guide, provides voice samples and anti-patterns, and implements human-in-the-loop review at every stage. The key difference is treating AI as a component in a larger system, not as a standalone solution.
Can this workflow be applied to AI products beyond content creation?
Absolutely. The core principles—structured inputs, quality gates, and feedback loops—apply to any AI-assisted product, from customer support automation to code generation to data analysis. The pattern is consistent: define quality criteria, provide examples and constraints, evaluate outputs, and iterate based on results.
How much time does Lieberman actually save with this AI workflow?
While Lieberman invests significant upfront time building the system (style guides, examples, prompts), the leverage comes at scale. He spends roughly 10 minutes structuring a prompt for work that would take 90+ minutes manually, then refines the output rather than creating from scratch. The time savings compound as the system improves through feedback loops.
What's the most common mistake product builders make when adding AI features?
The biggest mistake is treating AI as magic rather than as a tool that requires systematic design. Teams often expose raw model outputs without building quality gates, structured input mechanisms, or refinement workflows. This results in generic, low-quality outputs that users quickly abandon. Successful AI products focus on the system around the AI, not just the model itself.
- AI
- content-creation
- product-management
- workflow-automation
- Claude
- systems-thinking