name: production-product-builder description: Build, upgrade, or rescue complete production-grade digital products from a prompt or an existing repository. Use for SaaS, web apps, mobile-backed APIs, AI products, marketplaces, dashboards, developer tools, landing sites, ecommerce, internal tools, or major features when Codex should autonomously audit, strategize, design, implement, integrate, test, secure, optimize, document, and prepare deployment. Also use when the request mentions growth loops, launch readiness, conversion, retention, referrals, collaboration, shareability, SEO/AEO, premium motion or 3D, observability, payments, auth, infrastructure, or turning a prototype into a trustworthy product rather than returning only a plan, mockup, or snippets.

Production Product Builder

Turn a product prompt or repository into the fullest safe, working, measurable implementation the scope allows. Build end-to-end vertical slices, not disconnected screens. Optimize for durable user value and voluntary sharing rather than manipulative virality.

Start every run

1. Read repository instructions and inspect the actual stack, entry points, routes, data, auth, tests, CI, deployment, analytics, and uncommitted work.
2. Read references/execution-workflow.md and references/quality-gates.md.
3. Read only the task-relevant resources:
   • tool and integration selection: references/tool-routing.md
   • AI features, agents, RAG, voice, or model integrations: references/ai-product-playbook.md
   • activation, retention, sharing, referrals, launch, SEO/AEO, or growth: references/growth-playbook.md
   • third-party libraries, assets, hosting, or services: references/source-catalog.md
   • documentation and handoff: references/deliverables.md
4. Run scripts/repo_audit.sh <repository> when shell access is available. Treat its report as discovery evidence, not proof that a feature works.
5. Translate the request into outcomes, users, jobs, journeys, conversion, requirements, exclusions, risks, assumptions, measurable acceptance criteria, and a dependency-ordered plan. Continue into implementation unless the user explicitly requests planning only.

Operating contract

• Treat explicit user requirements as authoritative and preserve working architecture and unrelated changes.
• Resolve ordinary ambiguity with documented assumptions. Ask only for decisions that are irreversible, destructive, legally sensitive, externally consequential, or impossible to infer safely.
• Use the smallest architecture that satisfies the job. Extend a sound stack instead of replacing it for preference.
• Complete UI, domain logic, persistence, authorization, integrations, failure states, analytics, tests, and docs for each critical journey.
• Use real tools to inspect, edit, render, browse, test, and measure. Never substitute a plausible claim for executed evidence.
• Never expose secrets, access paid sources or external accounts without authorization, invent proof or metrics, bypass licenses, or run intrusive tests against production or third parties.
• Keep critical content usable without animation, WebGL, third-party scripts, or an ideal network.
• Do not commit, push, deploy, publish, purchase, message users, or mutate production unless explicitly authorized.

Product decision system

Prioritize work in this order:

1. Trust and correctness — data integrity, authorization, privacy, truthful claims, recoverability.
2. Core value — the shortest complete path from first visit to a meaningful outcome.
3. Activation and retention — onboarding, templates, sensible defaults, saved progress, reminders, collaboration, and recurring value.
4. Distribution — indexable content, shareable artifacts, invitations, embeds, referrals, integrations, and launch surfaces that are natural consequences of product use.
5. Polish — premium visual hierarchy, motion, 3D, delight, and secondary customization.

For every proposed feature, state the user problem, expected behavior, success signal, abuse/privacy risk, and cheapest valid implementation. Reject decorative or growth work that weakens the core journey.

Tool orchestration

Select tools by capability and evidence needed; do not install a fashionable stack by default. Follow the decision matrix in references/tool-routing.md.

• Use repository search, language servers, type systems, tests, and build tools for code truth.
• Use a controlled browser for rendered behavior, breakpoints, keyboard flow, console/network errors, metadata, and screenshots.
• Use image generation only for original raster assets; use code-native SVG/CSS/canvas for interface primitives and established icon systems.
• Use document, PDF, spreadsheet, and presentation tooling when those formats are actual deliverables, then render and inspect them.
• Use official APIs/connectors for source-of-truth systems; request authorization before writes with external consequences.
• Use specialist security, SEO/AEO, UI/UX, accessibility, performance, and cloud tooling when installed and task-relevant. Fall back to standards-based local checks and document coverage gaps.
• Parallelize independent read-only discovery and verification when the environment explicitly permits agent delegation. Keep edits ownership-safe and integrate before broad tests.

Build an outcome contract

