Productize

Drive the full lifecycle of AI-assisted development — from idea to merged PR — with one CLI and the agent you already use.

Productize installs a catalog of hundreds of battle-tested skills into your AI coding agent (Claude Code, Codex, Cursor, and more), then orchestrates the work: turn an idea into a PRD, a PRD into a tech spec, a tech spec into tasks, execute those tasks, and remediate code-review feedback — all reproducibly, from the command line. Every artifact stays as editable Markdown in your repo; the daemon owns execution state — runs, streams, and history — under ~/.productize.

No UI. No lock-in. Your agent does the thinking; Productize runs the lifecycle.

npm install -g @productize/cli   # or: brew install --cask itseffi/productize/productize
productize onboard existing --agent codex   # integrate an existing repository

---

Why Productize

A coding prompt gets you a diff. Shipping a product needs the work to hold together across many runs and many agents. Productize makes the process a first-class artifact:

• A repeatable lifecycle — onboard existing → create-prd → create-techspec → create-tasks → run → review → archive, each stage producing a versioned file under .productize/.
• Works with the agent you have — Claude Code, Codex, Cursor, Droid, OpenCode, Gemini, Copilot, and Pi. Pick per-run with --ide and --model.
• Skills, not prompts — a large catalog of reusable skills and review gates, installed once and invoked by name inside your editor.
• Headless orchestration — a background daemon runs tasks and review-fix loops over the Agent Client Protocol (ACP), so long jobs survive your terminal and can be reattached and replayed.
• MIT licensed, single static binary, zero runtime dependencies.

---

Quickstart

1. Install

# npm (any platform, Node 18+)
npm install -g @productize/cli

# Homebrew (macOS)
brew install --cask itseffi/productize/productize

# Go (build from source)
go install github.com/itseffi/productize/cmd/productize@latest

2. Onboard an existing project

productize onboard existing --agent codex

onboard existing finds the repository root, inventories packages and existing project documentation, generates durable knowledge under .productize/project/, installs Productize for the selected agent, and registers the workspace. It is deterministic and does not call a model. Preview everything without mutations:

productize onboard existing --agent codex --dry-run

For a new repository, or when you want to manage installation separately, use the lower-level setup command:

productize setup --agent codex
productize setup --agent claude --agent codex --yes
productize setup --all-agents --yes

Interactive setup chooses exactly one agent. Selecting OpenCode or Codex writes skills only to .agents/skills; selecting Claude Code writes only to .claude/skills. Repeat --agent to target several agents. Installing into every supported agent directory requires the explicit --all-agents flag. Before confirmation, Productize shows the exact unique directories it will modify.

If an older setup populated unwanted agent directories, preview and remove only Productize-managed copies or symlinks while retaining the agent you use:

productize setup cleanup --keep-agent opencode --dry-run
productize setup cleanup --keep-agent opencode --yes

Cleanup preserves drifted, unknown, and user-owned files for manual review.

3. Run the lifecycle

Inside your AI agent (e.g. Claude Code), invoke the lifecycle skills in order. Each writes its output under .productize/tasks/<slug>/:

Step	Skill (run in your agent)	Produces
1. Requirements	create-prd	_prd.md + adrs/
2. Technical design	create-techspec	_techspec.md
3. Task breakdown	create-tasks	_tasks.md

Then orchestrate execution and review from the CLI:

productize tasks run <slug>                 # execute the task list via the daemon
productize tasks run <slug> --concurrent 3  # dependency-aware parallel worktrees
productize reviews fetch <slug> --pr 123    # pull PR review feedback
productize reviews fix <slug>               # auto-remediate review issues
productize archive                          # file away completed work

That's the whole loop. The rest of this README is reference.

---

How it works

        you, in your AI agent                 productize CLI + daemon
   ┌──────────────────────────────┐       ┌──────────────────────────────┐
   │  create-prd                   │       │                              │
   │  create-techspec   ───────────┼──────▶│  .productize/tasks/<slug>/   │
   │  create-tasks                 │ write │   _prd.md, _techspec.md,     │
   └──────────────────────────────┘ files │   _tasks.md, reviews-NNN/    │
                                           │                              │
                                           │  tasks run   ─┐              │
                                           │  reviews fix  ├─▶ ACP runtime│
                                           │  reviews watch┘  (your agent)│
                                           └──────────────────────────────┘

