A Product Intelligence Engine — an interface-independent capability layer for structured product discovery, deterministic scoring, gated artifact generation, adaptive questioning, and automated market research. Delivered as an MCP server but reusable via CLI or as a Python library.
Zero LLM calls. Claude Desktop (or any MCP client) supplies reasoning; ProdForge supplies product management capabilities.
The Capability Layer (prodforge/capabilities/) orchestrates reusable product workflows by composing existing deterministic tools. Each capability is a self-registered Capability subclass with no LLM calls — it inspects structured context and returns guidance to the calling LLM.
Capability graph:
Discovery → Research → Strategy → Execution → Review
| Capability | What it composes |
|---|---|
| Discovery | next_questions, update_context, detect_issues, WorkflowGraph |
| Research | research_competitors, research_market, research_pricing, research_reviews, research_features, summarize_research |
| Strategy | RICE, MoSCoW, Kano, Opportunity, Impact/Effort, success_metrics, persona_builder |
| Execution | check_readiness, generate_artifact, export_artifact, generate_framework |
| Review | detect_issues (contradictions, gaps, unvalidated assumptions) |
The CapabilityPlanner determines which capability should run next based on workflow state. Dependency tracking invalidates downstream capabilities when upstream context changes — re-running discovery automatically resets research/strategy/execution/review to pending.
Low-level tools remain available — capabilities are the preferred MCP interface, but run_tool, update_context, generate_artifact, etc. still work directly for advanced users.
ProdForge now includes a complete Guided Product Discovery experience. Instead of returning raw questions, each capability returns:
- Progress — what stage you're in and what's complete
- Summary — what's known, what's unknown, and what's been learned
- Confidence — per-section confidence scores (0-100%) based on deterministic heuristics
- Evidence quality — flags weak or missing evidence (business impact stated but unsupported, unvalidated personas, etc.)
- Recommendations — context-aware next steps informed by the current state
- Collaboration — cross-capability insights (research findings inform strategy, personas inform execution)
- Conversation hint — why the next question matters, adapted to what's already known
In Claude Desktop, use the guided_discovery prompt:
"I want to improve checkout abandonment."
Claude will use run_discovery() which returns everything needed for a natural conversation:
{
"status": "active",
"current_stage": "discovery",
"confidence": {"problem": 0, "business": 0, ...},
"summary": {"problem": {"statement": null}, "unknowns": [...]},
"next_question": {"field": "problem.statement", "why": "A crisp, solution-free problem statement anchors every later decision."},
"recommendations": [{"priority": "high", "action": "Define the problem statement"}]
}discovery_summary() continuously maintains a structured view of what's known:
Problem: Cart abandonment at payment step is 40%
Users: 2 segment(s), 1 persona(s)
Business: $2M annual revenue loss
Unknowns: No competitive research conducted, No prioritization decision made
Overall Confidence: 27%
Every major section has a deterministic confidence score:
Problem Definition: 65% ██████░░░░
Business Context: 60% ██████░░░░
Personas & Users: 35% ███░░░░░░░
Research: 0% ░░░░░░░░░░
Strategy: 0% ░░░░░░░░░░
Execution Readiness: 0% ░░░░░░░░░░
Overall: 27% ██░░░░░░░░
Confidence increases as evidence accumulates. Problem Definition starts at 0% and rises to 80%+ when all fields are filled, pain points have severity ratings, and evidence is collected.
evidence_quality() flags weak or missing evidence:
- Business impact stated but no supporting evidence
- Opportunity size unsupported by market data
- Personas not validated with real users
- Pain points lacking severity context
- Assumptions not tested
- KPIs without targets
record_decision() builds a persistent log of every major decision:
{
"decision": "Build one-click checkout first",
"reason": "Highest RICE score (80), fastest time to market",
"evidence": "Scored 4 features with RICE; one-click was 2x the next highest",
"alternatives": ["Guest checkout", "Saved payment methods"],
"capability": "strategy",
"timestamp": "2025-07-14T10:30:00"
}decision_quality() scores how well decisions are documented: 100% = every decision has evidence and alternatives.
product_health() aggregates everything into a quality scorecard:
- Discovery completeness — how much of the problem space is covered
- Evidence quality — are claims supported by data?
- Research completeness — competitive landscape coverage
- Decision quality — are decisions well-documented?
- Risk level — how many high-likelihood risks exist?
- Execution readiness — is the project ready for execution?
- Overall confidence — aggregate across all dimensions
- Missing work — specific items that still need attention
readiness_dashboard() renders an ASCII progress report:
Problem Definition ██████░░░░ (fair)
Business Context ██████░░░░ (fair)
Personas & Users ███░░░░░░░ (poor)
Research ░░░░░░░░░░ (poor)
Strategy ░░░░░░░░░░ (poor)
Execution Readiness ░░░░░░░░░░ (poor)
Overall ██░░░░░░░░ (poor)
Blocked by: competitor research, success metrics, user validation
get_recommendations() returns context-aware suggestions at every stage, including:
- Which capability to run next
- Missing context that needs collection
- Useful frameworks and calculators
- Research opportunities inspired by gaps
- Cross-capability collaboration hints
Capabilities now automatically enrich one another:
- Research → Strategy: Pricing complaints found in research flag pricing as a strategic lever. High-confidence opportunities are surfaced during prioritization.
- Personas → Execution: When personas are defined without user stories, execution recommends generating stories from personas.
- Discovery → Research: Unvalidated assumptions during discovery trigger research recommendations to validate them.
- Strategy → Execution: Prioritization decisions are automatically logged and available for execution planning.
Use the guided_discovery prompt to walk through a complete product discovery:
- Idea → create_project
- Discovery → run_discovery() guides the conversation naturally
- Research → run_research() with research_* tools
- Strategy → run_strategy() with scoring calculators
- Execution → run_execution() with readiness gates
- Review → run_review() with product_health() report
The entire workflow is driven by run_discovery() — Claude only needs to start with that single call.
Claude Desktop / Cursor / any MCP client
│
│ MCP Protocol
▼
┌──────────────────────────────┐
│ MCP Adapter │ <── thin, no business logic
│ (interfaces/mcp/server.py) │
└──────────────┬───────────────┘
│
┌──────────────▼───────────────┐
│ Capability Layer │ <── orchestration layer
│ (capabilities/*) │ run_discovery / run_research /
│ │ run_strategy / run_execution / run_review
└──────────────┬───────────────┘
│
┌──────────────▼───────────────┐
│ ProductEngine │ <── unified API, MCP-free
│ (engine/orchestrator.py) │
└──┬────┬────┬────┬────┬───────┘
│ │ │ │ │
▼ ▼ ▼ ▼ ▼
┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌──────────┐
│Work│ │State│ │Tool│ │F'mk│ │ Research │
│flow│ │ │ │Reg │ │Reg │ │ Service │
│Graph│ │Mgr │ │istr │ │istr│ │+ Provid. │
└──┬──┘ └──┬──┘ └──┬──┘ └──┬──┘ └────┬───┘
│ │ │ │ │
▼ ▼ ▼ ▼ ▼
┌──────────────────────────────────────────┐
│ Domain Knowledge / Tools / Storage │
│ (deterministic calculators, questions, │
│ framework builders, section generators,│
│ normalizers, JSON persistence) │
└──────────────────────────────────────────┘
The engine is fully usable without MCP:
from prodforge import ProductEngine
engine = ProductEngine()
pid = engine.create_project("Checkout", "Reduce friction")["project_id"]
engine.next_questions(pid)
engine.update_context(pid, {"problem.statement": "40% cart abandonment"})
engine.generate_artifact(pid, "prd")
engine.research_competitors(pid) # structured market intelligencecd ProdForge
pip install -e .
pip install -e ".[dev]" # includes pytest for running testsAdd to claude_desktop_config.json:
{
"mcpServers": {
"prodforge": {
"command": "python",
"args": ["-m", "prodforge.interfaces.mcp.server"],
"cwd": "<path>/<toTheMcp>/<OnYourDevice>ProdForge"
}
}
}Restart Claude Desktop, then try: "I want to improve checkout".
prodforge-cli create "Checkout" "Reduce friction"
prodforge-cli status checkout
prodforge-cli questions checkout
prodforge-cli answer checkout problem.statement "40% cart abandonment"
prodforge-cli generate checkout prd
prodforge-cli tool rice '{"items": [{"name": "X", "reach": 1000, "impact": "high", "confidence": 0.8, "effort": 2}]}'
prodforge-cli research-competitors checkout
prodforge-cli research-market checkout --market "e-commerce"
prodforge-cli research-pricing checkout AlphaCorp
prodforge-cli research-reviews checkout
prodforge-cli research-features checkout
prodforge-cli research-summary checkout
prodforge-cli discovery checkout # Progress through the capability workflow
prodforge-cli research checkout
prodforge-cli strategy checkout
prodforge-cli execution checkout
prodforge-cli review checkout
prodforge-cli next-capability checkout # Ask the planner what to run next
prodforge-cli capability-status checkout# Show all capability states
prodforge-cli discovery-summary checkout # Structured discovery summary
prodforge-cli confidence checkout # Per-section confidence scores
prodforge-cli evidence checkout # Weak evidence flags
prodforge-cli record-decision checkout "Build MVP" "Fastest path"
prodforge-cli decision-log checkout # View decision log
prodforge-cli decision-quality checkout # Score decision documentation
prodforge-cli product-health checkout # Complete health scorecard
prodforge-cli dashboard checkout # Visual readiness dashboard
prodforge-cli recommendations checkout # Context-aware next steps
prodforge-cli capabilitiesProjects persist in ~/.prodforge/ (override with PRODFORGE_HOME).
Context & discovery — create_project, list_projects, get_status, get_context, update_context, next_questions, detect_issues, check_readiness
Workflow transitions — advance_stage, revisit_stage, rollback_stage
Deterministic tools — rice, kano, opportunity, impact_effort, moscow, persona_builder, success_metrics (run via run_tool or individual wrappers)
Research — research_competitors, research_market, research_pricing, research_reviews, research_features, summarize_research
Generation (gated) — generate_framework (lean_canvas, business_model_canvas, swot, okrs, opportunity_solution_tree, impact_mapping, heart, aarrr), generate_artifact (prd, user_stories, roadmap, launch_checklist), export_artifact
Capability orchestration — run_discovery, run_research, run_strategy, run_execution, run_review, next_capability, capability_status
UX: Discovery summary & confidence — discovery_summary, confidence_report, section_confidence, evidence_quality
UX: Decision log — record_decision, decision_log, decision_quality
UX: Health & readiness — product_health, readiness_dashboard
UX: Recommendations — get_recommendations
Prompts — start_discovery(idea), guided_discovery (full demo workflow)
create_project→ creates the project with the user's idea.run_discovery()→ returns progress, confidence, summary, and what to ask next. This is the primary conversation driver.- Periodically call
discovery_summary()to show the user what's known, what's unknown, and overall confidence. - Call
readiness_dashboard()to visualize progress with ASCII bars. - Record major decisions with
record_decision(). - At the Research stage,
run_research()checks for data and returns collaboration hints. Useresearch_competitors,research_market, etc. to gather intelligence. run_strategy()guides prioritization. Use RICE, MoSCoW, Kano, etc. for scoring. Decisions are auto-logged.check_readiness("prd")— if fields are missing, generation is blocked and discovery continues.generate_artifact("prd")assembles from structured context; PRD sections are cached — only changed sections regenerate.export_artifactsaves the approved version to disk.run_review()returns a completeproduct_health()report andreadiness_dashboard().detect_issues()now also surfaces weak evidence — business impact without support, unvalidated personas, etc.
Create a class extending ResearchProvider with the five abstract methods (search, competitors, pricing, reviews, features). Register it with @ProviderRegistry.register("name") or inject it directly into ResearchService.
Create a module in prodforge/tools/ with a @ToolRegistry.register("name") decorated function. Import it in tools/__init__.py. No other changes needed.
Create a builder in prodforge/frameworks/builders/ as a @FrameworkRegistry.register class extending Framework. Import it in frameworks/builders/__init__.py.
Create a module in prodforge/artifacts/ exposing readiness(ctx) and generate(ctx, cache). Add the mapping to ARTIFACTS in artifacts/__init__.py.
Create a class in artifacts/section_generators/ extending Section, declaring inputs (context paths that trigger regeneration when changed). Add it to PRD_SECTIONS in section_generators/__init__.py.
Add an entry to the appropriate module in prodforge/domain/ (field, question, why, depends_on, optional). The question is automatically picked up by the adaptive engine.
prodforge/
├── capabilities/ # Orchestration layer (5 capabilities)
│ ├── base.py # Capability ABC
│ ├── registry.py # CapabilityRegistry (self-registering)
│ ├── planner.py # CapabilityPlanner + dependency tracking
│ ├── discovery/ # run_discovery capability
│ ├── research/ # run_research capability
│ ├── strategy/ # run_strategy capability
│ ├── execution/ # run_execution capability
│ └── review/ # run_review capability
├── engine/ # Core engine (MCP-free)
│ ├── orchestrator.py # ProductEngine — unified API
│ ├── workflow.py # WorkflowGraph + Stage (10 stages)
│ ├── state.py # ProjectState
│ └── registry.py # ToolRegistry
├── research/ # Research capability layer
│ ├── models.py # Competitor, Complaint, FeatureMatrix, etc.
│ ├── registry.py # ProviderRegistry
│ ├── service.py # ResearchService — orchestration + heuristics
│ ├── providers/ # ResearchProvider ABC + MockProvider
│ └── normalizers/ # Competitor, Complaint, FeatureMatrix normalizers
├── storage/ # Persistence
│ ├── models.py # Context schema (includes research section)
│ └── store.py # JSON file store
├── domain/ # Adaptive questions + UX modules
│ ├── confidence.py # Confidence engine (per-section heuristics)
│ ├── discovery_summary.py # Discovery summary generator
│ ├── evidence.py # Evidence quality flags
│ ├── decision_log.py # Decision log management
│ ├── product_health.py # Product health scorecard
│ ├── readiness_dashboard.py # Readiness + ASCII bars
│ ├── recommendations.py # Smart recommendations
│ └── ... (questions) # 8 question modules
├── tools/ # Deterministic calculators (7 modules)
├── frameworks/ # Framework generators
│ ├── framework_base.py # Framework ABC
│ ├── registry.py # FrameworkRegistry
│ └── builders/ # 8 builders
├── artifacts/ # Artifact generators
│ ├── prd.py .. launch_checklist.py (4 artifacts)
│ └── section_generators/ # 11 PRD sections with input-hash caching
├── interfaces/ # Thin adapters
│ ├── mcp/server.py # MCP adapter (37 tools + 2 prompts)
│ ├── cli/main.py # CLI adapter (27 commands)
│ └── future/ # Reserved (REST, desktop, …)
└── render.py # Shared markdown helpers