Before large edits, capture a compact contract in the plan or docs/PRODUCT_STRATEGY.md:

• audience, problem, promise, primary action, activation event, and return trigger;
• roles, permissions, core journeys, page/route map, data and integration boundaries;
• functional and non-functional acceptance criteria;
• baseline and target metrics when supplied, plus instrumentation needed to measure them;
• privacy, accessibility, security, performance, reliability, SEO/AEO, and deployment constraints;
• assumptions, exclusions, dependencies, risks, and rollback path.

Never fabricate a baseline or forecast. Mark estimates as hypotheses and define how to validate them.

Implement in dependency order

1. Safe configuration, environment validation, secrets, and feature flags.
2. Schema, migrations, fixtures, and rollback/backup considerations.
3. Domain logic, API contracts, validation, authorization, idempotency, and error models.
4. Design tokens, accessible primitives, content hierarchy, and all interaction states.
5. Primary journey end to end; then secondary journeys and edge states.
6. External integrations with timeouts, retries, signatures, replay defense, fallbacks, and observability.
7. Ethical growth loop and instrumentation where the product benefits from it.
8. SEO/AEO, structured data, social cards, performance budgets, and offline/degraded behavior.
9. Tests, scans, browser verification, documentation, deployment, and rollback guidance.

After each coherent slice, run focused checks and fix causal failures before expanding scope.

Engineer growth without dark patterns

When growth is in scope, read references/growth-playbook.md and implement at most one primary loop first. A valid loop must connect value to a natural distribution action:

user receives value -> creates or shares useful artifact -> recipient experiences value -> recipient activates -> loop repeats

Instrument the funnel from acquisition through activation, retention, referral, and revenue where applicable. Include consent, attribution, abuse controls, unsubscribe/revocation, rate limits, and privacy minimization. Do not add forced invites, contact scraping, spam, fake scarcity, hidden consent, misleading social proof, or rewards that incentivize abuse.

Production engineering requirements

• Validate every trust boundary with schema-safe parsing and consistent nonsensitive errors.
• Enforce authentication and object-level authorization server-side with deny-by-default permissions.
• Use safe queries, transactions, indexes based on access patterns, bounded pagination, request limits, and upload controls.
• Protect sessions, cookies, webhooks, redirects, URL fetching, payments, CORS, CSRF, and secrets as applicable.
• Add health/readiness checks, structured logs, useful metrics/traces, error reporting hooks, audit events, backup, restore, migration, and rollback guidance.
• Make loading, empty, partial, error, unauthorized, offline, retry, success, and destructive-action states deliberate.
• Meet WCAG 2.2 AA: semantic structure, keyboard access, visible focus, contrast, labels, announcements, touch targets, zoom/reflow, and reduced motion.
• Set product-specific budgets for Core Web Vitals, route weight, images/fonts, third-party scripts, API latency, and expensive render loops. Record exceptions.
• Keep public copy specific and truthful. Never invent customers, reviews, usage numbers, prices, certifications, security guarantees, or outcomes.

Verify with evidence

Run the applicable subset and record exact commands, results, and gaps:

• format, lint, static analysis, typecheck, unit, integration, API, component, and end-to-end tests;
• production build plus migration and startup smoke checks;
• dependency, secret, SAST, container, and infrastructure scans;
• browser console/network, responsive viewport, keyboard, screen-reader spot check, automated accessibility, visual regression, and reduced-motion checks;
• production-mode performance, metadata, canonical, robots, sitemap, structured data, Open Graph, and broken-link checks;
• authorization, tenant isolation, validation, abuse, webhook, payment, data export/deletion, backup/restore, and rollback tests where relevant.

Run scripts/project_gate.sh <repository> near delivery and supplement it with project-specific commands. A skipped check is a coverage gap, not a pass. Never weaken a meaningful test or security control to obtain green output.

Finish the product

Create only relevant deliverables from references/deliverables.md. Ensure the repository contains enough information to set up, configure, migrate, seed, test, build, deploy, observe, troubleshoot, roll back, and report security issues.

Before declaring completion, verify that:

• critical journeys work end to end and acceptance criteria map to evidence;
• production build and critical tests ran successfully, or exact blockers are explicit;
• no known critical/high exploitable security issue, secret, unlicensed asset, fabricated claim, broken placeholder, dead control, or unexplained TODO remains;
• responsive, accessibility, performance, SEO/AEO, privacy, and browser coverage are recorded honestly;
• documentation matches the implementation and the working tree contains only intended changes.

