Next Move Theory is a methodology with a step-by-step algorithm for every product decision: it lays out every tactical and strategic move open to you and helps you choose the best, with the odds on your side.

This repository holds the open canon (the methodology, written as theses) and a set of Claude Code skills that run it. It's written for the people who decide what to build: founders, indie hackers, product managers, and product marketers. The methodology and the skills are by Ivan Zamesin (X · LinkedIn).

How to install

Into your project root (sets up Claude Code + Codex). Clone and run the installer:

git clone https://github.com/zamesin/Next-Move-Theory-Canon-and-Skills.git
bash Next-Move-Theory-Canon-and-Skills/install.sh --target .

Or do it in one command from the site:

curl -fsSL https://nextmovetheory.com/install.sh | bash

Full details ▸

There is an algorithm

There is an algorithm for making any product decision.

Next Move Theory is the algorithm behind every product call: how to find product-market fit, scale, position, grow conversion, improve retention. It works at every level, from this sprint's tactics to the company's strategy. There is one for each of the questions that decide a product's fate:

• How to launch a product and find Product-Market Fit
• How to scale a product
• How to save a dying product, or know when it's time to shut it down
• How to create value
• How to differentiate from competitors
• How to position a product
• How to exit direct competition
• How to create a Disruptive Innovation
• How to grow conversion
• How to raise average order value
• How to improve retention
• How to build an acquisition channel

It lays out every move open to you. Most decisions feel like a coin flip because you only see the one option you'd already fixed on. Next Move Theory lays out every tactical and strategic move actually open to you, including the ones you'd have missed.

It helps you choose the best. Scores give you comfort, not direction — you can rank a feature 1,200 and still be wrong. Next Move Theory weighs each move by how much it shifts your goal and points you to the best, with the reason why.

More of your bets land. That's the whole point. Hundreds of companies run on Next Move Theory, and across dozens of documented cases the metrics moved significantly — conversion, retention, revenue, market share.

This canon is the result of the last eight years of my work. Eight years ago I found Jobs To Be Done, saw how much it could become, and made an unreasonable decision: rebuild it from scratch so it would finally yield an algorithm. It only became that when I got lucky and found the science that explains what value really is and how a person changes behavior. That body of science sits in scientific-foundations.md, and everything else stands on it. On that foundation I rebuilt JTBD into thousands of theses, the core I call Advanced Jobs To Be Done. AJTBD alone still didn't produce the algorithm. To get there I folded in Unit Economics, the Riskiest Assumption Test, ABCDX segmentation, and Goldratt's Theory of Constraints. That integration became Next Move Theory. I've since taught it to more than 13,000 people in my home country, and this public canon is how I give its foundations to the world.

The main algorithm is here in full. Read it in the-algorithm.md. Reading the steps isn't enough, though. For the algorithm to work for you, you have to understand the foundations it runs on: what a Job is, what value is, how to segment, how to test the riskiest assumption first. That is what the rest of this canon is. These are the foundational theses the algorithm stands on, so it works for you instead of reading like an empty checklist.

The skills turn that algorithm into tools: feed in a product idea and get back a decision, not a description.

I find this methodology beautiful and powerful, and sharing it with the world is my mission. I hope it brings you real value and lets you see the moves in front of you clearly.

Who this is for

This canon is written for product builders. Same algorithm, and here's the win it lands for each:

• Founders — decide what to build, with the odds on your side. See every tactical and strategic move open to you, find the Job customers will actually pay for, and pick the strategy that wins before you bet the next three months on a hunch.
• Indie hackers / vibe-coders — pick a niche that actually pays. Writing code was never the problem; choosing what to ship is. Let the methodology pick the Job people pay for, so the next build is the first one with real buyers.
• Product managers — a roadmap that moves the metric, not theater. Run the logic from the foundations up, find where the metric actually breaks, ship the few moves most likely to shift it, and raise the odds of growth.
• Senior PMs / VPs / CPOs — the operating system your product org runs on. When every team reasons from the same strong foundations, tactic to strategy, you can stand behind every call and more of your bets pay off.
• Product marketers / growth — positioning that isn't "yet another X." Find the angle in the customer's real Job, not channel tactics, and the odds it converts climb before you spend a dollar.

If you build, market, or decide the direction of a product, this is for you. You don't have to throw out what you already know. Customer interviews, CJM, ICP, willingness-to-pay, and feature backlogs all still work. They just get grounded in the right unit of analysis and tied to real business decisions instead of floating free. Expect the rewire to take practice. Most people arrive with a feature-first or persona-first model, and the Job-first model takes a few honest attempts before it feels natural.

