用 Claude Code 和 Python 搭建内容创作流水线：灵感捕捉、生成与审查

让 Claude Code 生成大纲

有了灵感库，接下来让 Claude Code 读文件并输出大纲：

# 让 Claude Code 读取灵感并生成大纲
claude-code "请读取 inspirations.json 中最新的一条 pending 灵感，基于它生成一篇技术文章的大纲。要求：
1. 文章类型：教程/实战经验
2. 目标读者：有一定基础的开发者
3. 大纲结构：包含引言、核心内容（3-5 个小节）、代码示例、总结
4. 输出格式：Markdown"

内容生成与质量控制脚本

我把流程拆成几个类，方便复用：

# content_workflow.py
import subprocess
import time
from pathlib import Path

class ContentWorkflow:
    """AI 驱动的内容创作工作流"""
    def __init__(self, claude_code_path="claude-code"):
        self.claude_path = claude_code_path
        self.work_dir = Path("articles")
        self.work_dir.mkdir(exist_ok=True)

    def generate_outline(self, inspiration_data):
        """
        生成文章大纲
        Args:
            inspiration_data: 灵感数据字典
        """
        prompt = f"""
        基于以下灵感生成文章大纲：
        灵感内容：{inspiration_data['idea']}
        标签：{', '.join(inspiration_data['tags'])}
        背景：{inspiration_data.get('context','')}
        要求：
        1. 大纲要具体到每个小节的标题
        2. 标注哪些部分需要代码示例
        3. 估算每个小节的字数
        4. 输出为 Markdown 格式
        """
        return self._call_claude(prompt)

    def generate_section(self, outline, section_title):
        """
        生成指定小节的内容
        Args:
            outline: 完整大纲
            section_title: 要生成的小节标题
        """
        prompt = f"""
        你正在写一篇文章，大纲如下：
        {outline}
        现在请撰写"{section_title}"这一小节的完整内容。
        要求：
        1. 内容要充实，有具体例子
        2. 如果涉及代码，请提供完整可运行的代码
        3. 保持技术专业性，但要易懂
        4. 字数符合大纲估算
        """
        return self._call_claude(prompt)

    def _call_claude(self, prompt):
        """
        调用 Claude Code
        这是一个简化示例，实际中你可以使用 Claude Code 的 API 或 CLI
        """
        # 实际项目中，这里应该调用 Claude Code 的接口
        # 这里用伪代码示意
        result = subprocess.run([self.claude_path, prompt], capture_output=True, text=True)
        return result.stdout

    def review_content(self, content):
        """
        内容审查 - 让 AI 帮忙检查质量
        Args:
            content: 待审查的内容
        """
        review_prompt = f"""
        请从以下维度审查这篇文章，给出改进建议：
        {content}
        审查维度：
        1. 逻辑是否清晰
        2. 技术准确性
        3. 可读性
        4. 是否有遗漏的关键点
        5. 标题是否吸引人
        请以结构化的方式输出问题和建议。
        """
        return self._call_claude(review_prompt)

    def assemble_article(self, sections_data):
        """
        组装完整文章
        Args:
            sections_data: 各小节内容字典
        """
        article = []
        article.append("# " + sections_data.get("title", ""))
        article.append("\n")
        for section, content in sections_data.get("sections", {}).items():
            article.append(f"## {section}\n")
            article.append(content)
            article.append("\n\n")
        return "".join(article)

自动质量检查

写完还得过一遍基本检查，免得字数不够或者缺了必要章节：

# quality_checker.py
import re
from typing import List, Dict