• Skills are the lifecycle knowledge, installed into your agent by productize setup. You invoke them inside the editor.
• The CLI owns orchestration, validation, and review automation. It does not call the model directly for lifecycle authoring — your agent does.
• The daemon is a home-scoped singleton on a unix socket (~/.productize/daemon/daemon.sock). It runs tasks and review-fix loops, persists run state to SQLite, and is started/stopped automatically. You rarely touch it.

---

Core concepts

Skills & the catalog

Skills are self-contained Markdown bundles (SKILL.md + optional references/, templates/, agents/). Productize ships hundreds of them, embedded in the binary. setup resolves an effective catalog (bundled skills + any extensions, with conflicts resolved core-first), installs it into one selected agent target by default, and writes it to ~/.productize/catalog/skills.json (or .productize/catalog/skills.json for a single project). Cleanup-only ownership checksums live beside it in setup-ownership.json; that manifest is metadata, not another skill store.

Skills are organized by a tier: frontmatter field:

• Core — the spine of the workflow: lifecycle skills (create-prd, create-techspec, create-tasks, execute-task, review-round, fix-reviews, final-verify, workflow-memory), the review gates (productize-product-review, -design-review, -eng-review, -qa, -dx-review, -comms-review, -release, -docs), and the top-level orchestration skills (productize, productize-operate, productize-grow, …). Installed even with --core-only.
• Tactical — the rest of the catalog: domain advisors and analyses (competitive analysis, A/B-test design, and many more). Installed by default; opt out with --no-tactical.

See docs/skills.md.

Reusable agents

Beyond skills, Productize ships reusable agents — named, purpose-built sub-agents you can inspect and invoke. Manage them with:

productize agents list
productize agents inspect <name>
productize exec --agent productize-operator "build X"

productize-operator is the first-stop agent for routing Productize work. It reads project knowledge, checks workflow artifacts, identifies missing PRD/TechSpec/task steps, and recommends the exact next command before mutating files or running agents.

See docs/reusable-agents.md.

Project knowledge lifecycle

The five canonical documents under .productize/project/ are generated, portable read models. Productize owns files carrying its productize:project-knowledge marker and leaves unmarked files untouched. Keep deliberate human-authored additions in manual.md so refreshes never compete with edits.

• productize onboard existing performs the complete first-time integration for an existing repository.
• productize init existing is the lower-level command for creating or explicitly refreshing project knowledge without installing skills or registering a workspace.
• A successful productize sync reconciles workflow artifacts into ~/.productize/db/global.db and refreshes project knowledge from relevant repository facts, ADRs, and durable shared workflow memory.
• productize archive moves an eligible workflow first, then refreshes knowledge from both active and archived workflows so accepted, deprecated, or superseded decisions survive archival.

Knowledge refresh is a derived-read-model step. A sync or archive can complete while the refresh result is marked degraded; text output prints every skipped file and warning, and JSON exposes the optional project_knowledge object with updated, unchanged, skipped, warnings, source_checksum, degraded, inventory, diagnostics, and imported_repository_adrs. Run productize sync again after resolving the warning to repair stale knowledge.

ACP runtimes (execution backends)

setup installs skills into 40+ editors, but execution (tasks run, reviews fix, exec) goes through an ACP-capable runtime. Productize speaks the Agent Client Protocol to whichever you choose:

--ide	Agent	Default model
codex	Codex (default)	gpt-5.5
claude	Claude Code	opus
cursor-agent	Cursor	composer-1
droid	Droid	(runtime default)
opencode	OpenCode	anthropic/claude-opus-4-6
gemini	Gemini	gemini-2.5-pro
copilot	GitHub Copilot	claude-sonnet-4.6
pi	Pi	anthropic/claude-opus-4-6

Override per run: productize tasks run <slug> --ide claude --model opus.

Workspaces & the daemon