What's here — and what's coming

This public canon is the foundation, about 25% of the whole methodology. What you have here are the foundational theses of Advanced Jobs To Be Done and Next Move Theory: what a Job is, what value is, how segmentation works, behavior change, the Job Graph, and the Riskiest Assumption Test. It also includes the main algorithm itself (the-algorithm.md).

The rest of the methodology is not coming to this public repo. It lives in the full version, available through the products and courses at nextmovetheory.com. Beyond the foundations here, the full methodology covers:

• the product-diagnosis algorithm;
• the step-by-step algorithms for the questions listed at the top — launch and find Product-Market Fit, scale, save a dying product, position, exit competition, grow conversion, raise average order value, improve retention, build an acquisition channel, and the rest;
• the full 100+ mechanics catalog;
• generating product ideas and feature ideas;
• goal-setting — the algorithm for finding a company's real growth points;
• demand creation and acquisition channels — how the methodology runs at the delivery stage;
• branding — how to build and run a brand on Jobs;
• process principles and the algorithms for rolling the methodology out across a company;
• Customer Success and Support built on Jobs;
• the full unit-economics integration, and more.

Subscribe to the newsletter at nextmovetheory.com so you don't miss new free materials, courses, and products as they go live.

The skills

The Skills/ directory holds Claude Code skills that run the methodology for you. Each one reads the canon at runtime, so its output is grounded in this methodology, not the generic JTBD an LLM would otherwise reach for.

Two front doors. /ask-nmt is the conversational front door for advice, explanation, or pressure-testing an idea. /diagnose is the front door for a live product: it finds your risks and growth points and routes you to the next move. Both answer from the canon and point you to the right producer skill when you need a full artifact. For a brand-new idea, start at /market-research.

The four producer skills form a pipeline, each one building on the artifact the one before it produced:

1. /market-research → pick the segment and the Core Jobs to compete for (with the GO / NARROW / PIVOT verdict and the riskiest assumptions to test).
2. /craft-value-proposition → feed it the market-research result; get the value proposition plus a PRD-ready implementation spec.
3. From the value proposition, branch to either (or both):
   • /product-requirements → the build-ready PRD, what to build. It consumes the segment from step 1 and the value from step 2.
   • /craft-go-to-market → the landing page, ads, and growth plan, how to sell it. Works best from the value proposition; also accepts the PRD or the market-research result.

You can also jump in mid-pipeline if you already know your segment and Jobs. Each skill takes what you hand it, or routes you back to the step it needs first.

All six are user-invocable in Claude Code (/ask-nmt, /diagnose, /market-research, /craft-value-proposition, /product-requirements, /craft-go-to-market). The four producers each have a fast Quick mode (no internet) and a deeper Deep mode (subagents + web research). /ask-nmt and /diagnose are conversational (no file unless you ask).

The skills produce hypotheses, not conclusions. Every number is an LLM-generated estimate with a verification path attached. Validate before any decision with expensive consequences. That's the RAT discipline the methodology is built on.

Install into your project

Install the canon + skills into the root of your existing project (the folder you run your agent from) with one command:

curl -fsSL https://nextmovetheory.com/install.sh | bash

That's the whole install: clone + setup in one step, so there's nothing to "run next." It clones the repo to a temp dir and lays everything into your project root. After install that root looks like:

your-project/
├── .claude/skills/<skill>/        # skills for Claude Code
├── .codex/skills/<skill>/         # skills for Codex
├── Next-Move-Theory-Canon/        # the canon — keep this exact name (skills read it by this path)
├── AGENTS.md                      # your existing file — rules injected between markers
├── CLAUDE.md                      # your existing file — rules injected between markers
└── NextMoveTheory-README.md       # this README, renamed, for reference

Already ran git clone and got a nested Next-Move-Theory-Canon-and-Skills/ folder? That's just the raw repo, not an install. Fix it in one step. From inside that folder run:

bash install.sh            # installs into the PARENT dir (your project root)
# or: bash install.sh --target /path/to/your/project

Then invoke a skill:

/diagnose            # what should I do next with my product?
/market-research a tool that drafts SOC 2 evidence for early-stage SaaS

Updating later: re-run the install command. It's idempotent: the canon and skills are replaced, the rules between <!-- Next-Move-Theory-Rules:start --> … <!-- Next-Move-Theory-Rules:end --> are refreshed in place, and your own text outside the markers is untouched.

