product-manager（产品经理）

Product Manager

Ensures features are not just implemented but actually user-accessible. Bridges the gap between "code complete" and "user can use it."

Integrates with:

• prd-analyzer — Reads tasks.db, features.json, PROJECT.md
• All implementation skills — Validates their output is user-facing

The Problem This Solves

PRD says: "User can export analytics to Tableau"
Backend:   ✓ analytics-api.ts exists with Tableau endpoints
Frontend:  ✗ No /analytics route
Navigation: ✗ No menu item
Result:    Feature "done" in tasks.db, but users can't access it

Core Workflow

1. DISCOVER   → Find project structure and framework
2. READ       → Load PRD features from prd-analyzer output
3. SCAN       → Search codebase for implementation evidence
4. AUDIT      → Check user-facing accessibility
5. ANALYZE    → Compare requirements vs reality
6. REPORT     → Generate gap analysis
7. REMEDIATE  → Create tasks for missing pieces

Quick Start

1. Discover Project

# Identify framework and structure
ls -la
cat package.json

Look for:

• Framework indicators (next.config.js, vite.config.ts, expo.json, etc.)
• Source structure (src/, app/, pages/, etc.)
• Backend location (backend/, server/, api/, etc.)

2. Load PRD Context

# From prd-analyzer output
cat .claude/PROJECT.md
cat .claude/features.json
sqlite3 .claude/tasks.db "SELECT id, title, status FROM epics"

3. Run Feature Audit

For each feature:

1. Check backend implementation
2. Check frontend implementation
3. Check user accessibility
4. Record findings

4. Generate Report

Output:

• audit-report.md — Human-readable gap analysis
• audit-results.json — Programmatic results
• Updated tasks.db — Remediation tasks added

Feature Completeness Model

Completeness Levels

Completeness Checklist

## Feature: [Name]

### Implementation
- [ ] Backend service/API implemented
- [ ] Database schema exists (if needed)
- [ ] Frontend components exist
- [ ] API integration complete

### Accessibility  
- [ ] Route/screen exists
- [ ] Reachable from navigation
- [ ] Mobile responsive (if web)
- [ ] Works on target platforms

### Polish
- [ ] Error states handled
- [ ] Loading states present
- [ ] Empty states designed
- [ ] Documented in help/docs

### Verdict: Level [0-5]

Framework Detection

Automatic Detection

// Detection order
const frameworkIndicators = {
  // Web Frameworks
  'next.config.js':     'nextjs',
  'next.config.mjs':    'nextjs',
  'next.config.ts':     'nextjs',
  'vite.config.ts':     'vite',
  'vite.config.js':     'vite',
  'remix.config.js':    'remix',
  'astro.config.mjs':   'astro',
  
  // React Router / TanStack
  'src/routes.tsx':     'react-router',
  'src/router.tsx':     'tanstack-router',
  'app/routes/':        'remix',
  
  // Mobile
  'app.json':           'expo',
  'expo.json':          'expo',
  'react-native.config.js': 'react-native',
  'ios/':               'react-native',
  'android/':           'react-native',
  
  // Backend
  'backend/':           'separate-backend',
  'server/':            'separate-backend',
  'api/':               'api-routes',
};

Framework-Specific Patterns

Detailed patterns: See references/framework-patterns.md

Scanning Process

Backend Scan

Find evidence of implementation:

