DEV Community: Suifeng023

How to Turn One Idea Into 30 Pieces of Content With AI

Suifeng023 — Mon, 11 May 2026 15:59:17 +0000

How to Turn One Idea Into 30 Pieces of Content With AI

Most people use AI to create more content. The better use is to create more usable angles from one strong idea.

If you start with a weak idea, AI only gives you more weak posts. But if you start with a useful source — an article, transcript, product update, case study, or opinion — AI can help you turn it into platform-native content quickly.

Here is the workflow I use.

Step 1: Extract the source material

Do not ask AI to "write posts about productivity" or "make content about my product".

Start with something concrete:

a blog post
a YouTube transcript
a podcast transcript
a product update
a customer story
notes from a client call
a strong opinion you already believe

Then run an intake prompt.

You are a content strategist. Analyze the source material below and extract reusable content angles.

Source material:
[PASTE ARTICLE / TRANSCRIPT / NOTES / PRODUCT UPDATE]

Audience:
[WHO THIS IS FOR]

Business goal:
[TRAFFIC / EMAIL SIGNUPS / PRODUCT SALES / TRUST / COMMUNITY]

Return:
1. One-sentence core idea
2. 10 useful insights from the source
3. 10 audience pain points connected to the source
4. 10 contrarian or surprising angles
5. 5 proof points or examples worth highlighting
6. 5 content formats this source can become
7. A warning list: what would make the content sound generic

This gives you raw material before you start writing.

Step 2: Pick the strongest angles

The mistake is trying to publish every AI output.

I usually look for angles that have at least one of these:

a painful problem
a specific before/after
a surprising opinion
a useful checklist
a practical example
a mistake people are making

If none of the angles are strong, the source material probably needs more proof or a clearer point of view.

Step 3: Convert by platform, not by format

A LinkedIn post is not just a shorter blog post.
An X thread is not just bullet points.
A newsletter is not just a summary.

Each platform needs a different shape.

For example, for an X/Twitter thread:

You are a social media editor turning long-form content into an X/Twitter thread.

Source:
[PASTE SOURCE]

Audience:
[AUDIENCE]

Point of view:
[YOUR OPINION OR TAKE]

Create a 9-post thread:
1. Hook tweet under 240 characters
2. Context tweet
3-7. Five useful points with examples
8. A practical checklist
9. Soft CTA pointing to [LINK]

Constraints:
- No clickbait.
- Each tweet should stand alone.
- Use simple language.
- Avoid hashtags unless highly relevant.

For LinkedIn, I would ask for story, checklist, and contrarian versions separately.

Step 4: Run an anti-generic rewrite

This is the step most people skip.

AI writing often sounds vague because it uses empty words like:

unlock
transform
game-changing
in today's fast-paced world
boost your productivity

Use a cleanup prompt:

You are a sharp editor. Rewrite this content so it sounds specific, useful, and human.

Draft:
[PASTE DRAFT]

Audience:
[AUDIENCE]

Personal examples or proof:
[EXAMPLES]

Rewrite with:
- clearer hook
- stronger verbs
- fewer generic claims
- more concrete examples
- natural CTA

Avoid:
- "game-changing"
- "unlock your potential"
- "in today's fast-paced world"
- fake urgency
- empty motivational language

This usually improves the content more than generating another draft from scratch.

Step 5: Build a simple content map

One idea can become:

1 blog post
2 LinkedIn posts
2 X threads
5 short posts
1 email newsletter
3 short video scripts
1 checklist
1 carousel outline
5 follow-up angles
10 hooks to test

But the goal is not volume. The goal is to find which angle people actually respond to.

Free sample and full system

I added a free sample set to GitHub:

https://github.com/Suifeng023/awesome-ai-prompts-free?utm_source=devto&utm_medium=article&utm_campaign=content_repurposing_launch

I also packaged the full workflow into a small prompt system:

AI Content Repurposing Prompt System

https://payhip.com/b/CAN9Z?utm_source=devto&utm_medium=article&utm_campaign=content_repurposing_launch

It includes prompts for:

universal content intake
blog to X/Twitter thread
article to LinkedIn posts
YouTube transcript to newsletter
podcast to short clips
product update to launch content
case study to sales assets
30-day content calendar
quality control
anti-generic rewriting

The most important lesson: do not ask AI for more content. Ask it to create better structures for turning one strong idea into useful assets.

MCP Explained: The Protocol Changing How AI Agents Talk to Your Code

Suifeng023 — Mon, 11 May 2026 13:50:24 +0000

If you've been following AI development in 2025-2026, you've probably seen the acronym MCP everywhere. It stands for Model Context Protocol, and it's rapidly becoming the lingua franca for AI agents to interact with tools, databases, APIs, and — most importantly — your codebase.

In this guide, I'll break down what MCP is, why it matters, and how you can start using it today.

What is MCP?

MCP is an open protocol standardized by Anthropic (the company behind Claude) that provides a universal way for AI models to connect with external tools and data sources. Think of it as USB-C for AI agents — a single standard that lets any AI model plug into any tool.

Before MCP, every AI tool had its own integration approach:

Cursor had its own file system access
ChatGPT had plugins
Claude had tool use
Each required custom implementation

MCP unifies all of this under one protocol.

The Architecture: Client-Server Model

┌─────────────┐         ┌─────────────┐         ┌─────────────┐
│   AI Model  │ ◄─────► │ MCP Client  │ ◄─────► │ MCP Server  │
│ (Claude, etc)│         │ (in your app)│         │  (your tool) │
└─────────────┘         └─────────────┘         └─────────────┘
                                                         │
                                                         ▼
                                                  ┌─────────────┐
                                                  │  Local API   │
                                                  │ File System  │
                                                  │  Database    │
                                                  └─────────────┘

Key Components:

MCP Host: The application the user interacts with (e.g., Claude Desktop, IDE)
MCP Client: Maintains 1:1 connections with servers, within the host
MCP Server: Lightweight programs that expose specific capabilities
Shared Resources: Tools, prompts, and resources the server provides

Three Core Capabilities

1. Resources

Resources are the data your AI agent can read:

@mcp.resource("file:///{path}")
def read_file(path: str) -> str:
    """Read a file from the local filesystem."""
    with open(path, 'r') as f:
        return f.read()