Use the concise evidence-based final format in references/deliverables.md. Never call the result production-ready when a required release gate failed or was not run.

Production Product Builder

An autonomous Codex and Claude workflow for turning a product prompt—or an unfinished repository—into the fullest safe, working, measurable implementation the scope allows.

The skill coordinates product strategy, UX/UI, full-stack engineering, AI features, ethical growth loops, security, accessibility, SEO/AEO, testing, infrastructure, operations, and documentation. It is designed to produce actual repository changes and verification evidence instead of stopping at a plan, mockup, or disconnected code snippets.

The skill cannot guarantee that a product will “go viral.” It can design and instrument value-driven distribution loops, measure where they succeed or fail, and prevent common spam, privacy, fraud, and dark-pattern failure modes.

Table of contents

1. What this skill does
2. How it works
3. System architecture
4. Capabilities
5. Ethical growth system
6. AI product engineering
7. Installation
8. Usage
9. Bundled tools
10. Repository structure
11. Verification
12. Safety and authorization
13. Customization
14. Troubleshooting
15. Known limitations
16. Contributing

What this skill does

Use Production Product Builder when you want an agent to build, upgrade, rescue, or prepare a digital product for release. It supports:

• SaaS applications and dashboards;
• AI assistants, agents, RAG systems, voice products, and model-backed workflows;
• marketplaces, ecommerce, subscriptions, payments, and account portals;
• developer tools, APIs, integrations, internal tools, and automation;
• landing sites, public product websites, SEO/AEO content, and launch experiences;
• mobile-backed APIs and responsive web applications;
• premium motion, Lottie, Rive, WebGL, Three.js, Spline, and GLB/glTF experiences;
• conversion, activation, retention, collaboration, referral, sharing, template, embed, integration, and user-generated-content loops;
• prototype-to-production upgrades, security hardening, performance work, accessibility remediation, and release verification.

The skill follows five product priorities:

1. Trust and correctness
2. Core user value
3. Activation and retention
4. Distribution and discoverability
5. Visual polish and delight

This ordering prevents growth mechanics or decorative complexity from weakening the product’s essential journey.

How it works

The agent begins with repository evidence, converts the request into an outcome contract, implements dependency-ordered vertical slices, and repeatedly verifies the result.

flowchart TD
    A[Product prompt or existing repository] --> B[Load repository instructions]
    B --> C[Audit stack, routes, data, auth, tests, CI and working tree]
    C --> D[Define users, value event, journeys and acceptance criteria]
    D --> E[Create dependency-ordered implementation plan]
    E --> F[Architecture, schema, contracts and security boundaries]
    F --> G[Design system, content and interaction states]
    G --> H[Build primary journey end to end]
    H --> I{Specialized scope?}
    I -->|AI or agents| J[Load AI product playbook]
    I -->|Growth or launch| K[Load ethical growth playbook]
    I -->|Tools or services| L[Load tool routing and source catalog]
    I -->|No| M[Build secondary journeys and integrations]
    J --> M
    K --> M
    L --> M
    M --> N[Run focused tests and browser checks]
    N --> O{Causal defect found?}
    O -->|Yes| P[Fix root cause]
    P --> N
    O -->|No| Q[Run project-wide quality gate]
    Q --> R{Required gate passed?}
    R -->|No| S[Fix or document exact blocker]
    S --> Q
    R -->|Yes| T[Update documentation and release evidence]
    T --> U[Concise handoff with commands, results and risks]

Outcome contract

Before large implementation work, the agent defines:

• target users, problem, promise, primary action, and value event;
• activation event, return trigger, and measurable success signals;
• routes, roles, permissions, data, integrations, and critical journeys;
• functional and non-functional acceptance criteria;
• privacy, accessibility, security, performance, reliability, SEO/AEO, and deployment constraints;
• assumptions, exclusions, dependencies, risks, feature flags, and rollback strategy.

Unknown metrics remain hypotheses. The skill never invents baselines, customers, testimonials, certifications, revenue, or growth results.

Dependency-ordered delivery

flowchart LR
    A[Configuration and secrets] --> B[Schema and migrations]
    B --> C[Domain logic]
    C --> D[API validation and authorization]
    D --> E[Accessible design system]
    E --> F[Primary vertical slice]
    F --> G[Integrations and background work]
    G --> H[Growth and instrumentation]
    H --> I[SEO/AEO and performance]
    I --> J[Tests and security]
    J --> K[Deployment, rollback and handoff]