Note for AI agents: if a user asks you to "install this repo," do not stop at git clone. That leaves the skills in a nested Skills/ folder where no agent will find them. Run the one-command installer (or bash install.sh from the clone). The skills must end up in .claude/skills/ and .codex/skills/ at the project root, never in a top-level Skills/ folder.

SRC=$(mktemp -d) && git clone --depth 1 https://github.com/zamesin/Next-Move-Theory-Canon-and-Skills.git "$SRC"
rm -rf ./Next-Move-Theory-Canon && cp -r "$SRC/Next-Move-Theory-Canon" ./Next-Move-Theory-Canon
mkdir -p .claude/skills .codex/skills
cp -r "$SRC"/Skills/. .claude/skills/
cp -r "$SRC"/Skills/. .codex/skills/
cp "$SRC/README.md" ./NextMoveTheory-README.md
# then inject the rules block from "$SRC/CLAUDE.md" and "$SRC/AGENTS.md" between the markers
rm -rf "$SRC"

Make your AI agent methodology-aware

This repo also ships CLAUDE.md and AGENTS.md, a compact rules file that teaches a coding agent (Claude Code, Codex, Cursor, and others) to do product work with this methodology instead of the generic, often-wrong Jobs To Be Done in its training data.

• What it is — the non-negotiable theses (what a Job is, what value is, how to segment) plus a routing table that tells the agent which canon file to read for a given task, so it avoids the common JTBD mistakes.
• How to use it — the install above injects it for you: step 4 writes these rules into your project's CLAUDE.md (Claude Code) and AGENTS.md (Codex and most other agents), between <!-- Next-Move-Theory-Rules:start --> … <!-- Next-Move-Theory-Rules:end --> markers, so updates refresh cleanly and your own rules outside the markers stay intact. The canon it routes to sits at ./Next-Move-Theory-Canon.
• Why — out of the box an agent pattern-matches to generic JTBD and gets the theses wrong. This file points it at the correct definitions and the canon, so its product reasoning is grounded in the methodology.

How to read the canon

Prefer a nicer reading experience? The same canon is available in a cleaner, more readable form on the site — read it at nextmovetheory.com/library/canon.

The canon lives in Next-Move-Theory-Canon/, around two dozen interlinked files. You don't have to read them in order. If you want the fastest path to understanding, read these four key-theses files first, in order:

1. Next-Move-Theory/nmt-key-theses.md — the integrative root: what the whole framework is and how its pillars (AJTBD, Unit Economics, RAT, ABCDX) plus Theory of Constraints — with OKR (Objectives & Key Results) as a supporting methodology — fit into one system. Start here for the big picture.
2. Advanced-Jobs-To-Be-Done/ajtbd-key-theses.md — the substrate the rest stands on: Jobs, the Job Graph, value and the Aha Moment, segmentation. The core you'll use most.
3. Riskiest-Assumption-Test/rat-key-theses.md — before you build: list the assumptions the idea rests on, rank them by how lethal they are if wrong, and buy the cheapest evidence against the deadliest first.
4. ABCDX-Segmentation/abcdx-segmentation-key-theses.md — the theory turned into a concrete operating move on a real customer base: focus the high-margin A/B, fire C/D, and read X as the signal of where to grow next.

Then read the rest in whichever cluster matches your problem.

Advanced Jobs To Be Done — Foundations

The Job Graph — where strategy lives

Creating value

Reaching and converting customers

Choosing where to compete

Next Move Theory — the meta-framework above AJTBD

Practice, B2B, and the operating loop

The public canon covers the most foundational theses and mechanics. The full methodology — the product-diagnosis algorithm, the 100+-mechanic catalog, the full unit-economics integration, and more — lives in the products and courses at nextmovetheory.com. For new theses and book chapters as they're published, subscribe at nextmovetheory.com — home to the canon, the books, and the newsletter.

What's inside

Next-Move-Theory-Canon-and-Skills/
├── Next-Move-Theory-Canon/             # the methodology, written as theses
│   ├── Advanced-Jobs-To-Be-Done/       #   the Jobs framework — start with ajtbd-key-theses.md
│   ├── ABCDX-Segmentation/             #   segmenting a paying base by margin × satisfaction
│   ├── Riskiest-Assumption-Test/       #   validating ideas before you build them
│   ├── Next-Move-Theory/               #   the integrative meta-framework above AJTBD
│   ├── HowTos/                         #   practical guides — start with the interview guide
│   └── Algorithms/                     #   how the pieces combine into one loop
└── Skills/                             # Claude Code skills that run the methodology
    ├── market-research/
    ├── craft-value-proposition/
    └── product-requirements/

How this methodology came to be

