Skip to content

Getting Started with MOMENTUM

This guide shows how to start using MOMENTUM to manage product strategy, discovery, and delivery using a repository-first, AI-assisted workflow.

MOMENTUM assumes:

  • The human PM owns intent and decisions
  • AI assists with drafting, structuring, and consistency work
  • Strategy lives in version control as a single source of truth

Before You Begin

Read first (5 minutes):

If MOMENTUM fits your situation, continue below.

Prerequisites

To effectively use MOMENTUM, you will need the following:

  • Git Repository Host: An account with a Git hosting service like GitHub, GitLab, or Bitbucket. MOMENTUM relies heavily on Git for versioning and collaboration.
  • Integrated Development Environment (IDE): An IDE with strong Markdown support and integrated AI capabilities, such as Visual Studio Code (VS Code) or Cursor.
  • Coding Agent / LLM Assistant: An LLM-powered coding agent integrated into your IDE. Popular choices include:
    • Codex (OpenAI - e.g., via GitHub Copilot)
    • Claude Code (Anthropic - part of Claude AI)
    • GitHub Copilot Chat (GitHub)
    • Gemini CLI (Google - part of Google Gemini API)
    • Note: Free versions of these agents are sufficient for getting started, but extensive strategy work might be impacted by rate limits.

Understanding Repository Setup Options

MOMENTUM can be integrated into your product repository using different Git mechanisms, each with its own trade-offs, particularly concerning initial setup and ongoing updates from the MOMENTUM framework.

How they work: These Git features embed one repository (pm-framework) as a subdirectory within another (your product repository). They maintain a link to the framework's history, allowing you to pull updates from the upstream MOMENTUM repository.

  • Submodules: Store the exact commit of the embedded repository. Great for ensuring a stable framework version.
  • Subtrees: Merge the framework's history into your repository. Can be simpler for some workflows, but might obscure framework updates if not managed carefully.

Benefits: - Direct Update Mechanism: You can easily pull updates from the upstream MOMENTUM framework directly into your project. The update-framework.sh script is designed for this. - Version Control: You maintain precise control over which version of the framework you are using. - Contribution-Friendly: Ideal for maintaining the core _deps/pm-framework part of the repository, enabling both you and contributors to easily work on and update the framework itself.

Considerations: - Adds a layer of Git complexity. - Requires specific Git commands for updates and managing changes.

How they work: A template repository serves as a blueprint. When you create a new repository "from template," Git effectively copies all files from the template repo into your new, independent repository. There is no ongoing Git link between the new repository and the template.

Benefits: - Simplest Start: Extremely easy for new users to get started with a pre-configured MOMENTUM project. - Clean Slate: The new repository is entirely independent, with its own fresh Git history.

Considerations: - No Direct Update Mechanism: Once created, your new project has no built-in way to pull updates directly from the original MOMENTUM template repository. You would need to manually merge changes or re-apply updates. - Ideal for Projects, Not Framework Integration: Template repositories are excellent for starting a new project that uses MOMENTUM, but less suitable for integrating the MOMENTUM framework itself if you want to receive continuous updates to scripts, templates, or documentation.

Which Option to Choose?

  • For integrating the MOMENTUM framework into your existing repository (e.g., this PM-docs repository where you are developing the framework): Git Submodules or Subtrees are recommended due to their built-in update mechanisms. This allows you (and contributors) to easily pull updates from the core pm-framework repository.
  • For starting a brand new product repository that will use MOMENTUM: A Template Repository offers the simplest setup. Be aware that framework updates would need to be applied manually or by re-scaffolding specific parts.

The examples below focus on using Git Subtree/Submodule for integrating the framework.

Setup: Initialize Your Repository

MOMENTUM is added to your product repository as a dependency.
This keeps the framework versioned and separate from your product content.

git subtree add --prefix _deps/pm-framework \
  https://github.com/wolfgangheinz/PM-framework.git \
  main --squash

Option 2: Git Submodule

git submodule add \
  https://github.com/wolfgangheinz/PM-framework.git \
  _deps/pm-framework

git submodule update --init --recursive

