Pureinn - Product thinking, wired into your coding agent

Four things that make it hold up in practice.

Unified

Full lifecycle, one system

Seven phases give it the backbone - the order that makes the output hold up. Skip straight to any of the 51skills when that's all the moment needs.

Autonomous

Agent-powered execution

Add --agent, it drafts on its own. Never hallucinates, marks every gap.

Brownfield

Works on what exists

Point it at an existing codebase, it extracts the domain model and backlog.

JIT

Spec before every build

No build starts without a complete, just-in-time spec.

Built on 450+ practitioner-sourced PM observations across JTBD, KANO, Design Thinking, and Hypothesis Validation, not generated from defaults.

The command surface

One command deep, and it already knows where you are.

The product lifecycle breaks into seven stages, from a raw idea to a shipped feature. Pick the one you're in - the engine scaffolds what's missing, runs a handful of focused skills for that stage, and hands you finished, real artifacts. Nothing here assumes you've used it before.

Every run starts here/pureinn "your idea"to begin, or/pureinn resumeto pick up where you left off

Not sure which stage is yours? Find your starting point →

/pureinn discover

The real problem, and who has it

You walk out with

Problem validation, a market read, personas, and the real customer job, grounded in your data, not invented.

Inside this stage· 3 of 6 skills shown

These don't depend on each other - they're separate research tracks that converge at the end. Run them side by side: interview customers while you size the market.

/pm-personasReview

Who actually has this problem, in their own words.

/jtbd-buildingReview

The job they're really hiring your product to do.

/pm-market-analysisAuto

How big this is, and who else is already trying to solve it.

Auto drafts it on its own · Review drafts it, then waits for your sign-off · Live stays a back-and-forth conversation

Trust the inputs and don't want to walk through a skill by hand? Add --agent to any command above - it drafts the artifact in the background and hands you a summary to review, instead of running interactively.

Full phase and all its skills →

Watch it run

One command in. Real files out.

A real Pureinn session, replayed at your own pace - every question it asks, every assumption it flags, and the files that land on your disk as it goes.

Nothing exists yet - just an idea. Watch it scaffold a workspace and turn the idea into a grounded read on the problem.

Claude CodeStep 1 / 7

You run

/pureinn discover "food delivery app"

Workspace0 touched

pureinn-workspace / food-delivery-app/

◇
Empty for now.
Files appear here as the
session writes them →

artifacts / phase-2-discovery/

Real markdown on your disk - cross-linked, portable, yours.

Every option, assumption, and file is what the skill actually produces - nothing here is scripted for this page.

Who this is for

Built for people who ship.

Agencies

Every project starts from scratch, every handoff is a risk. Pureinn gives you a reusable methodology, consistent output, and a structured onboarding brief for anyone joining mid-project.

Small teams

No dedicated PM, decisions living in Slack threads. Pureinn gives the structure of a full product org without the headcount, living registers, settled decisions, a clear spec before anything gets built.

Solo builders

You know what you want to build. Pureinn collapses months of scattered work into one guided system that tells you the highest-value next move at every step.

Developers get the business judgment they used to have to guess at. PMs get artifacts precise enough for a repo, not a slide deck. Either way, the line between the two roles is the one Pureinn is built to erase.

The output is real files on your disk.

No proprietary lock-in, no black box. A finished run leaves you a workspace of portable, cross-linked markdown, ready to hand to a developer, a designer, or an investor.

A real Pureinn workspace in VS Code: product PRD, domain registers, feature cards, and phase artifacts as markdown files. — One real run: a food-delivery app. 40+ cross-linked markdown files in a single workspace.

/pm-business-rule-core · -critical · -governance

Business rules, split three ways

Not one flat list. Core, critical, and governance layers, each handled by its own skill, so contradictory rules never get quietly baked into code.

/pm-feature-design

Design just-in-time, per feature

Each feature is specced only when it's about to be built. The discipline of a real spec without the waste of designing things you may never ship.

/pm-stress-test

An adversarial stress-test engine

It role-plays a hostile investor, CFO, or CTO and grills your proposal in multiple rounds, so you survive the toughest questions before the real room.

/pm-root-cause

A root-cause diagnostic engine

When something live breaks, a metric drops or a feature flops, it drills to the real cause instead of chasing the first plausible-looking one.