By 2018 I taught product for a living: customer research, segmentation, interviews. Yet at the root I didn't actually know how products get created. The model I taught was find the pain, build the painkiller. But I kept watching satisfied customers with no problem to solve buy anyway, and I had no explanation for it. I was also building my own company against a stronger competitor, with no rule for choosing a strategy, only a pile of plausible advice. So I made an unreasonable decision: build the methodology from scratch.

I went deep into Jobs To Be Done and kept its deepest intuition: a person sits in a situation and wants to transition into a different state. I left the rest of the machinery behind, because it never told me how to research, segment, choose where to compete, or create value.

It only came together when I got lucky and found the right science. Lisa Feldman Barrett's work led me to allostasis, prediction, and reward prediction error, which is what value actually is to a brain managing an energy budget. It also led me to the theories of needs, emotions, habit, identity, and loss aversion that explain how a person changes behavior. That body of science sits in scientific-foundations.md, and everything else stands on it. On top of it I could finally build a real algorithm for creating value, the core I called Advanced Jobs To Be Done (AJTBD).

AJTBD alone still wasn't enough. A few more methodologies turned out to be fundamental. First the Riskiest Assumption Test. Every initiative is a stack of risky assumptions, any of which might not hold, so you don't just launch and hope. In a sense the idea is already dead and you simply don't yet know what will kill it. RAT is how you find out cheaply, before you've paid for the build. Then Unit Economics. A company can only grow and fund its next bets by competing for the Jobs of segments where it can actually earn a target margin. Goldratt's Theory of Constraints taught me to find the single bottleneck that limits the system and fix that, instead of improving everything at once. Later I added goal-setting, an algorithm for finding a company's real growth points. Together it all became Next Move Theory.

Today hundreds of companies in my home country run on this work, with dozens of cases documented at nextmovetheory.com/cases. My goal now is to give the methodology to the world, so your product work stops being guesswork and becomes something you genuinely enjoy. The full story, with the scenes, the mistakes, and the moments where the wrong model stopped working, is the subject of my book.

The book — The Nature of Product

The Nature of Product is free to read on the site. It's the first book in a series, and it covers the foundation, Advanced Jobs To Be Done (AJTBD), rather than the whole of Next Move Theory. The broader framework comes in later books. Where the canon states the methodology as theses, the book tells the story of how it was discovered. It's a chain of insights, each one a moment where the wrong model stopped working and a better one had to be built. A recurring skeptic, Wes, attacks the ideas with the exact questions real students used.

It's for founders, indie hackers, PMs, marketers, and designers making product decisions on incomplete evidence, and it assumes no prior Jobs To Be Done background. Read it on the couch. The canon and skills are here when you want to get operational.

About the author

Ivan Zamesin is the author of Advanced Jobs To Be Done and Next Move Theory. Two independent industry studies ranked him the #1 product expert in his home market.

• Led image search at his home market's largest tech company. Took 25% of the market from Google Images, growing share from 55% to 72%.
• Trained 13,000+ founders and product managers through the most popular product course in his home market, running since 2017.
• Founded and sold a startup. A therapist-matching service: built it, grew it, and exited to a larger marketplace.
• Product-strategy consulting for market leaders, built on Jobs and unit economics.

nextmovetheory.com · X · LinkedIn · ivan@nextmovetheory.com

Talks & questions

Want me to speak? If you'd like me to walk your team, company, or event through the methodology — a talk, a workshop, or a conversation about how it applies to your product — I'd genuinely welcome that. Email me at ivan@nextmovetheory.com or reach out on LinkedIn.

Found an error in a thesis or a broken link? Open an issue or a pull request.

License

The canon and the skills are licensed under CC BY-NC-SA 4.0 (Creative Commons Attribution–NonCommercial–ShareAlike 4.0 International) — see LICENSE. You are free to share and adapt the material, as long as you:

• Attribution — credit Ivan Zamesin and link back to this repository and the license;
• NonCommercial — don't use the material for commercial purposes;
• ShareAlike — license your adaptations under the same terms.

A note on the writing. English isn't my native language, and I didn't create this methodology in English. I built it over eight years in my own language, and it grew into thousands of theses. Rewriting all of that into English by hand wasn't realistic for me, so I used Claude to turn my theses into the text you're reading. Every thesis is mine, worked out over years of practice and teaching, and I'm confident in all of them. What the AI did was the English wording, not the thinking behind it.

Built by Ivan Zamesin. nextmovetheory.com · X · LinkedIn · ivan@nextmovetheory.com. The canon is a living document; it grows as new theses are validated in practice.