Initialize Base Files

Run the scaffold script once:

_deps/pm-framework/scripts/init-base.sh

This creates:

  • product-strategy.md – your strategy (SSOT)
  • product-evidence.md – why the strategy exists
  • /delivery/ – epics and stories
  • /discovery/ – raw inputs and learning

No manual file creation required.

How You Work with AI in MOMENTUM

MOMENTUM is agent-agnostic.
You can use any IDE-native assistant that can read local files.

What matters is how you attach files or prompts as context.

Attaching Prompt Files (UX Pattern)

Different tools use different syntaxes to reference local files.
The semantics are the same – explicitly tell the agent which file to read.

  • Codex / Codex CLI – prefix with @
    Example: @prompts/strategy-outline/create-or-overhaul-product-strategy.md

  • GitHub Copilot Chat – prefix with #
    Example: #prompts/strategy-outline/create-or-overhaul-product-strategy.md

  • Claude Code – use @file:
    Example: @file:prompts/strategy-outline/create-or-overhaul-product-strategy.md

  • Gemini CLI – use a context flag
    Example: --context prompts/strategy-outline/create-or-overhaul-product-strategy.md

If your tool does not support file references, open the file in the editor or paste its contents into the chat.

The Interaction Pattern

  1. Open the relevant prompt file
  2. Reference it explicitly in your instruction
  3. Let the assistant read local files
  4. Review, edit, and commit via PR

Example instructions:

  • “Help me create my strategy using create-or-overhaul-product-strategy.md.”
  • “Refine the strategy by running the product feedback loop prompt as a three-amigos discussion.”

Draft: Create Strategy and Evidence (AI-Assisted)

Draft product-strategy.md

Instead of writing from scratch, use the strategy prompts

  • prompts/strategy-outline/create-or-overhaul-product-strategy.md
  • prompts/discovery/product-feedback-loop-product-strategy-update.md

The assistant helps you draft:

  • The problem and target users
  • Goals and desired outcomes
  • Scope and non-scope
  • Constraints
  • Success metrics
  • Key assumptions

You review and decide what stays.
The result should be concise and stable by default.

Draft product-evidence.md

The product evidence is built by the framework automatically when new information is entered. You can use the prompt prompts/discovery/generic-information-intake.md, or just have conversations with your agent in the chat.

Evidence can include:

  • Research summaries
  • Experiments
  • Early user conversations
  • Internal reviews
  • Later: production behaviour

Strategy changes only when new information materially changes your understanding, regardless of where that information comes from. In many cases, both files are updated.

Examples: - “Use this meeting transcript (attach a transcript from copilot or other tools) and review it against the strategy. Suggest changes based on the decisions of the meeting and let me review them. Afterwards update the strategy and evidence. ” - Do a competitor analysis against competitor X and Y and suggest implications on our strategy and evidence.”

Shape: From Strategy to Epics and Stories

Once strategy is clear, generate execution artifacts.

Create Epics

Use:

  • prompts/epics-stories/epic-shaping-from-product-strategy.md

This converts parts of the strategy into epics under:

/delivery/epic-001-*/
  epic-001-*.md

Epics describe user-visible capabilities, not tasks.

Slice Stories

Use:

  • prompts/epics-stories/story-slicing-from-epic.md

This creates small, testable stories inside the same epic folder.

Stories are downstream artifacts.
They can be regenerated if strategy changes.

Keep Things Aligned

Periodically run:

  • prompts/epics-stories/consistency-check-strategy-epics-stories.md

This helps detect:

  • Drift
  • Contradictions
  • Missing coverage

Learn and Iterate

As new information arrives (discovery, experiments, early usage, production):

  1. Capture it in discovery or evidence
  2. Decide whether it changes strategy
  3. If strategy changes, regenerate epics and stories

AI helps with the busy work.
The PM remains accountable for decisions.

See Workflows for detailed patterns.

Resulting Repo Structure

product-strategy.md        # SSOT
product-evidence.md        # Why the strategy exists

/discovery                 # Inputs and learning
/delivery                  # Epics and stories

_deps/pm-framework         # Framework (vendored)