# Services
find backend/src/services -name "*.ts" | head -20
grep -l "export.*class\|export.*function" backend/src/services/*.ts

# API routes/handlers
find . -path "*/api/*" -name "*.ts" | head -20
find . -path "*/handlers/*" -name "*.ts" | head -20

# Database models/schema
find . -name "schema.ts" -o -name "models.ts" -o -name "*.model.ts"

Frontend Scan

Find UI implementation:

# Routes/pages (framework-dependent)
find . -path "*/pages/*" -name "*.tsx" 2>/dev/null
find . -path "*/app/*" -name "page.tsx" 2>/dev/null
find . -path "*/screens/*" -name "*.tsx" 2>/dev/null
find . -path "*/routes/*" -name "*.tsx" 2>/dev/null

# Components
find . -path "*/components/*" -name "*.tsx" | grep -i "FEATURE_NAME"

# Navigation
grep -r "href=\|to=\|navigate\|Link" --include="*.tsx" src/components/nav/

API Integration Scan

Verify frontend calls backend:

# Find API calls
grep -r "fetch\|axios\|useMutation\|useQuery" --include="*.tsx" src/

# Find service imports
grep -r "import.*from.*services\|import.*from.*api" --include="*.tsx" src/

Navigation Scan

Check if feature is reachable:

# Find navigation components
find . -name "*nav*" -o -name "*sidebar*" -o -name "*menu*" | grep -E "\.(tsx|jsx)$"

# Check for links to feature
grep -r "/FEATURE_ROUTE" --include="*.tsx" src/

Audit Output

Audit Report Structure

# Feature Audit Report

**Project**: VoiceForm AI
**Audit Date**: 2026-01-12
**Framework**: Next.js (App Router) + Separate Backend

## Summary

| Metric | Count |
|--------|-------|
| Total Features | 30 |
| Fully Complete (L5) | 12 |
| Accessible (L4) | 5 |
| Routable (L3) | 3 |
| Frontend Exists (L2) | 2 |
| Backend Only (L1) | 8 |
| Not Started (L0) | 0 |

**Overall Completion**: 40% fully user-accessible

## Critical Gaps (P0 Features)

| Feature | Level | Missing |
|---------|-------|---------|
| F028 Analytics API | L1 | Frontend route, Navigation, UI |
| F029 Tenant Isolation | L1 | Settings UI, BYOK config screen |

## All Features

### F001: Survey Studio
**Level**: 5 - Complete ✅

**Evidence**:
- Backend: `backend/src/services/survey-studio.ts` ✓
- Route: `app/surveys/new/page.tsx` ✓
- Navigation: Sidebar "Create Survey" link ✓
- Documentation: Help article exists ✓

---

### F028: Analytics API
**Level**: 1 - Backend Only 🔴

**Evidence**:
- Backend: `backend/src/services/analytics-api.ts` ✓
- Route: ❌ No `/analytics` route found
- Navigation: ❌ No analytics link in navigation
- Documentation: ❌ No help article

**Remediation Required**:
1. Create `app/analytics/page.tsx`
2. Add Analytics to main navigation
3. Build dashboard components
4. Document analytics features

---

[...continues for all features...]

JSON Output

{
  "audit_date": "2026-01-12",
  "project": "VoiceForm AI",
  "framework": {
    "frontend": "nextjs-app",
    "backend": "separate",
    "mobile": null
  },
  "summary": {
    "total_features": 30,
    "by_level": {
      "L5_complete": 12,
      "L4_accessible": 5,
      "L3_routable": 3,
      "L2_frontend_exists": 2,
      "L1_backend_only": 8,
      "L0_not_started": 0
    }
  },
  "features": [
    {
      "id": "F028",
      "title": "Analytics API",
      "level": 1,
      "level_name": "backend_only",
      "evidence": {
        "backend": {
          "found": true,
          "files": ["backend/src/services/analytics-api.ts"]
        },
        "frontend": {
          "found": false,
          "files": []
        },
        "route": {
          "found": false,
          "path": null
        },
        "navigation": {
          "found": false,
          "location": null
        }
      },
      "remediation": [
        {
          "type": "create_route",
          "description": "Create analytics page",
          "path": "app/analytics/page.tsx"
        },
        {
          "type": "add_navigation",
          "description": "Add Analytics to sidebar"
        }
      ]
    }
  ]
}

Remediation Task Generation

Task Creation

For each gap, generate tasks in tasks.db:

-- New story for missing frontend
INSERT INTO stories (id, epic_id, title, description, status)
VALUES (
  'story-028-frontend',
  'epic-028',
  'Analytics Frontend Implementation',
  'Create user-facing analytics dashboard',
  'todo'
);

-- Tasks for the story
INSERT INTO tasks (id, story_id, title, task_type, estimate_hours, status)
VALUES 
  ('task-028-f01', 'story-028-frontend', 'Create /analytics route', 'frontend', 4, 'todo'),
  ('task-028-f02', 'story-028-frontend', 'Build analytics dashboard components', 'frontend', 8, 'todo'),
  ('task-028-f03', 'story-028-frontend', 'Add Analytics to navigation', 'frontend', 1, 'todo'),
  ('task-028-f04', 'story-028-frontend', 'Connect to analytics API', 'frontend', 4, 'todo');

Priority Assignment

Integration with prd-analyzer

Reading PRD Context

import sqlite3
import json

def load_prd_context(project_path: str):
    """Load features from prd-analyzer output"""
    
    # Load features.json
    with open(f"{project_path}/.claude/features.json") as f:
        features = json.load(f)
    
    # Load from tasks.db
    conn = sqlite3.connect(f"{project_path}/.claude/tasks.db")
    conn.row_factory = sqlite3.Row
    
    epics = conn.execute("""
        SELECT e.*, 
               COUNT(s.id) as story_count,
               SUM(CASE WHEN s.status = 'done' THEN 1 ELSE 0 END) as done_count
        FROM epics e
        LEFT JOIN stories s ON s.epic_id = e.id
        GROUP BY e.id
    """).fetchall()
    
    return {
        "features": features,
        "epics": [dict(e) for e in epics]
    }

Updating Task Status

When audit finds discrepancies:

-- Mark feature as needing frontend work
UPDATE epics 
SET status = 'needs_frontend', 
    updated_at = datetime('now')
WHERE id = 'epic-028';

-- Add audit metadata
INSERT INTO epic_metadata (epic_id, key, value)
VALUES ('epic-028', 'audit_level', '1'),
       ('epic-028', 'audit_date', '2026-01-12'),
       ('epic-028', 'audit_gaps', 'route,navigation,documentation');

Running an Audit

Full Audit Command

# In Claude Code session:

# 1. Read project structure
cat package.json
ls -la src/ app/ pages/ 2>/dev/null

# 2. Load PRD context
cat .claude/features.json
sqlite3 .claude/tasks.db "SELECT id, title, priority FROM epics ORDER BY id"

# 3. For each feature, scan for evidence
# (Claude does this systematically)

# 4. Generate report
# Outputs to .claude/audit-report.md and .claude/audit-results.json

Quick Audit (Single Feature)

# Audit just F028
# 1. Find backend
find . -name "*analytics*" -type f

# 2. Find frontend  
find . -path "*app*" -o -path "*pages*" | xargs grep -l "analytics" 2>/dev/null

# 3. Check navigation
grep -r "analytics" --include="*.tsx" src/components/nav/ app/layout.tsx

# 4. Report finding
echo "F028: Level 1 - Backend only, no frontend route"

Anti-Patterns

Audit Anti-Patterns

Remediation Anti-Patterns

Checklist: Running Product Audit

Before Audit

• [ ] prd-analyzer has run (tasks.db exists)
• [ ] Project structure understood
• [ ] Framework identified
• [ ] Backend location known
• [ ] Frontend location known

During Audit

• [ ] Each feature checked systematically
• [ ] Backend evidence recorded
• [ ] Frontend evidence recorded
• [ ] Route existence verified
• [ ] Navigation links verified
• [ ] Level assigned (0-5)

After Audit

• [ ] Report generated (markdown)
• [ ] Results saved (JSON)
• [ ] Remediation tasks created
• [ ] tasks.db updated
• [ ] Priorities assigned

References:

• references/framework-patterns.md — Scanning patterns for each framework
• references/completeness-criteria.md — Detailed level definitions
• references/gap-analysis.md — Analysis methodology
• references/remediation-templates.md — Task templates for common gaps