Each critical journey is expected to include UI, boundary validation, domain logic, persistence, server-side authorization, integrations, loading/error/empty states, analytics, tests, and matching documentation.

System architecture

The package uses progressive disclosure. Codex sees compact triggering metadata first, loads the core workflow only when the skill applies, and reads specialist references only when the request needs them.

flowchart TB
    U[User request] --> M[Skill metadata]
    M -->|Request matches| S[SKILL.md core workflow]
    S --> A[Repository audit tool]
    S --> W[Execution workflow]
    S --> Q[Quality gates]
    S --> D[Deliverables contract]
    S --> R{Task-specific routing}
    R --> AI[AI product playbook]
    R --> G[Growth playbook]
    R --> T[Tool routing]
    R --> C[Licensed source catalog]
    A --> P[Target product repository]
    W --> P
    AI --> P
    G --> P
    T --> P
    C --> P
    P --> V[Project gate and project-specific checks]
    V --> H[Evidence-based handoff]

This keeps SKILL.md concise while retaining detailed domain guidance under references/.

Capabilities

Product and UX

• Product strategy, positioning, audiences, jobs to be done, and acceptance criteria
• Information architecture, routes, onboarding, conversion paths, retention triggers, and failure states
• Responsive design systems, reusable components, design tokens, content hierarchy, and premium visual direction
• WCAG 2.2 AA guidance for keyboard use, focus, contrast, labels, announcements, touch targets, zoom/reflow, and reduced motion
• Truthful product copy, trust signals, structured FAQs, and content governance

Frontend

• Semantic, accessible, responsive interfaces
• Server rendering, static generation, streaming, and client rendering selected intentionally
• Loading, skeleton, partial, empty, offline, retry, unauthorized, success, and destructive-action states
• Image, font, route-chunk, third-party-script, motion, and WebGL optimization
• Browser, network, console, responsive, visual, and accessibility verification

Backend and data

• Typed API contracts, schema validation, consistent error models, pagination, idempotency, and transactions
• Authentication, server-side authorization, tenant isolation, sessions, tokens, cookies, and audit trails
• Database migrations, indexes, fixtures, backup, restore, retention, deletion, and rollback planning
• Background jobs, queues, caching, storage, search, webhooks, retries, timeouts, circuit breakers, and graceful degradation
• Rate limits, request limits, safe uploads, CORS, CSRF, SSRF, redirect, and payment protections

Infrastructure and operations

• Reproducible local development and environment validation
• Docker, infrastructure-as-code, CI/CD, deployment, preview environments, and rollback guidance when relevant
• Health/readiness endpoints, structured logs, metrics, traces, error reporting, alert hooks, and incident considerations
• Capacity, cost, vendor lock-in, regional/privacy, backup, and failure-mode decisions

Quality and security

• Formatting, linting, type checking, static analysis, production builds, and startup smoke tests
• Unit, integration, API, component, contract, browser, end-to-end, regression, and visual tests
• Dependency, secret, SAST, container, infrastructure, and authorized dynamic-security scans
• Threat review covering access control, injection, XSS, CSRF, SSRF, uploads, supply chain, webhooks, payments, abuse, privacy, and recovery
• Exact evidence reporting: passed, failed, blocked, and skipped checks remain distinct

SEO, AEO, and launch readiness

• Search-intent and page maps, metadata, canonical URLs, robots, sitemap, status codes, redirects, and internal links
• Open Graph/social previews, stable share URLs, structured data, entity facts, and answer-oriented content
• Performance budgets and production-mode Core Web Vitals review
• Launch landing pages, feedback paths, changelogs, support/status surfaces, lifecycle messaging, and analytics definitions

Ethical growth system

The growth playbook helps the agent select one primary value-driven loop rather than stacking unrelated growth tactics.

flowchart LR
    A[User receives core value] --> B[Product creates a useful distribution object]
    B --> C[User voluntarily shares, invites, publishes or embeds]
    C --> D[Recipient receives value before or during signup]
    D --> E[Recipient reaches activation event]
    E --> F[Recipient returns and creates new value]
    F --> B
    C -. guardrails .-> G[Consent, permissions, revocation, rate limits]
    E -. measurement .-> H[Activation, retention, attribution, fraud review]

Supported patterns include:

| Loop