class ContentQualityChecker:
    """内容质量检查器"""
    def __init__(self):
        self.checks = [
            self._check_word_count,
            self._check_code_blocks,
            self._check_readability,
            self._check_structure
        ]

    def check(self, content: str, requirements: Dict) -> Dict:
        """
        执行所有检查
        Args:
            content: 待检查内容
            requirements: 要求字典（如最小字数等）
        """
        results = {"passed": True, "issues": [], "warnings": []}
        for check_func in self.checks:
            result = check_func(content, requirements)
            if not result["passed"]:
                results["passed"] = False
                results["issues"].append(result["message"])
            elif result.get("warning"):
                results["warnings"].append(result["warning"])
        return results

    def _check_word_count(self, content: str, requirements: Dict) -> Dict:
        """检查字数"""
        word_count = len(content)
        min_words = requirements.get("min_words", 1000)
        if word_count < min_words:
            return {"passed": False, "message": f"字数不足：当前{word_count}字，要求至少{min_words}字"}
        return {"passed": True}

    def _check_code_blocks(self, content: str, requirements: Dict) -> Dict:
        """检查代码块"""
        code_blocks = re.findall(r'```[\s\S]*?```', content)
        required_blocks = requirements.get("min_code_blocks", 1)
        if len(code_blocks) < required_blocks:
            return {"passed": False, "message": f"代码块不足：当前{len(code_blocks)}个，要求至少{required_blocks}个"}
        return {"passed": True}

    def _check_readability(self, content: str, requirements: Dict) -> Dict:
        """检查可读性"""
        # 检查段落长度
        paragraphs = content.split('\n\n')
        long_paragraphs = [p for p in paragraphs if len(p) > 500]
        if long_paragraphs:
            return {"passed": True, "warning": f"发现{len(long_paragraphs)}个超长段落，建议拆分以提高可读性"}
        return {"passed": True}

    def _check_structure(self, content: str, requirements: Dict) -> Dict:
        """检查结构完整性"""
        required_sections = requirements.get("required_sections", [])
        missing = []
        for section in required_sections:
            if section not in content:
                missing.append(section)
        if missing:
            return {"passed": False, "message": f"缺少必要章节：{', '.join(missing)}"}
        return {"passed": True}

把流程串起来

最后用主函数把各个模块连起来：

# main_workflow.py
from capture_inspiration import InspirationCapture
from content_workflow import ContentWorkflow
from quality_checker import ContentQualityChecker

def main():
    # 初始化各模块
    capturer = InspirationCapture()
    workflow = ContentWorkflow()
    checker = ContentQualityChecker()

    # 获取待处理的灵感
    pending_ideas = capturer.get_pending_ideas()
    if not pending_ideas:
        print("没有待处理的灵感")
        return

    # 选择最新的一条
    idea = pending_ideas[0]
    print(f"正在处理灵感：{idea['idea']}")

    # 步骤 1: 生成大纲
    print("生成大纲...")
    outline = workflow.generate_outline(idea)
    print(outline)

    # 步骤 2: 分段生成内容
    print("生成内容...")
    sections = {}
    # 这里简化处理，实际应该解析 outline 中的各个小节
    section_titles = ["引言", "核心实现", "代码示例", "总结"]
    for title in section_titles:
        print(f"  正在生成：{title}")
        content = workflow.generate_section(outline, title)
        sections[title] = content
        time.sleep(1) # 避免请求过快

    # 步骤 3: 质量检查
    print("质量检查...")
    full_content = workflow.assemble_article({"title": idea['idea'], "sections": sections})
    quality_result = checker.check(full_content, {"min_words": 1500, "min_code_blocks": 3, "required_sections": ["引言", "核心实现", "总结"]})
    if quality_result["passed"]:
        print("质量检查通过！")
    else:
        print("质量检查未通过:")
        for issue in quality_result["issues"]:
            print(f" - {issue}")

    # 步骤 4: AI 审查
    print("AI 审查中...")
    review = workflow.review_content(full_content)
    print(review)

    # 步骤 5: 保存文章
    output_path = f"articles/{idea['id']}.md"
    with open(output_path, 'w', encoding='utf-8') as f:
        f.write(full_content)
    print(f"文章已保存至：{output_path}")

if __name__ == "__main__":
    main()

工具还是搭档？

很多开发者用 AI 有个误区：只把它当工具用，问一句答一句。我更倾向把 Claude Code 看成搭档。比如：

• 工具模式：'帮我写一个 Python 函数读取 JSON 文件'
• 搭档模式：'我正在构建一个内容创作系统，需要读取灵感数据。考虑到性能和可扩展性，你觉得用什么存储方式比较好？如果用 JSON，怎么处理并发写入的问题？'

第二种方式会让 AI 参与架构思考，指出你没注意到的坑。

总结

这几个 Python 脚本和 Claude Code 搭配，基本能覆盖从灵感捕捉到成稿的不少环节。AI 擅长信息整合和框架梳理，但价值判断、个性注入和情感共鸣只能靠人。工作流的设计就是把重复的事情交给 AI，人做决策和最后那一下润色。当然，自动化不是目的，省下来的时间应该花在选题、文笔和读者连接上。

参考资源

• Claude Code 官方文档
• Python 自动化实践
• 技术写作最佳实践