AI产品从0到1的PMF验证checklist：30天快速验证的工程方法
作者：钟伊人 | 日期：2026-07-29 | Week5 总结与趋势判断
模块一：PMF验证的核心框架
什么是PMF（Product-Market Fit）？
PMF是产品与市场匹配的缩写。Sean Ellis定义：40%以上的用户"非常失望"如果没有你的产品，就达到了PMF。对于AI产品，PMF的定义更严格：
- 用户是否愿意为AI功能付费？
- AI功能是否显著优于传统方案？
- 用户使用频率是否足够高？
AI产品PMF验证的特殊性：
"""
PMF验证数据模型
追踪关键指标，量化PMF进度
"""
from dataclasses import dataclass
from typing import List, Dict, Optional
from datetime import datetime, timedelta
import json
@dataclass
class PMFMetrics:
"""PMF关键指标"""
# 用户指标
total_users: int
active_users_7d: int # 7日活跃
active_users_30d: int # 30日活跃
retention_day1: float # 次日留存率
retention_day7: float # 7日留存率
retention_day30: float # 30日留存率
# 参与度指标
avg_sessions_per_user: float
avg_session_duration_min: float
feature_usage_rate: Dict[str, float] # 功能使用率
# 满意度指标
nps_score: float # Net Promoter Score
very_disappointed_pct: float # "非常失望"百分比（Sean Ellis指标）
# 商业指标
free_to_paid_conversion: float
monthly_churn_rate: float
ltv_cac_ratio: float # 生命周期价值 / 获客成本
# AI特有指标
ai_usage_per_user: float # 人均AI功能使用次数
ai_cost_per_user: float # 人均AI成本
ai_accuracy_satisfaction: float # AI准确度满意度
class PMFValidator:
"""
PMF验证器
30天快速验证框架
"""
def __init__(self, product_name: str):
self.product_name = product_name
self.start_date = datetime.now()
self.metrics_history: List[PMFMetrics] = []
self.user_feedback: List[Dict] = []
def day_1_setup(self) -> Dict:
"""
Day 1：设置验证框架
任务：
1. 定义假设（Hypothesis）
2. 设计MVP功能范围
3. 确定目标用户画像
4. 设置追踪指标
"""
checklist = {
"hypothesis_defined": False, # 假设已定义
"mvp_scope_defined": False, # MVP范围已定义
"target_users_defined": False, # 目标用户已定义
"tracking_setup": False, # 数据追踪已设置
"feedback_channel_setup": False, # 反馈渠道已设置
}
print("=" * 60)
print(f"Day 1：{self.product_name} PMF验证启动")
print("=" * 60)
print("\\n任务清单：")
print(" [ ] 定义核心假设（最多3个）")
print(" [ ] 定义MVP功能范围（最多3个核心功能）")
print(" [ ] 定义目标用户画像（最多2类）")
print(" [ ] 设置数据追踪（埋点）")
print(" [ ] 设置用户反馈收集渠道")
print("\\n核心假设模板：")
print(" 我们相信 [目标用户] 需要 [产品功能]")
print(" 因为 [问题/痛点]")
print(" 我们将通过 [关键指标] 来验证")
return checklist
def day_7_first_users(self, metrics: PMFMetrics) -> Dict:
"""
Day 7：首批用户反馈
关键问题：
1. 用户是否理解了产品价值？
2. 用户是否愿意继续使用？
3. AI功能的准确度是否满足期望？
"""
evaluation = {}
# 检查1：是否有用户注册
evaluation["has_users"] = metrics.total_users > 0
# 检查2：次日留存率
evaluation["good_retention_d1"] = metrics.retention_day1 >= 0.4 # 40%+
# 检查3：AI功能是否被使用
evaluation["ai_used"] = metrics.ai_usage_per_user > 0
# 检查4：成本是否合理
evaluation["cost_reasonable"] = metrics.ai_cost_per_user < 1.0 # 人均成本<$1
# 综合判断
passed = sum(evaluation.values())
evaluation["day7_passed"] = passed >= 3
if not evaluation["day7_passed"]:
print("⚠️ Day 7评估：未通过，需要调整方向")
print("建议：")
if not evaluation["has_users"]:
print(" – 问题：没有用户注册")
print(" – 建议：检查产品定位和价值传达")
if not evaluation["good_retention_d1"]:
print(" – 问题：次日留存率低")
print(" – 建议：访谈流失用户，了解原因")
else:
print("✅ Day 7评估：通过，继续验证")
return evaluation
def day_14_iteration(self, metrics: PMFMetrics) -> Dict:
"""
Day 14：第一次迭代
基于前7天的数据和反馈，进行第一次产品迭代
"""
insights = {
"top_feature": max(metrics.feature_usage_rate,
key=metrics.feature_usage_rate.get),
"retention_trend": "improving" if metrics.retention_day7 > metrics.retention_day1 else "declining",
"ai_cost_trend": "acceptable" if metrics.ai_cost_per_user < 0.5 else "too_high"
}
print("\\nDay 14 洞察：")
print(f" 最受欢迎功能：{insights['top_feature']}")
print(f" 留存趋势：{insights['retention_trend']}")
print(f" AI成本趋势：{insights['ai_cost_trend']}")
return insights
def day_30_pmf_assessment(self, metrics: PMFMetrics) -> Dict:
"""
Day 30：PMF评估
判断是否达到PMF（Sean Ellis标准）
"""
result = {}
# 标准1：Sean Ellis指标（40%以上用户"非常失望"）
result["sean_ellis_pass"] = metrics.very_disappointed_pct >= 0.4
# 标准2：留存率（7日留存>30%，30日留存>15%）
result["retention_pass"] = (metrics.retention_day7 >= 0.3 and
metrics.retention_day30 >= 0.15)
# 标准3：NPS（Net Promoter Score > 40）
result["nps_pass"] = metrics.nps_score >= 40
# 标准4：付费意愿（免费到付费转化率>5%）
result["monetization_pass"] = metrics.free_to_paid_conversion >= 0.05
# 标准5：LTV/CAC > 3（生命周期价值/获客成本）
result["unit_economics_pass"] = metrics.ltv_cac_ratio >= 3
# AI产品特有：成本可控
result["ai_cost_pass"] = metrics.ai_cost_per_user < 2.0
# 综合判断
passed_count = sum([
result["sean_ellis_pass"],
result["retention_pass"],
result["nps_pass"],
result["monetization_pass"],
result["unit_economics_pass"],
result["ai_cost_pass"]
])
result["pmf_achieved"] = passed_count >= 4 # 至少通过4个标准
result["passed_count"] = passed_count
if result["pmf_achieved"]:
print("🎉 恭喜！产品已达到PMF！")
print("建议：开始规模化增长")
else:
print(f"⚠️ PMF未达到（通过{passed_count}/6项标准）")
print("建议：继续迭代产品或调整方向")
self._print_improvement_suggestions(result)
return result
def _print_improvement_suggestions(self, result: Dict):
"""打印改进建议"""
if not result["sean_ellis_pass"]:
print(" – 改进方向：提升产品核心价值（用户访谈）")
if not result["retention_pass"]:
print(" – 改进方向：提升用户参与度（新功能/通知）")
if not result["nps_pass"]:
print(" – 改进方向：提升用户体验（UI/性能优化）")
if not result["monetization_pass"]:
print(" – 改进方向：调整定价策略或提升价值感知")
if not result["unit_economics_pass"]:
print(" – 改进方向：降低获客成本或提升LTV")
if not result["ai_cost_pass"]:
print(" – 改进方向：优化AI成本（缓存/模型选择）")
Mermaid：30天PMF验证时间线
模块二：AI产品MVP的工程实现
AI产品MVP的特殊考虑
AI产品的MVP比传统产品更复杂：
"""
AI产品MVP脚手架
快速搭建可验证的AI产品原型
"""
from abc import ABC, abstractmethod
from typing import List, Dict, Any, Optional
import time
import json
class AIMVPBase(ABC):
"""
AI产品MVP基类
提供通用的PMF验证功能
"""
def __init__(self, product_name: str):
self.product_name = product_name
self.users: Dict[str, Dict] = {} # user_id -> user_data
self.usage_logs: List[Dict] = []
self.feedback: List[Dict] = []
self.start_time = time.time()
@abstractmethod
def process_user_request(self, user_id: str, request: str) -> Dict:
"""
处理用户请求（AI核心功能）
每个AI产品必须实现此方法
"""
pass
def track_usage(self, user_id: str, action: str, metadata: Dict = None):
"""追踪用户行为"""
log = {
"user_id": user_id,
"action": action,
"timestamp": time.time(),
"metadata": metadata or {}
}
self.usage_logs.append(log)
def collect_feedback(self, user_id: str, feedback: Dict):
"""收集用户反馈"""
feedback["user_id"] = user_id
feedback["timestamp"] = time.time()
self.feedback.append(feedback)
def get_metrics(self) -> PMFMetrics:
"""计算当前PMF指标"""
total_users = len(self.users)
# 计算留存率（简化）
now = time.time()
day1_active = sum(
1 for u in self.users.values()
if now – u.get("last_active", 0) <= 86400
)
day7_active = sum(
1 for u in self.users.values()
if now – u.get("last_active", 0) <= 7 * 86400
)
retention_d1 = day1_active / total_users if total_users > 0 else 0
retention_d7 = day7_active / total_users if total_users > 0 else 0
# 计算AI使用指标
ai_usage = {}
for log in self.usage_logs:
action = log["action"]
ai_usage[action] = ai_usage.get(action, 0) + 1
avg_ai_usage = sum(ai_usage.values()) / total_users if total_users > 0 else 0
# 计算NPS（简化）
promoters = sum(1 for f in self.feedback if f.get("rating", 0) >= 4)
detractors = sum(1 for f in self.feedback if f.get("rating", 0) <= 2)
nps = ((promoters – detractors) / len(self.feedback) * 100) if self.feedback else 0
return PMFMetrics(
total_users=total_users,
active_users_7d=day7_active,
active_users_30d=day7_active, # 简化
retention_day1=retention_d1,
retention_day7=retention_d7,
retention_day30=retention_d7 * 0.5, # 估算
avg_sessions_per_user=len(self.usage_logs) / total_users if total_users > 0 else 0,
avg_session_duration_min=5.0, # 简化
feature_usage_rate=ai_usage,
nps_score=nps,
very_disappointed_pct=0.0, # 需要通过问卷收集
free_to_paid_conversion=0.0,
monthly_churn_rate=0.0,
ltv_cac_ratio=0.0,
ai_usage_per_user=avg_ai_usage,
ai_cost_per_user=0.0, # 需要从账单计算
ai_accuracy_satisfaction=0.0
)
# 示例：AI写作助手MVP
class AIWritingAssistantMVP(AIMVPBase):
"""
AI写作助手MVP
用于演示PMF验证流程
"""
def __init__(self, llm_client, api_cost_per_1k_tokens: float = 0.01):
super().__init__("AI写作助手")
self.llm = llm_client
self.api_cost = api_cost_per_1k_tokens
self.total_api_cost = 0.0
def process_user_request(self, user_id: str, request: str) -> Dict:
"""
处理写作请求
MVP阶段的核心功能：
1. 根据提示词生成文章大纲
2. 根据大纲生成正文
"""
# 追踪开始时间（用于测量延迟）
start_time = time.time()
# 功能1：生成大纲
if request.startswith("大纲："):
topic = request[3:].strip()
result = self._generate_outline(user_id, topic)
# 功能2：生成正文
elif request.startswith("生成："):
outline = request[3:].strip()
result = self._generate_content(user_id, outline)
else:
result = {"error": "未知请求类型"}
# 追踪使用
latency = time.time() – start_time
self.track_usage(user_id, "ai_request", {
"latency": latency,
"request_type": "outline" if "大纲" in request else "content"
})
# 更新用户最后活跃时间
if user_id in self.users:
self.users[user_id]["last_active"] = time.time()
return result
def _generate_outline(self, user_id: str, topic: str) -> Dict:
"""生成文章大纲"""
prompt = f"""请为以下主题生成一个详细的文章大纲：
主题：{topic}
要求：
1. 包含5-8个主要章节
2. 每个章节有2-3个子点
3. 逻辑清晰，层次分明
输出格式：Markdown格式的大纲"""
try:
# 调用LLM（简化：实际应使用self.llm）
# response = self.llm.generate(prompt)
response = f"# {topic}\\n\\n## 引言\\n## 主体\\n## 结论"
# 模拟API成本
estimated_tokens = len(prompt) / 4 + len(response) / 4
cost = estimated_tokens / 1000 * self.api_cost
self.total_api_cost += cost
return {
"success": True,
"outline": response,
"estimated_cost_usd": round(cost, 4)
}
except Exception as e:
return {
"success": False,
"error": str(e)
}
def _generate_content(self, user_id: str, outline: str) -> Dict:
"""根据大纲生成正文"""
prompt = f"""请根据以下大纲生成文章正文：
大纲：
{outline}
要求：
1. 每个章节展开为200-300字
2. 语言流畅，逻辑清晰
3. 使用简体中文
输出格式：完整的Markdown文章"""
try:
# 调用LLM
response = f"根据大纲生成的文章内容…\\n\\n{outline}"
# 模拟API成本
estimated_tokens = len(prompt) / 4 + len(response) / 4
cost = estimated_tokens / 1000 * self.api_cost
self.total_api_cost += cost
return {
"success": True,
"content": response,
"estimated_cost_usd": round(cost, 4)
}
except Exception as e:
return {
"success": False,
"error": str(e)
}
def register_user(self, user_id: str, email: str):
"""注册用户"""
self.users[user_id] = {
"email": email,
"registered_at": time.time(),
"last_active": time.time()
}
print(f"用户 {user_id} 注册成功")
def get_cost_report(self) -> Dict:
"""获取成本报告"""
total_users = len(self.users)
return {
"total_api_cost_usd": round(self.total_api_cost, 2),
"cost_per_user_usd": round(self.total_api_cost / total_users, 4) if total_users > 0 else 0,
"total_users": total_users
}
模块三：用户访谈与反馈分析
为什么用户访谈比数据更重要？
数据是后视镜，访谈是探照灯。数据告诉你"什么"发生了，访谈告诉你"为什么"。
"""
用户访谈框架
AI产品PMF验证的核心活动
"""
from typing import List, Dict
import json
class UserInterviewFramework:
"""
用户访谈框架
访谈的核心目标：
1. 验证核心假设
2. 发现未满足的需求
3. 了解用户真实使用场景
4. 收集改进建议
"""
def __init__(self):
self.interviews: List[Dict] = []
def prepare_interview_guide(self, product_stage: str = "mvp") -> List[str]:
"""
准备访谈提纲
Args:
product_stage: 产品阶段（mvp / iteration / scaling）
"""
if product_stage == "mvp":
# MVP阶段：验证核心假设
questions = [
# 开场（建立信任）
"请介绍一下你自己和你的工作？",
"你目前是如何解决[我们解决的问题]的？",
"",
# 产品体验
"你第一次使用我们的产品时，感觉如何？",
"哪个功能最有用？为什么？",
"哪个功能最没用？为什么？",
"",
# 核心价值
"如果你不能再使用这个产品，会有什么影响？",
"你会向朋友推荐这个产品吗？为什么？",
"",
# 改进建议
"如果可以添加一个功能，你希望是什么？",
"有什么让你感到困惑或沮丧的地方？"
]
elif product_stage == "iteration":
# 迭代阶段：深入了解使用细节
questions = [
"你最近一次使用产品是为了什么？",
"产品是否满足了你的期望？",
"与其他工具相比，我们的产品有什么优势/劣势？",
"你希望我们在哪方面改进？"
]
else:
# 增长阶段：了解扩展需求
questions = [
"你是否在团队中分享了这个产品？",
"你的团队有什么特殊需求？",
"你愿意为哪些功能付费？"
]
return questions
def conduct_interview(self,
user_id: str,
user_background: str,
interview_notes: str) -> Dict:
"""
记录访谈结果
Returns: 访谈洞察
"""
interview = {
"user_id": user_id,
"background": user_background,
"notes": interview_notes,
"timestamp": time.time(),
"insights": {}
}
# 提取关键洞察（简化：实际应人工分析）
insights = self._extract_insights(interview_notes)
interview["insights"] = insights
self.interviews.append(interview)
return insights
def _extract_insights(self, notes: str) -> Dict:
"""从访谈笔记中提取洞察（简化）"""
# 实际应使用NLP或人工分析
insights = {
"pain_points": [], # 痛点
"delights": [], # 满意点
"feature_requests": [], # 功能请求
"confusion": [] # 困惑点
}
return insights
def analyze_all_interviews(self) -> Dict:
"""分析所有访谈，提取模式"""
if not self.interviews:
return {"error": "尚无访谈数据"}
# 汇总洞察
all_pain_points = []
all_delights = []
all_feature_requests = []
for interview in self.interviews:
insights = interview.get("insights", {})
all_pain_points.extend(insights.get("pain_points", []))
all_delights.extend(insights.get("delights", []))
all_feature_requests.extend(insights.get("feature_requests", []))
# 找出最常见的模式
from collections import Counter
return {
"total_interviews": len(self.interviews),
"top_pain_points": Counter(all_pain_points).most_common(5),
"top_delights": Counter(all_delights).most_common(5),
"top_feature_requests": Counter(all_feature_requests).most_common(5),
"pmf_signal": self._calculate_pmf_signal()
}
def _calculate_pmf_signal(self) -> str:
"""计算PMF信号（基于访谈）"""
very_disappointed_count = 0
for interview in self.interviews:
notes = interview.get("notes", "")
# 简化：检查是否包含"非常失望"或类似表达
if any(word in notes for word in ["非常失望", "离不开", "必不可少"]):
very_disappointed_count += 1
pct = very_disappointed_count / len(self.interviews) if self.interviews else 0
if pct >= 0.4:
return "强PMF信号（>=40%用户非常失望）"
elif pct >= 0.2:
return "中等PMF信号（20-40%用户非常失望）"
else:
return "弱PMF信号（<20%用户非常失望）"
Mermaid：用户访谈流程
模块四：AI产品特有的验证挑战
挑战1：AI准确度与用户期望的差距
AI产品的准确度很难达到100%。但用户往往期望AI是"全知全能"的。需要在产品中管理用户期望。
"""
AI产品中的期望管理
"""
class AIExpectationManager:
"""
AI期望管理器
策略：
1. 在UI中明确告知AI的局限性
2. 提供置信度评分
3. 允许用户纠正错误
4. 持续展示改进
"""
def __init__(self):
self.confidence_threshold = 0.7 # 置信度阈值
def add_expectation_management_ui(self, response: Dict) -> Dict:
"""
在AI响应中添加期望管理元素
返回更新后的响应，包含：
– 置信度指示
– 免责声明
– 反馈按钮
"""
confidence = response.get("confidence", 0.5)
# 添加置信度指示
if confidence >= 0.8:
confidence_label = "高置信度"
confidence_color = "green"
elif confidence >= 0.5:
confidence_label = "中置信度"
confidence_color = "orange"
else:
confidence_label = "低置信度"
confidence_color = "red"
response["ui_metadata"] = {
"confidence_label": confidence_label,
"confidence_color": confidence_color,
"disclaimer": "AI生成内容可能不准确，请谨慎参考",
"feedback_buttons": ["准确", "不准确", "部分准确"]
}
return response
def generate_disclaimer_text(self, use_case: str) -> str:
"""生成针对特定用例的免责声明"""
disclaimers = {
"medical": "本AI不提供医疗建议，请咨询专业医生",
"legal": "本AI不提供法律建议，请咨询专业律师",
"financial": "本AI不提供投资建议，投资有风险",
"general": "AI生成内容可能包含错误，请自行核实"
}
return disclaimers.get(use_case, disclaimers["general"])
挑战2：AI成本与用户付费意愿的差距
这是2026年AI创业公司失败的主要原因。API成本远超用户付费意愿。
"""
AI成本与定价分析工具
"""
class AICostPricingAnalyzer:
"""
AI成本与定价分析器
核心问题：
– 每个用户的AI使用成本是多少？
– 用户愿意支付多少？
– 如何实现盈利？
"""
def __init__(self):
self.cost_data = []
self.pricing_data = []
def analyze_unit_economics(self,
avg_ai_cost_per_user: float,
avg_subscription_price: float,
gross_margin_pct: float) -> Dict:
"""
分析单位经济模型
Args:
avg_ai_cost_per_user: 人均AI成本（美元/月）
avg_subscription_price: 平均订阅价格（美元/月）
gross_margin_pct: 毛利率（扣除AI成本后）
"""
# 计算毛利率
gross_profit = avg_subscription_price – avg_ai_cost_per_user
actual_margin_pct = (gross_profit / avg_subscription_price
if avg_subscription_price > 0 else 0)
result = {
"ai_cost_per_user": avg_ai_cost_per_user,
"subscription_price": avg_subscription_price,
"gross_profit_per_user": gross_profit,
"gross_margin_pct": round(actual_margin_pct * 100, 1),
"is_profitable": gross_profit > 0
}
# 建议
if not result["is_profitable"]:
result["recommendations"] = [
"降低AI成本（使用更便宜的模型、缓存、批处理）",
"提高订阅价格",
"限制免费用户的AI使用次数",
"引导用户使用低成本功能"
]
else:
result["recommendations"] = [
"单位经济健康，可以考虑增长投入"
]
return result
def suggest_pricing_strategy(self,
product_type: str,
target_users: str) -> Dict:
"""
建议定价策略
AI产品的常见定价模式：
1. 按使用量计费（如API调用次数）
2. 订阅制（如每月$10）
3. 混合模式（基础订阅+超额计费）
"""
strategies = {
"api_usage": {
"name": "按使用量计费",
"pros": ["用户只付使用的部分", "成本可控"],
"cons": ["收入不稳定", "需要防止滥用"],
"example": "每次AI调用$0.01"
},
"subscription": {
"name": "订阅制",
"pros": ["收入可预测", "用户粘性高"],
"cons": ["需要控制重度用户成本", "可能有亏损用户"],
"example": "每月$10，包含100次AI调用"
},
"freemium": {
"name": "免费增值",
"pros": ["快速获取用户", "降低试用门槛"],
"cons": ["免费用户成本高", "转化率低"],
"example": "免费用户每天3次，付费无限制"
}
}
return strategies.get(product_type, strategies["freemium"])
模块五：决策框架与Next Steps
PMF验证后的决策树
30天验证结束后，需要根据结果做出决策：
"""
PMF验证后决策框架
"""
class PostPMFDecisionFramework:
"""
PMF验证后决策框架
"""
def __init__(self):
self.decision_options = {
"scale": "规模化增长",
"iterate": "继续迭代产品",
"pivot": "调整方向",
"pause": "暂停项目"
}
def make_decision(self, pmf_result: Dict, resources: Dict) -> Dict:
"""
基于PMF结果和资源情况做出决策
Args:
pmf_result: PMF评估结果
resources: 资源情况（资金、团队等）
"""
# 决策矩阵
if pmf_result["pmf_achieved"]:
# 达到PMF
if resources.get("funding_months", 0) > 6:
decision = "scale"
reason = "PMF已达成，资源充足，开始规模化增长"
else:
decision = "iterate"
reason = "PMF已达成，但资源有限，先优化单位经济"
else:
# 未达到PMF
passed_count = pmf_result["passed_count"]
if passed_count >= 3:
decision = "iterate"
reason = f"接近PMF（通过{passed_count}/6项），继续迭代"
elif passed_count >= 2:
if resources.get("funding_months", 0) > 3:
decision = "pivot"
reason = "PMF较远，但资源充足，可以考虑调整方向"
else:
decision = "pause"
reason = "PMF较远，资源不足，建议暂停"
else:
decision = "pause"
reason = "PMF非常远，建议暂停并反思核心假设"
return {
"decision": decision,
"reason": reason,
"next_steps": self._get_next_steps(decision)
}
def _get_next_steps(self, decision: str) -> List[str]:
"""获取决策后的下一步行动"""
steps = {
"scale": [
"制定增长策略（付费获客 vs 有机增长）",
"扩大团队（重点是增长和运维）",
"确保单位经济健康（LTV/CAC > 3）",
"建立客户成功团队"
],
"iterate": [
"深度用户访谈（找出未满足需求）",
"快速迭代MVP（2周一个版本）",
"优化AI成本（如果成本是问题）",
"重新定义价值主张"
],
"pivot": [
"重新审视核心假设",
"访谈潜在新用户",
"开发新的MVP（快速验证）",
"考虑是否更换问题领域"
],
"pause": [
"总结教训（为什么没达到PMF）",
"评估是否值得继续投入",
"考虑开源或出售技术",
"团队成员转移到其他项目"
]
}
return steps.get(decision, [])
Mermaid：PMF验证决策树
30天PMF验证Checklist汇总
"""
30天PMF验证完整Checklist
"""
FULL_CHECKLIST = {
"Day 1-3：准备阶段": [
"() 定义核心假设（最多3个）",
"() 定义MVP功能范围（最多3个功能）",
"() 确定目标用户画像（最多2类）",
"() 搭建MVP原型（可用AI脚手架）",
"() 设置数据追踪（埋点）",
"() 设置用户反馈收集（问卷+访谈）",
],
"Day 4-7：首批用户": [
"() 获取首批10-20个用户",
"() 观察用户注册流程",
"() 收集第一批使用数据",
"() 进行第一批用户访谈（3-5人）",
"() 计算Day 7指标",
],
"Day 8-14：第一次迭代": [
"() 分析首批用户反馈",
"() 确定最需改进的1-2个问题",
"() 快速迭代MVP",
"() 扩大测试用户到50-100人",
"() 开始追踪AI成本和准确度",
],
"Day 15-21：深度验证": [
"() 进行更多用户访谈（累计10-15人）",
"() 计算留存率和参与度指标",
"() 测试不同定价策略（如果准备商业化）",
"() 收集Sean Ellis问卷数据",
],
"Day 22-30：PMF评估": [
"() 计算所有PMF指标",
"() 进行PMF达标评估",
"() 做出决策（规模化/迭代/调整/暂停）",
"() 制定下一步计划",
]
}
def print_full_checklist():
print("=" * 70)
print("AI产品PMF验证30天完整Checklist")
print("=" * 70)
for period, items in FULL_CHECKLIST.items():
print(f"\\n【{period}】")
for item in items:
print(f" {item}")
print("\\n完成所有Checklist项目后，再进行PMF决策！")
纯技术总结
- PMF定义：Sean Ellis标准（40%用户"非常失望"），AI产品需额外关注成本可控性和准确度满意度
- 30天验证框架：Day1-3准备（假设+MVP+埋点），Day4-7首批用户，Day8-14第一次迭代，Day15-21深度验证，Day22-30 PMF评估决策
- AI产品MVP要点：真实AI能力（非假按钮）、成本控制（API成本追踪）、期望管理（置信度UI+免责声明）
- 用户访谈核心：验证假设+发现未知需求+收集改进建议；访谈后提取痛点/满意点/功能请求模式
- 成本与定价：单位经济必须正向（订阅价>AI成本）；推荐免费增值模式（免费限次+付费无限制）
- 决策框架：PMF达成且资金>6月→规模化；PMF未达但通过≥3项→继续迭代；通过<2项→暂停反思
