productize-design

<p align="center"> <img src="imgs/productize-banner.png" alt="Productize" width="100%"> </p>

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 setup                 # install the skill catalog into your agent

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 — init 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. Install the skills into your agent

productize setup --agent codex

setup installs the skill catalog into the agent/editor you choose — it supports 40+ agents and editors (Claude Code, Codex, Cursor, Droid, OpenCode, Pi, Gemini, Copilot, Windsurf, Amp, Continue, Goose, Roo Code, Cline, and more). Non-interactive installs require an explicit target so Productize does not spray .claude, .agents, .codex, or other tool directories without permission. Installing skills is separate from executing through a runtime: to run tasks run, reviews fix, or exec you need an ACP-capable runtime (see the table below). Common options:

productize setup --list            # show everything that would be installed
productize setup --doctor --agent codex --format json
productize setup --core-only       # install only the core lifecycle skills
productize setup --global          # install for all projects (~/.productize) instead of just this one
productize setup --agent claude --agent codex --yes
productize setup --all-agents --yes

3. Adopt existing project context

For an existing repo, generate durable project knowledge before asking an agent to plan new work:

productize init existing

This writes .productize/project/ docs for inventory, context, conventions, architecture, and promoted decisions. The command is deterministic and does not call a model.

4. 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>/:

Then orchestrate execution and review from the CLI:

productize tasks run <slug>                 # execute the task list via the daemon
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) and writes it to ~/.productize/catalog/skills.json (or .productize/catalog/skills.json for a single project).

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.

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:

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

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]
include_completed = false
# 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
│   ├── inventory.md          ├── db/global.db
│   ├── context.md            ├── catalog/skills.json
│   ├── conventions.md        ├── runs/
│   ├── architecture.md       ├── logs/
│   └── decisions.md          └── agents/
├── tasks/<slug>/
│   ├── _prd.md
│   ├── _techspec.md
│   ├── _tasks.md
│   ├── reviews-001/
│   └── adrs/
├── catalog/skills.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:

``bash 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.