The daemon tracks workspaces (registered project directories) and persists run state to ~/.productize/db/global.db. Workspaces are registered lazily, but you can manage them explicitly:

productize daemon status
productize workspaces list
productize runs watch <run-id>     # stream a running job

---

Command reference

Command	What it does
productize onboard existing	Inventory an existing repo, generate knowledge, install skills, and register the workspace.
productize init existing	Create or refresh only .productize/project/ knowledge docs.
productize setup	Install the skill catalog and reusable agents into one selected agent target.
productize setup --doctor	Inspect setup targets, paths, and drift without installing.
productize setup cleanup	Safely remove old Productize-managed agent targets while retaining selected agents.
productize exec [prompt]	Run one ad-hoc prompt through an ACP runtime (headless).
productize tasks run <slug>	Execute a task workflow via the daemon.
productize tasks validate	Validate task-workflow metadata.
productize reviews fetch <slug>	Import PR/review feedback into a review round.
productize reviews fix <slug>	Auto-remediate issues in a review round.
productize reviews watch <slug>	Continuously fetch + fix review rounds until clean.
productize reviews list | show	Inspect review rounds and issues.
productize runs watch | attach | purge	Stream or clean up persisted runs.
productize agents list | inspect	Discover and inspect reusable agents.
productize ext ...	Install, enable, and manage extensions.
productize workspaces ...	Manage daemon workspace registrations.
productize daemon start | status | stop	Manage the background daemon.
productize migrate	Convert legacy workflow artifacts to frontmatter.
productize sync	Reconcile workflow artifacts into the global DB and refresh project knowledge.
productize archive	Move completed workflows to _archived/ and refresh project knowledge.
productize upgrade	Update the CLI to the latest release.

Run productize <command> --help for full flags, or see the CLI reference.

---

Configuration

Productize reads TOML from two locations; the project file overrides the global one:

• Global: ~/.productize/config.toml
• Project: .productize/config.toml

[defaults]
ide = "codex"            # default agent backend
model = "gpt-5.5"        # default model
output_format = "text"   # text | json | raw-json
reasoning_effort = "medium"
access_mode = "full"
auto_commit = false

[tasks.run]
concurrent = 1
include_completed = false
output_format = "text"
verify_command = "make verify"
# Route certain task types to a specific agent/model:
task_runtime_rules = [
  { type = "frontend", ide = "codex", model = "gpt-5.5" },
]

[fetch_reviews]
provider = "coderabbit"

[watch_reviews]
max_rounds = 5
poll_interval = "30s"
auto_push = false
until_clean = false

[runs]
default_attach_mode = "auto"   # auto | stream | detach
keep_terminal_days = 7

See docs/configuration.md for every key.

Filesystem layout

.productize/                  ~/.productize/
├── config.toml               ├── config.toml
├── project/                  ├── daemon/daemon.sock
│   ├── context.md            ├── db/global.db
│   ├── conventions.md        ├── catalog/skills.json
│   ├── architecture.md       ├── catalog/setup-ownership.json
│   ├── decisions.md          ├── runs/
│   ├── constraints.md        ├── logs/
│   └── manual.md (optional)  └── agents/
├── tasks/<slug>/
│   ├── _prd.md
│   ├── _techspec.md
│   ├── _tasks.md
│   ├── reviews-001/
│   └── adrs/
├── catalog/skills.json
├── catalog/setup-ownership.json
└── tasks/_archived/

---

Extending Productize

• Write a skill — drop a SKILL.md (with name, description, and tier: frontmatter) into a skill directory; add references/ or templates/ as needed.

• Write a reusable agent — define it under agents/ and validate with productize agents inspect.

• Package an extension — bundle skills and agents and install from a git URL or path:

  productize ext install <git-url-or-path>
  productize ext doctor

See docs/extensibility/ for the authoring guide.

---

Documentation

• CLI reference — every command and flag
• Configuration — every config key and path
• The lifecycle workflow — PRD → tasks → review, end to end
• Skills & the catalog — authoring, tiers, and the effective catalog
• Reusable agents
• Extensions — build and ship extensions
• Events — the run event stream and schema
• Run reader library — read run state programmatically

---

License

MIT — see LICENSE.