2. Tools

Tools are the actions your AI agent can perform:

@mcp.tool()
def execute_sql_query(query: str, database: str = "default") -> str:
    """Execute a SQL query against the configured database."""
    conn = get_connection(database)
    result = conn.execute(query)
    return json.dumps(result)

3. Prompts

Prompts are reusable templates for user interaction:

@mcp.prompt()
def code_review(file_path: str) -> str:
    """Generate a code review prompt for the given file."""
    code = read_file(file_path)
    return f"Please review this code:\n\n```
{% endraw %}
\n{code}\n
{% raw %}
```"

Building Your First MCP Server

Let's build a practical MCP server that lets Claude interact with a SQLite database:

# server.py
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("my-data-tools")

import sqlite3
import json

DB_PATH = "./my_database.db"

@mcp.tool()
def list_tables() -> list[str]:
    """List all tables in the database."""
    conn = sqlite3.connect(DB_PATH)
    cursor = conn.cursor()
    cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
    tables = [row[0] for row in cursor.fetchall()]
    conn.close()
    return tables

@mcp.tool()
def query_table(table: str, limit: int = 10) -> str:
    """Query a table and return the results as JSON."""
    conn = sqlite3.connect(DB_PATH)
    cursor = conn.cursor()
    cursor.execute(f"SELECT * FROM {table} LIMIT ?", (limit,))
    columns = [description[0] for description in cursor.description]
    rows = [dict(zip(columns, row)) for row in cursor.fetchall()]
    conn.close()
    return json.dumps(rows, indent=2, default=str)

@mcp.tool()
def run_custom_query(query: str) -> str:
    """Execute a custom SQL query (SELECT only for safety)."""
    if not query.strip().upper().startswith("SELECT"):
        return "Error: Only SELECT queries are allowed."
    conn = sqlite3.connect(DB_PATH)
    cursor = conn.cursor()
    try:
        cursor.execute(query)
        columns = [description[0] for description in cursor.description]
        rows = [dict(zip(columns, row)) for row in cursor.fetchall()]
        return json.dumps(rows, indent=2, default=str)
    except Exception as e:
        return f"Error: {str(e)}"
    finally:
        conn.close()

if __name__ == "__main__":
    mcp.run()

Running the Server

pip install mcp
python server.py

Connecting Claude Desktop

Add this to your Claude Desktop config (claude_desktop_config.json):

{
  "mcpServers": {
    "my-data-tools": {
      "command": "python",
      "args": ["/path/to/server.py"]
    }
  }
}

Restart Claude Desktop, and you'll see a 🔨 icon — your tools are now available!

Real-World Use Cases

1. Database Exploration

Ask Claude directly: "Show me the top 10 users by revenue from the orders table."

2. API Integration

Build an MCP server wrapping your internal APIs. Claude can fetch real-time data.

3. File Operations

The official MCP filesystem server lets Claude read, write, and search files — perfect for code review.

4. Git Operations

Create branches, commit changes, and review diffs through natural language.

Why MCP Matters for Developers

Write once, use everywhere: Build one MCP server, use it with Claude, ChatGPT, Cursor, Windsurf
Security: The protocol runs locally — your data doesn't go to a third party
Composability: Mix and match servers for powerful AI workflows
Open standard: No vendor lock-in

Getting Started Checklist

[ ] Install the MCP Python SDK: pip install mcp
[ ] Build a simple server with one tool
[ ] Connect it to Claude Desktop
[ ] Test with a natural language prompt
[ ] Explore official server examples on GitHub

Conclusion

MCP is more than another API spec — it's a paradigm shift in how AI agents interact with software. By providing a universal protocol for tool use, MCP eliminates the "every AI needs its own integration" problem.

The ecosystem is young and growing fast. Now is the perfect time to get involved.

For more AI developer guides, check out my Developer Prompt Bible — 200+ battle-tested prompts for coding with AI.

I Wrote 500 ChatGPT Marketing Prompts — Here Are the 15 That Actually Convert

Suifeng023 — Mon, 11 May 2026 12:32:01 +0000

I Wrote 500 ChatGPT Marketing Prompts — Here Are the 15 That Actually Convert

I spent the last 3 months testing AI-generated marketing copy across email campaigns, landing pages, social media, and ads. Most prompts produced generic fluff.

But 15 of them? They consistently generated copy that outperformed human-written alternatives.

Here they are, categorized by use case.

📧 Email Marketing (4 Prompts)

1. The Subject Line A/B Generator

Write 10 email subject lines for a [product/service] targeting [audience]. 
5 should use curiosity gaps, 3 should use urgency, and 2 should use personalization.
Keep each under 50 characters. Explain the psychological trigger behind each.

2. The Abandoned Cart Recovery

Write a 3-part abandoned cart email sequence for [product]. 
Email 1 (1hr later): Gentle reminder
Email 2 (24hr later): Address objections  
Email 3 (48hr later): Final offer with incentive
Tone: Friendly, not desperate. Include one specific objection per email.

3. The Welcome Sequence Architect

Create a 5-email welcome sequence for [business type] subscribers.
Email 1: Thank you + set expectations
Email 2: Quick win / value bomb
Email 3: Story + brand values
Email 4: Social proof / case study
Email 5: Soft pitch
Keep each email under 200 words. Write in [tone] voice.

4. The Re-engagement Revival

Write a re-engagement email for subscribers who haven't opened in 60+ days.
Use the "we miss you" angle but avoid being cheesy.
Include: a compelling reason to re-engage, a small incentive, and a clear CTA.
Subject line must create curiosity without being clickbait.

📄 Landing Page Copy (4 Prompts)

5. The Hero Section Formula

Write a hero section for a landing page selling [product] to [audience].
Structure: 
1. Headline (under 10 words, outcome-focused)
2. Subheadline (explains how, under 20 words)
3. 3 bullet benefits (specific, quantifiable)
4. Primary CTA button text
5. Secondary CTA text
Avoid: "revolutionary", "cutting-edge", "game-changing". Use concrete language.

6. The Objection Destroyer

List the top 5 objections someone has before buying [product].
For each objection, write a 2-3 sentence response that:
1. Acknowledges the concern (don't dismiss it)
2. Provides evidence or logic to overcome it
3. Includes a micro-CTA
Format as an FAQ section for a landing page.

7. The Social Proof Amplifier

Transform this basic testimonial into 3 formats:
Original: "[paste testimonial]"

Format 1: Pull quote for homepage (one sentence, maximum impact)
Format 2: Case study snippet (problem → solution → result)
Format 3: Social media graphic text (short, shareable, with metric)

8. The Before-After Framework

Write a "before/after" comparison section for [product] targeting [audience].

BEFORE section: Describe their current pain point in vivid, emotional detail
(3 sentences, second person "you")

AFTER section: Paint the picture of life after using [product]
(3 sentences, same emotional intensity but positive)

Bridge: One sentence transition connecting the two.

📱 Social Media (4 Prompts)

9. The LinkedIn Authority Post

Write a LinkedIn post that establishes thought leadership on [topic].
Structure:
- Hook (first 2 lines, must stop scrolling)
- Story or observation (personal, specific)
- Lesson or framework (3-5 bullet points)
- Call to action (question, not link drop)
Tone: Professional but human. No corporate speak.
Length: 150-200 words.

10. The Twitter/X Thread Blueprint

Write a 7-tweet thread about [topic] that teaches something actionable.
Tweet 1: Controversial hook or surprising stat
Tweets 2-5: Steps/insights (one per tweet, start with numbers)
Tweet 6: Common mistake people make
Tweet 7: Summary + "What's your take?" CTA
Each tweet must work standalone if someone only sees one.

11. The Instagram Carousel Script

Write a 10-slide Instagram carousel about [topic].
Slide 1: Attention-grabbing headline
Slides 2-8: One key point per slide (short, punchy)
Slide 9: Summary/recap
Slide 10: CTA + save prompt
Each slide text: under 20 words.
Caption: 150 words expanding on the content with 5 relevant hashtags.

12. The Product Launch Teaser

Create a 3-post social media teaser sequence for launching [product].
Post 1 (7 days before): Vague curiosity — hint at a problem you're solving
Post 2 (3 days before): Show a sneak peek or behind-the-scenes
Post 3 (launch day): Announcement with clear value prop and CTA
Each post needs: Hook, body (under 50 words), CTA, and 3 hashtag suggestions.

💰 Ad Copy (3 Prompts)

13. The Facebook Ad Multi-Variant

Write 5 versions of Facebook ad copy for [product] targeting [audience].

Version 1: Problem-agitation-solution (PAS) framework
Version 2: Story-driven (short narrative)
Version 3: Direct response (features + benefits + offer)
Version 4: Social proof focused (testimonial style)
Version 5: Question-led (engagement bait done ethically)

Each: Primary text (under 125 chars for mobile), headline (under 40 chars), description (under 30 chars).

14. The Google Ads Copy Matrix

Write 10 Google Ads headlines and 4 descriptions for [product].

Requirements:
- Include exact, phrase, and broad match keyword variations
- 3 headlines must include numbers
- 2 headlines must ask questions
- 1 headline must include your unique value proposition
- Each description must have a clear CTA
- No exclamation marks in headlines (they decrease CTR)

15. The Retargeting Ad

Write a retargeting ad for people who visited [product page] but didn't buy.
They know what the product is — focus on overcoming hesitation.

Write 3 versions:
1. Social proof version ("Join 10,000+ who...")
2. Urgency version ("Price increases [date]" or "Only X spots left")
3. Risk reversal version ("Try it for 30 days, full refund if...")
Each under 90 characters for display ads.

🔑 Why These Work (The Pattern)

After analyzing what made these 15 prompts different from the 485 that failed, I found 3 common elements:

Specific constraints — "under 50 characters", "3 sentences" — force the AI to be precise
Psychological frameworks — PAS, AIDA, before/after, social proof — give the AI a proven structure
Anti-fluff rules — explicitly banning generic words ("revolutionary", "innovative") eliminates the AI's tendency to be vague

The biggest mistake? Asking the AI to "write marketing copy" without a framework. It's like telling a developer to "build an app" without requirements.

Ready to Scale Your Marketing with AI?

I packaged 500+ tested marketing prompts organized by channel, framework, and use case — including the exact prompts above plus 485 more covering email sequences, ad copy, content marketing, SEO, and more.

Every prompt includes:

Fill-in-the-blank templates
Which framework it uses
When to use (and NOT use) it
Example output

👉 Get the AI Marketing Copy Prompt Pack

Which prompt are you trying first? Let me know in the comments!

marketing #chatgpt #copywriting #ai #productivity

10 ChatGPT Prompts That Actually Make You a Better Developer

Suifeng023 — Mon, 11 May 2026 12:31:22 +0000

10 ChatGPT Prompts That Actually Make You a Better Developer

Every developer knows ChatGPT can write code. But most developers are using it wrong — they ask vague questions and get mediocre answers.

After testing thousands of prompts across real projects, here are the 10 that consistently deliver production-quality output.

1. The Architecture Review Prompt

I'm building a [technology stack] application that [describe feature]. 
Review my architecture and identify:
1. Potential bottlenecks
2. Security vulnerabilities  
3. Scalability concerns
4. Suggested improvements with code examples

Why it works: It forces structured thinking instead of a generic "is this good?" question.

2. The Debug Detective

I have a bug in my [language/framework] code. Here's what I know:
- Expected behavior: [describe]
- Actual behavior: [describe]
- Error message: [paste exact error]
- Code snippet: [paste code]

Don't just fix it — explain WHY it broke and how to prevent similar bugs.

Pro tip: The "explain why" part is what separates a quick fix from real learning.

3. The Code Review Simulator

Act as a senior engineer conducting a code review. Review this [language] code for:
1. Code smells and anti-patterns
2. Performance issues
3. Edge cases not handled
4. Naming conventions
5. Test coverage gaps

Rate each issue by severity (Critical/Warning/Suggestion).

4. The Refactoring Engine

Refactor this code to improve readability, performance, and maintainability:
[paste code]

Rules:
- Keep the same functionality
- Follow [language] best practices
- Add comments explaining each change
- Show before/after comparison

5. The API Design Prompt

Design a REST API for [describe your application]. Include:
1. All endpoints with HTTP methods
2. Request/response schemas
3. Authentication strategy
4. Error handling patterns
5. Rate limiting approach

6. The Test Generation Factory

Generate comprehensive unit tests for this [language/framework] function:
[paste code]

Include:
- Happy path tests
- Edge case tests
- Error handling tests
- Mock examples where needed
Use [testing framework] conventions.

7. The Documentation Writer

Generate professional documentation for this [language] module/function:
[paste code]

Include:
- JSDoc/docstring format
- Parameter descriptions with types
- Return value documentation
- Usage examples (3 examples: basic, intermediate, advanced)
- Common gotchas

8. The Regex Builder

Create a regex that [describe what you need to match].
Requirements:
- [specific rule 1]
- [specific rule 2]
- [specific rule 3]

Provide:
1. The regex pattern
2. Explanation of each component
3. Test cases it should match
4. Test cases it should NOT match
5. Code example in [language]

9. The Performance Optimizer

Analyze this [language] code for performance issues:
[paste code]

For each issue found:
1. Explain the performance impact
2. Provide the optimized version
3. Show the time complexity before/after
4. Explain when this optimization matters vs. premature optimization

10. The Learning Path Generator

I'm a [current skill level] developer who wants to learn [technology/skill].
Create a 30-day learning plan that includes:
1. Daily topics (15 min reading + 45 min practice)
2. One mini-project per week
3. Resources for each topic (free only)
4. Milestone checkpoints
5. A capstone project for day 30

The Secret Ingredient: Context Stacking

Here's what most people miss — the quality of your output is directly proportional to the context you provide.

Before using any of these prompts, try this:

Define your role: "Act as a senior [specialty] engineer with 10 years of experience"
Set constraints: "We're using [specific versions/libraries]"
Provide examples: "Here's the style I want: [example code]"
Iterate: "Good, now make it more [specific quality]"

Want More?

If you found these useful, I've compiled 200+ battle-tested developer prompts covering debugging, code review, system design, and more — organized by use case so you never have to think about how to phrase your request.

👉 Check out the Developer's Prompt Bible

What's your go-to ChatGPT prompt for development work? Share it in the comments!

chatgpt #prompts #productivity #ai

Claude AI Is Underrated: 10 Prompts That Made Me Switch from ChatGPT

Suifeng023 — Mon, 11 May 2026 12:19:58 +0000

Claude AI Is Underrated: 10 Prompts That Made Me Switch from ChatGPT

I've used ChatGPT daily for two years. But after a month with Claude, I'm convinced most people are using the wrong tool for the wrong reasons.

Claude has a superpower that ChatGPT doesn't: it actually follows complex instructions without breaking character. This changes everything about how you write prompts.

Here are 10 prompts where Claude dramatically outperforms ChatGPT — and why.

Why Claude Is Different (And Why It Matters)

ChatGPT tends to drift. You ask for a specific format, and it slowly morphs into something else by paragraph three. Claude holds structure like a steel beam.

This isn't fanboyism — it's a practical observation that affects how I write prompts:

Aspect	ChatGPT	Claude
Long-form consistency	Degrades after ~500 words	Maintains structure throughout
Following negative constraints	Often forgets "don't do X"	Rarely violates constraints
Code with explanations	Over-explains basics	Explains the right level
Multi-step reasoning	Skips steps	Follows each step precisely
Tone consistency	Shifts mid-response	Locks into requested tone

With that context, here are the prompts where Claude shines.

1. The 5000-Word Technical Guide

ChatGPT struggles with long-form content that maintains quality. Claude doesn't.

Write a comprehensive technical guide about [TOPIC] for [AUDIENCE LEVEL].

Structure requirements:
- Total length: approximately 5000 words
- Each section must be 500-800 words
- Include at least 3 code examples per major section
- Use analogies for complex concepts (one per section maximum)
- End each section with a "Key Takeaways" box

Sections to cover:
1. Introduction and Problem Statement
2. Core Concepts (with visual descriptions for diagrams)
3. Architecture Overview
4. Step-by-Step Implementation
5. Common Pitfalls and Solutions
6. Performance Optimization
7. Testing Strategy
8. Real-World Case Study

Tone: Senior engineer mentoring a mid-level colleague.
Do NOT use bullet-point lists for the main content — use flowing paragraphs with inline code.
Only use tables for comparison data.

Start with a one-paragraph hook that makes the reader realize they NEED this knowledge.

Why Claude wins: It maintains the no-bullet-point rule across 5000 words. ChatGPT almost always relapses into lists.

2. The Multi-Persona Meeting Simulator

Simulate a architecture review meeting with 4 participants:

Participants:
1. Sarah - Staff Engineer (focused on scalability, asks hard questions)
2. Marcus - Product Manager (focused on user impact, pushes back on complexity)
3. Aisha - Security Lead (focused on vulnerabilities, compliance requirements)
4. Dev - Junior Developer (asks clarifying questions, sometimes surfaces important naive perspectives)

Topic: We're migrating [SYSTEM] from [OLD TECH] to [NEW TECH].

Rules:
- Each person speaks in a distinct voice and personality
- Sarah is direct but respectful, uses technical jargon
- Marcus avoids jargon, always brings it back to user value
- Aisha references specific security frameworks and compliance standards
- Dev asks questions that reveal assumptions others take for granted
- Generate at least 12 exchanges
- The conversation should reveal genuine trade-offs, not artificial agreement
- End with a decision and action items

Format: "Name: Dialogue" — no narration between lines.

Why Claude wins: Each persona stays consistent across 12+ exchanges. ChatGPT tends to blend voices after a few rounds.

3. The Constraint-Heavy API Design

Design a REST API for [PRODUCT/SERVICE].

Hard constraints:
- Maximum 15 endpoints
- No endpoint should require more than 3 query parameters
- All endpoints must support pagination (same pattern)
- Authentication: Bearer token only
- Rate limiting: 100 req/min for free, 1000 for paid
- Version in URL path (/v1/)

For each endpoint provide:
1. HTTP method + path
2. One-line description
3. Request body schema (JSON, with types)
4. Response schema (success + error)
5. Authentication requirement

Then answer:
- Which endpoints would you combine or remove if forced to cut to 10?
- What would you add if the limit was 25?
- What's the most controversial design decision here and why?

Why Claude wins: The hard constraints (max 15 endpoints, max 3 params) are treated as actual limits, not suggestions.

4. The Code-to-Documentation Pipeline

I will give you source code. Convert it into THREE types of documentation:

Code:
[PASTE CODE]

Generate:

## 1. README Section (for GitHub)
- What it does (2 sentences)
- Installation (exact commands)
- Usage example with 3 scenarios
- Configuration options table
- Common errors table with solutions

## 2. API Reference (for internal docs)
- Every public function/method
- Parameters with types and defaults
- Return values
- Exceptions raised
- Example calls

## 3. Architecture Decision Record (ADR)
- Context: What problem does this code solve?
- Decision: What approach was chosen?
- Consequences: What are the trade-offs?

Rules:
- Never invent functionality that doesn't exist in the code
- If something is unclear, mark it with ⚠️
- Estimate the reading level needed (beginner/intermediate/advanced)

Why Claude wins: Produces all three documentation types without hallucinating features that don't exist in the code.

5. The Gradual Complexity Tutor

You are a programming tutor. I want to learn [TOPIC].

Teach me in 5 levels. I must say "next" before you advance.

Level 1: The 30-second explanation a smart 12-year-old would understand
Level 2: The explanation you'd give to a non-technical manager
Level 3: The explanation for a junior developer in a different domain
Level 4: The explanation for a mid-level developer who'll implement this
Level 5: The edge cases, performance nuances, and production considerations

Rules:
- Each level builds on the previous one (don't repeat, extend)
- Use a NEW analogy at each level (never reuse the same metaphor)
- Include one code example starting from Level 3
- At Level 4, include a "common mistakes" warning
- At Level 5, include a comparison table of approaches

Wait for my "next" command between each level.
Begin with Level 1 now.

Why Claude wins: The progressive complexity actually progresses. Each level genuinely builds rather than repeating with more jargon.

6. The Honest Code Review with Alternatives

Review this code. I want HONEST feedback, not polite encouragement.

Code:
[PASTE CODE]

Provide your review in this exact format:

## Overall Assessment
[One paragraph. Include a score from 1-10 and justify it.]

## Problems Found
[List each problem with:]
- Severity: 🔴/🟡/🟢
- Line(s) affected
- Why it's a problem (not just what)
- How to fix it

## What's Actually Good
[Be specific. Don't say "clean code" — say "the error handling in the retry function is well-structured because..."]

## Three Alternative Approaches
[Describe 3 different ways to solve the same problem, with pros/cons of each vs the current approach]

## Learning Resources
[If there are concepts the developer should study, list specific resources (book chapters, blog posts, docs sections)]

Why Claude wins: The "honest not polite" instruction actually sticks. Claude will give a 4/10 score if deserved.

7. The System Design Interview Coach

Conduct a mock system design interview for [SYSTEM TYPE] (e.g., "design Twitter" / "design Uber" / "design a URL shortener").

Be the interviewer. Ask ONE question at a time and wait for my response.

Interview structure:
1. Requirements gathering (ask me clarifying questions)
2. High-level design (ask for a diagram description)
3. Deep dive into 2-3 components (your choice based on my answers)
4. Scalability discussion
5. Trade-off decisions

Rules:
- Grade each of my responses (A/B/C/D)
- If I give a weak answer, ask a follow-up that guides me to think deeper
- After 8 exchanges, give me a final evaluation
- Include: what I did well, what I missed, and one concept I should study

Start with: "Let's design [SYSTEM]. What questions do you have about the requirements?"

Why Claude wins: The grading is consistent and the follow-up questions actually build on previous answers.

8. The Data Pipeline Design Prompt

Design a data pipeline for this use case:

Source: [DESCRIBE DATA SOURCE]
Destination: [DESCRIBE WHERE DATA NEEDS TO GO]
Volume: [ESTIMATED DATA VOLUME]
Latency requirement: [REAL-TIME/BATCH/HYBRID]
Budget constraints: [ANY LIMITATIONS]

Provide:
1. Architecture diagram description (components + data flow)
2. Technology stack recommendation with alternatives
3. Error handling strategy (what happens when a step fails)
4. Data quality checks (where and what to validate)
5. Monitoring and alerting plan
6. Cost estimation (monthly, at 1x and 10x volume)
7. Migration plan from current state (if applicable)

Format: Professional technical design document.
Each recommendation must include: what, why this choice, what we sacrifice.

9. The Recursive Prompt Improver

I will give you a prompt. Improve it using this process:

Original prompt:
[PASTE YOUR PROMPT]

Step 1: Analyze weaknesses in the original prompt
Step 2: Rate it (1-10) on: clarity, specificity, constraint usage, output format definition
Step 3: Produce an improved version
Step 4: Explain each change and why it matters
Step 5: Provide 3 test inputs where the improved prompt would produce better output

Then ask if I want you to improve it further (iterate up to 3 times).

Why Claude wins: It understands what makes a prompt good and explains the reasoning behind each improvement.

10. The "Explain Like I'm Reviewing Your PR" Prompt

I'm reviewing your pull request. Explain your changes to me as if I'm a skeptical senior engineer who thinks this might be over-engineered.

Code changes:
[PASTE CODE DIFF]

Respond as the developer:
1. Start with "Here's what I changed and why" (keep it under 100 words)
2. Then address: "Why not just [obvious simpler alternative]?"
3. Then: "What breaks if this goes wrong?"
4. Then: "What's the rollback plan?"
5. End with: "What I'd want you to focus on in this review"

Rules:
- Don't be defensive
- Acknowledge trade-offs openly
- If there IS a simpler approach, admit it

Why Claude wins: The role-play feels authentic, not like a template being filled in.

The Practical Takeaway

Claude isn't universally better than ChatGPT. But for structured, constrained, long-form tasks — the kind that make up most professional work — it's significantly more reliable.

The key pattern: Claude respects constraints that ChatGPT ignores.

If you find yourself constantly re-prompting ChatGPT to "stay on format" or "remember the rules I set," you're probably using the wrong tool.

Want More Battle-Tested Prompts?

I've spent months testing prompts across both Claude and ChatGPT. The ones that actually work (not just sound good) are organized in these packs:

🔧 Developer's Prompt Bible — 100+ prompts for coding, debugging, architecture, and DevOps (works with both Claude and ChatGPT)
📈 AI Marketing Copy Prompt Pack — Conversion-focused prompts for landing pages, emails, ads, and social media
🎨 Midjourney Commercial Design Prompt Pack — Professional visual design prompts with style templates

Each prompt is tested and refined across multiple AI platforms.

What's your experience with Claude vs ChatGPT? Which do you prefer for what tasks? Drop your thoughts in the comments.

I Wrote 500+ AI Prompts — Here Are the 15 That Actually Save Me Hours Every Day

Suifeng023 — Mon, 11 May 2026 12:17:17 +0000

I Wrote 500+ AI Prompts — Here Are the 15 That Actually Save Me Hours Every Day

After testing hundreds of AI prompts across ChatGPT, Claude, and Gemini, most of them turned out to be generic fluff. But a handful? They genuinely transformed how I work.

I'm sharing the 15 that survived my ruthless testing process — and the framework I use to write prompts that actually work.

The Prompt Framework Nobody Talks About

Most people write prompts like this:

"Write a blog post about AI"

Then wonder why the output is generic garbage. The problem isn't the AI — it's the prompt structure.

After analyzing what separates effective prompts from time-wasters, I landed on this framework:

[ROLE] + [CONTEXT] + [SPECIFIC INPUT] + [CONSTRAINTS] + [OUTPUT FORMAT] + [DECISION RULES]

Let me break down each component and show you real examples.

1. The Code Review Prompt

You are a senior software engineer with 15 years of experience in [LANGUAGE/Framework].

Review the following code for:
1. Bugs and logic errors
2. Performance issues
3. Security vulnerabilities
4. Code style and maintainability

For each issue found:
- Rate severity: 🔴 Critical / 🟡 Warning / 🟢 Suggestion
- Show the problematic line
- Explain WHY it's an issue
- Provide the corrected code

Do NOT suggest changes that are purely stylistic preferences.

CODE:
[PASTE YOUR CODE HERE]

Why it works: The severity rating system forces structured output. The "no stylistic preferences" constraint eliminates noise.

2. The Landing Page Converter

You are a direct-response copywriter who has generated $50M+ in revenue for SaaS companies.

Write a landing page for [PRODUCT] targeting [AUDIENCE].

Product details: [BRIEF DESCRIPTION]
Key benefit: [MAIN BENEFIT]
Pain point solved: [SPECIFIC PAIN]

Requirements:
- Hero section with headline + subheadline + CTA
- 3 feature sections with benefit-focused headers
- Social proof section (create 3 realistic testimonials)
- FAQ section with 5 objections
- Final CTA section

Tone: Conversational but authoritative. No corporate jargon.
Each headline must be under 10 words.
Every section must end with a reason to take action NOW.

Do NOT use: "revolutionary", "cutting-edge", "game-changer", "synergy"

Why it works: The forbidden words list eliminates generic marketing speak. The "end with urgency" rule creates natural flow.

3. The Debug Detective

You are a debugging specialist. I will give you code and an error message.

Step 1: Identify the ROOT CAUSE (not just the symptom)
Step 2: Explain WHY this error occurs in simple terms
Step 3: Provide the minimal fix
Step 4: Explain how to PREVENT this in the future
Step 5: Rate the likelihood of this bug occurring in production (1-10)

Error message:
[PASTE ERROR]

Code:
[PASTE CODE]

Why it works: Step-by-step structure prevents the AI from jumping to conclusions. The prevention step adds long-term value.

4. The Email Sequence Builder

You are an email marketing strategist with a 45% open rate track record.

Create a 5-email welcome sequence for [BUSINESS TYPE] selling [PRODUCT/SERVICE].

Target audience: [DESCRIBE IDEAL CUSTOMER]
Sequence goal: [CONVERSION/SUBSCRIPTION/ETC]

For each email provide:
- Subject line (under 50 characters) + 2 A/B variants
- Preview text
- Full email body (under 200 words)
- Send timing (how many days after previous email)
- The ONE action the reader should take

Rules:
- Email 1: Welcome + quick win (no pitch)
- Email 2: Story + problem agitation
- Email 3: Solution reveal + social proof
- Email 4: Handle top 3 objections
- Email 5: Final push + urgency element

Why it works: Email-specific constraints (character limits, timing) force realistic output. The sequence structure follows proven marketing psychology.

5. The Refactoring Expert

You are a software architect specializing in clean code and design patterns.

Refactor the following [LANGUAGE] code to improve:
1. Readability
2. Maintainability  
3. Testability
4. Performance (where applicable)

Rules:
- Preserve ALL existing functionality
- Add comments only where logic is non-obvious
- Apply appropriate design patterns
- Keep functions under 20 lines
- Reduce cyclomatic complexity
- Show BEFORE → AFTER comparison
- List each change with the reasoning

Original code:
[PASTE CODE]

6. The API Documentation Writer

You are a technical writer who specializes in developer documentation.

Create comprehensive API documentation for this endpoint:

Endpoint: [METHOD] [PATH]
Purpose: [WHAT IT DOES]
Auth: [AUTH TYPE]

Include:
1. Description (2-3 sentences)
2. Request headers table
3. Request body schema (with types, required/optional, descriptions)
4. Query parameters table
5. Response schema for: 200, 400, 401, 404, 500
6. 3 curl examples (basic, with all params, error case)
7. Code examples in: Python, JavaScript, Go
8. Rate limiting info
9. Common errors and troubleshooting

Format in Markdown. Use tables for parameters. Use code blocks with language tags.

7. The Product Brief Generator

You are a product manager at a top-tier tech company.

Create a product brief for: [PRODUCT IDEA]

Include:
1. Problem Statement (who, what, why now)
2. Target User Personas (3 with demographics, goals, frustrations)
3. User Stories (5 in "As a [user], I want [action] so that [benefit]" format)
4. Success Metrics (3 primary, 3 secondary)
5. Competitive Landscape (list 5 competitors + their weakness)
6. MVP Feature Priority (MoSCoW method)
7. Risks & Mitigations
8. 30-60-90 Day Launch Timeline

Be specific. Use numbers. No vague statements.

8. The SQL Query Architect

You are a database optimization expert.

I need to write a SQL query for:

Database: [POSTGRESQL/MYSQL/ETC]
Tables involved: [LIST TABLES]
What I need: [DESCRIBE DESIRED RESULT]

Requirements:
1. Write the most EFFICIENT query (consider indexes, execution plan)
2. Add a query plan analysis
3. Provide 2 alternative approaches with trade-offs
4. Include proper indexing suggestions
5. Add comments explaining complex joins/subqueries

Schema:
[PASTE RELEVANT SCHEMA]

9. The Meeting Summary to Action Items

You are an executive assistant who turns messy meeting notes into clear action items.

Meeting notes:
[PASTE NOTES]

Extract and format:
## Attendees
[List names and roles]

## Key Decisions Made
[Bullet list with decision + who decided + rationale]

## Action Items
| Owner | Task | Deadline | Priority | Dependencies |
|-------|------|----------|----------|--------------|

## Open Questions
[Numbered list of unresolved items]

## Next Meeting Agenda Items
[Based on what was discussed]

If anything is ambiguous, mark it with ❓ and suggest what clarification is needed.

10. The Technical Interview Prep

You are a senior engineering interviewer at FAANG.

I'm preparing for a [TYPE] interview at [COMPANY LEVEL].

Generate 5 realistic interview questions with:
1. The question
2. What the interviewer is REALLY testing
3. A strong answer framework
4. Common mistakes to avoid
5. Follow-up questions they might ask

Difficulty: [JUNIOR/MID/SENIOR]
Domain: [SPECIFIC DOMAIN]

11. The Midjourney Commercial Prompt

Create a Midjourney prompt for a [PRODUCT TYPE] advertisement.

Product: [DESCRIBE PRODUCT]
Brand mood: [LUXURY/FRIENDLY/BOLD/MINIMAL]
Target platform: [INSTAGRAM/WEBSITE/PRINT]

Prompt structure:
[SUBJECT] + [SETTING] + [LIGHTING] + [CAMERA ANGLE] + [STYLE] + [COLOR PALETTE] + [TECHNICAL PARAMS]

Requirements:
- Photorealistic quality
- Professional commercial feel
- Include negative prompt
- Suggest 3 aspect ratios for different platforms
- Provide 3 style variations

Example structure: "A [product] placed on [surface], [lighting description], shot from [angle], [style], [colors], --ar [ratio] --v 6 --style raw"

12. The Regex Builder

You are a regex expert.

I need a regular expression that:

Description: [WHAT IT SHOULD MATCH]
Language: [PROGRAMMING LANGUAGE]
Examples of valid input: [LIST 3-5]
Examples of invalid input: [LIST 3-5]

Provide:
1. The regex pattern
2. Explanation of each part
3. Test cases (pass + fail)
4. A breakdown of edge cases handled
5. Performance considerations

Bonus: Provide a readable (verbose) version with comments.

13. The Presentation Script Writer

You are a presentation coach who has helped founders raise $100M+.

Write a script for a [LENGTH]-minute presentation about [TOPIC].

Audience: [WHO'S LISTENING]
Goal: [PERSUADE/INFORM/SELL]
Tone: [PROFESSIONAL/CASUAL/INSPIRATIONAL]

For each slide provide:
- Slide number and title
- What to DISPLAY (bullet points, max 6 words each)
- What to SAY (speaking notes, conversational tone)
- Transition to next slide (one sentence)
- Estimated time for this slide

Rules:
- Opening: Start with a surprising statistic or question
- Every 3 slides: Include a story or example
- Closing: End with a clear call-to-action
- Total speaking time must fit in [LENGTH] minutes
- No bullet point should exceed 7 words

14. The Competitor Analysis Prompt

You are a competitive intelligence analyst.

Analyze these competitors in the [INDUSTRY] space:

Competitors: [LIST 3-5 COMPETITORS]
My product: [DESCRIBE YOUR PRODUCT]

For each competitor:
1. Positioning statement (one sentence)
2. Pricing model
3. Target audience
4. Key features (top 5)
5. Marketing channels they use
6. Their biggest weakness
7. What they do better than everyone else

Then provide:
- Feature comparison matrix
- Market gap analysis (what's missing in the market)
- Positioning recommendation for my product
- 3 differentiation strategies

15. The Unit Test Generator

You are a QA engineer specializing in test-driven development.

Generate comprehensive unit tests for this [LANGUAGE] code:

[PASTE CODE]

Testing framework: [JEST/PYTEST/JUNIT/ETC]

Requirements:
- Test coverage goal: >90%
- Include: happy path, edge cases, error cases
- Use descriptive test names that read like documentation
- Group tests with describe/context blocks
- Include setup/teardown if needed
- Mock external dependencies
- Add comments for complex test scenarios

Format:
1. List test cases before the code (planning)
2. Full test code
3. Coverage report summary
4. Any untested scenarios and why

The Meta-Pattern: Why These 15 Work

Looking at all 15 prompts, you'll notice they share these qualities:

Specific role assignment — Not "be helpful" but "be a senior engineer with 15 years experience"
Structured output format — Tables, numbered lists, specific sections
Constraints that eliminate garbage — Forbidden words, character limits, "do NOT" rules
Decision rules — Priority ratings, severity scores, MoSCoW method
Real-world context — Not abstract, but tied to actual workflows

Want 500+ More?

These 15 are samples from a larger collection. I've organized 500+ production-ready prompts into three packs:

🔧 Developer's Prompt Bible — 100+ prompts for coding, debugging, architecture, and DevOps
📈 AI Marketing Copy Prompt Pack — Conversion-focused prompts for landing pages, emails, ads, and social media
🎨 Midjourney Commercial Design Prompt Pack — Professional visual design prompts with style templates

Each prompt uses the framework I described above. No fluff, no generic templates — just prompts that produce results you can actually use.

What's Your Best Prompt?

Drop your most effective AI prompt in the comments. I'm always looking for new patterns to add to the collection.

If you found this useful, follow me for more prompt engineering content. I share techniques I've discovered from writing and testing hundreds of AI workflows.

The Prompt Template I Use for Useful AI Outputs

Suifeng023 — Mon, 11 May 2026 11:41:11 +0000

The Prompt Template I Use for Useful AI Outputs

A lot of AI output feels generic because the prompt asks for an answer, not a workflow.

The reusable structure I use is:

Role + context + inputs + constraints + output format + decision rule

Here is a simple example for product copy:

You are a direct-response copywriter.

Product: [PRODUCT]
Audience: [AUDIENCE]
Pain: [PAIN]
Desired result: [RESULT]
Proof: [PROOF]

Write:
1. Headline under 12 words
2. Subheadline under 28 words
3. 5 benefit bullets tied to use cases
4. 3 objections with answers
5. CTA button text

Constraints:
- Avoid hype words.
- Be specific enough that the buyer knows whether it is for them.

And for code review:

You are a senior software engineer reviewing a pull request.

Context:
- Stack: [STACK]
- Change summary: [CHANGE]
- Risk tolerance: [LOW/MEDIUM/HIGH]

Review:
[DIFF]

Return bugs ranked by severity, missing tests, security risks, exact patch suggestions, and a merge recommendation.

I published free samples here:

https://github.com/Suifeng023/awesome-ai-prompts-free?utm_source=devto&utm_medium=article&utm_campaign=promptcraft_launch&utm_content=template_article

Full packs are here:

Developer prompts: https://payhip.com/b/ADsQI?utm_source=devto&utm_medium=article&utm_campaign=promptcraft_launch&utm_content=template_article
Marketing prompts: https://payhip.com/b/6lqVh?utm_source=devto&utm_medium=article&utm_campaign=promptcraft_launch&utm_content=template_article
Midjourney design prompts: https://payhip.com/b/XLNPm?utm_source=devto&utm_medium=article&utm_campaign=promptcraft_launch&utm_content=template_article

I Replaced My Prompt Library With 3 Reusable AI Systems

Suifeng023 — Mon, 11 May 2026 11:39:21 +0000

I Replaced My Prompt Library With 3 Reusable AI Systems — Here Are the Free Samples

Most AI prompt packs fail because they are just lists of generic commands.

A useful prompt library needs three things:

Role context — the model needs to know what job it is doing.
Inputs and constraints — the prompt should force the user to fill in the missing business context.
A repeatable output format — so the answer can be reused in real work.

I have been building a small prompt library for developers, marketers, and visual creators. Below are three free samples you can copy today.

1. Developer prompt: code review with risk ranking

You are a senior software engineer reviewing a pull request.

Context:
- Project type: [WEB APP / API / CLI / DATA PIPELINE]
- Main stack: [LANGUAGE + FRAMEWORK]
- Change summary: [WHAT CHANGED]
- Risk tolerance: [LOW / MEDIUM / HIGH]

Review the following diff or description: ""
[PASTE DIFF OR DESCRIPTION]

Return:
1. A 5-bullet executive summary
2. Bugs ranked by severity: Critical, High, Medium, Low
3. Security and privacy risks
4. Missing tests
5. Exact patch suggestions where possible
6. One final merge recommendation: approve / request changes / needs human decision

Rules:
- Do not comment on style unless it can cause a bug or maintainability issue.
- Prefer concrete examples over general advice.
- If information is missing, state the assumption and continue.

Why it works: it pushes the model away from vague code comments and toward a decision-oriented review.

2. Marketing prompt: turn features into conversion copy

You are a direct-response copywriter for a small digital product.

Product:
- Name: [PRODUCT NAME]
- Audience: [WHO BUYS]
- Pain point: [WHAT PROBLEM THEY HAVE]
- Main promise: [RESULT]
- Proof or credibility: [WHY BELIEVE IT]
- Price: [PRICE]

Create a landing page section with:
1. Headline under 12 words
2. Subheadline under 28 words
3. 5 benefit bullets, each tied to a real use case
4. 3 objections and concise answers
5. CTA button text
6. A short social post for X/Twitter

Constraints:
- Avoid hype words like revolutionary, ultimate, game-changing.
- Make it specific enough that a buyer knows whether it is for them.

Why it works: it forces the model to connect product features to buyer motivation.

3. Midjourney prompt: commercial design brief

You are an art director writing a commercial image-generation prompt.

Brief:
- Product or subject: [SUBJECT]
- Use case: [AD / LANDING PAGE / SOCIAL POSTER / PACKAGING]
- Brand personality: [3 ADJECTIVES]
- Target customer: [AUDIENCE]
- Color palette: [COLORS]
- Required composition: [LAYOUT]
- Avoid: [THINGS TO EXCLUDE]

Create 5 image prompts.
Each prompt must include:
- subject and composition
- lighting
- lens or camera style
- background
- color and texture notes
- commercial usage angle
- negative prompt

Make the prompts visually distinct from each other.

Why it works: it starts from a design brief, not from random aesthetic keywords.

The bigger pattern

A good reusable prompt is not a magic sentence. It is a mini workflow:

Role + context + inputs + constraints + output format + decision rule

If you build your own library, I recommend sorting prompts by job-to-be-done rather than by tool. For example:

Debug code
Review PRs
Write launch copy
Create social posts
Generate ad concepts
Turn a design brief into visuals

That structure makes the library useful when you are busy.

Full packs

I turned this structure into three compact paid prompt packs:

Developer's Prompt Bible — debugging, PR review, refactoring, docs, architecture, tests: https://payhip.com/b/ADsQI?utm_source=devto&utm_medium=article&utm_campaign=promptcraft_launch&utm_content=developer_pack
AI Marketing Copy Prompt Pack — landing pages, emails, ads, social posts, offers: https://payhip.com/b/6lqVh?utm_source=devto&utm_medium=article&utm_campaign=promptcraft_launch&utm_content=marketing_pack
Midjourney Commercial Design Prompt Pack — product visuals, ads, brand images, poster concepts: https://payhip.com/b/XLNPm?utm_source=devto&utm_medium=article&utm_campaign=promptcraft_launch&utm_content=midjourney_pack

If you only need the free samples, copy the prompts above. If you want the organized full versions, the packs are on PromptCraft.

Quick checklist for better prompts

Does the prompt define a role?
Does it ask for missing context?
Does it include constraints?
Does it specify the output format?
Does it help you make a decision or ship something?

If the answer is no, it is probably just a prompt idea — not a workflow.