[ASSUMED]

It marks its assumptions, not hallucinates

Where a skill lacks data, it flags the gap explicitly for you to fill, and degrades gracefully, instead of inventing confidence.

The reverse path

Start anywhere. Including the middle.

Most product frameworks assume you're starting from zero. Pureinn reads what already exists, your codebase and whatever docs you have in any format, and extracts the structure for you.

Your codebasestructural truth

Your docsbusiness logic · any format

/pm-reconcile

Reads both, reconciles them against each other, and surfaces every conflict explicitly instead of merging them silently. You decide how to resolve each one.

Out comes a full workspace, built backwards

Domain modelEntity registry + state machinesBusiness rules libraryScored, phased feature backlogReconciliation report

Code is structural truth. Docs are business logic. At the end, a structured coverage check proves whether the legacy docs are safe to archive - not a guess, not a gut call.

Read the full reconciliation path →

How it runs

Four situations. One system.

You don't pick a mode up front. The orchestrator detects which of these you're in and routes you accordingly. All four run on the same skills and artifacts - they differ only in the entry point and the path.

Match your situation to its entry command →

Raw idea
Discovery - problem validation, market, personas, JTBD
Validation - hypotheses tested, Go / No-Go gate
Define - business case, lean canvas, PRD, roadmap
Domain modeling - domain model, entities, business rules
Feature planning - feature list, MVP scope, delivery stripes
Design inspection gate
Build - JIT feature specs, stripe-by-stripe delivery
Shipped, documented product

Full walkthrough in the docs →

/pm-stripeorchestrates the lifecycle, one feature per stripe

Viability (optional)1_Backlog

Spec (JIT)2_Spec_Done

Design Inspection3_Ready_to_Build

Build4_In_Build

Review5_In_Review

Ship6_Shipped

Managing expectations

What Pureinn is not.

Six boundaries, stated up front.

Not a project management tool.

It does not track tasks, sprints, or tickets. It produces the thinking and artifacts that feed those tools.

Not a code generator.

It stops at a tool-ready prototype spec and PRD. Building is a separate step, and the framework hands off cleanly to it.

Not a replacement for talking to customers.

When the highest-value next move is “go interview 3 users,” the framework says so instead of generating a document.

Not a rigid template pack.

It adapts to where you are. You do not fill in 51 blank forms in order.

Not a heavyweight corporate process.

No sign-off chains, no stage-gates for their own sake. The rigor of enterprise product process, without the bureaucratic drag.

Not a black box of AI guesses.

Every skill is opinionated and grounded. Where it assumes, it marks the assumption explicitly so you can correct it.

Not invented from scratch

Two established methodologies, one hybrid.

Feature-Driven Development provides the backbone: work organized around client-valued features, each tracked through its own lifecycle. In Pureinn, that's the Feature Card.

Spec-Driven Development provides the rigor: the build follows a spec, not a vibe. The domain model, business rules, and PRD are what a developer, or an AI builder, executes against.

The twist: just-in-time per-feature design. Classic SDD tempts you into big-design-upfront, a giant spec that rots before a line ships. Pureinn keeps the FDD backbone but designs each feature only when it's about to be built, the discipline of specs without the waste of designing things you may never ship.

Need this built into your team's process? Consulting & Advisory →

Experience

10+ years across product, tech & business

Grounding

450+ practitioner-sourced observations

Skills

51 specialist skills, full lifecycle

Maturity

v5.38.0+ semantically versioned

Install Pureinn

Install Pureinn in under a minute.

Just Claude Code, CLI or desktop app. No account, no config file to write by hand. The orchestrator scans your workspace and takes it from there.

Works with

Claude Code CLI · Claude Code desktop app · VS Code extension · JetBrains extension

Coming soon to more platforms

CursorGitHub CopilotGemini CLICodex CLI

Install via

$/plugin marketplace add ljucask/pureinn-product-development

Then open /plugin and install pureinn-product-development from the list. Select user scope to make it available across all your projects.

Update

Open /plugin and update pureinn-product-development from the list.

First run

$/pureinn "your product idea"

The orchestrator scans your workspace, asks a short set of intake questions, selects the right playbook, and gives you an ordered list of what to run next. You don't need to know the skill catalog.