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.

What this skill does
How it works
System architecture
Capabilities
Ethical growth system
AI product engineering
Installation
Usage
Bundled tools
Repository structure
Verification
Safety and authorization
Customization
Troubleshooting
Known limitations
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.

It also ships a specialist premium microsite track for content-led sites with no application backend — brand, practitioner and clinic, studio, portfolio, restaurant, venue, product launch, event, and campaign sites. That track swaps the backend half of the contract for a queryable design-and-content knowledge base, a build-brief generator, and a release gate tuned to prerendering, motion, WebGL, structured data, and truthful claims. See references/premium-microsite-playbook.md.

The skill follows five product priorities:

Trust and correctness
Core user value
Activation and retention
Distribution and discoverability
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	Typical implementation	Required guardrails
Collaboration	Scoped invitations, shared objects, activity notifications	Least privilege, revoke access, invitation limits
Shareable artifact	Public report, design, result, export, remix	Private-by-default choices, preview, stable permissions
Template	Gallery, duplicate/remix, creator credit	Licensing, moderation, canonical rules
User-generated SEO	Structured public pages and taxonomies	Quality thresholds, moderation, no thin pages
Embed/API	Useful widget, badge, API output, attribution	Performance, security, opt-out
Marketplace	Listings, profiles, inquiry or transaction workflow	Fraud controls, moderation, disputes
Referral	Qualified two-sided incentive	Eligibility, reward delay/caps, self-referral detection
Integration	Workflow action or synchronized data	Narrow scopes, token revocation, outage handling

The skill prohibits forced invitations, contact scraping, spam, hidden consent, fake scarcity, misleading social proof, notification traps, and incentives designed for abuse.

AI product engineering

The AI product playbook covers model-backed features without treating probabilistic output as trusted application state.

flowchart LR
    A[User input] --> B[Input limits and policy]
    B --> C[Context or authorized retrieval]
    C --> D[Model inference]
    D --> E[Typed output validation]
    E --> F{Tool or external action?}
    F -->|No| G[Grounded user response]
    F -->|Yes| H[Server-side authorization and confirmation]
    H --> I[Idempotent tool execution]
    I --> J[Read authoritative result]
    J --> G
    D --> K[Evaluation and tracing]
    I --> K
    K --> L[Quality, latency, cost and safety monitoring]

It provides guidance for:

structured extraction, drafting, classification, routing, grounded Q&A, and background enrichment;
tool-calling assistants, multi-step agents, realtime experiences, and voice workflows;
model/provider comparison using representative evaluations rather than marketing claims;
hybrid retrieval, access-controlled RAG, citations, freshness, deletion propagation, and abstention;
prompt-injection defense, least-privilege tools, approval boundaries, idempotency, audit logs, and kill switches;
versioned evaluations, groundedness, tool accuracy, harmful-output checks, human review, latency, and cost;
timeouts, bounded retries, queues, backpressure, caching, fallbacks, quotas, and provider-outage behavior.

Installation

Prerequisites

Codex or another skill-aware agent environment
Git for repository inspection
Bash for the bundled audit and project-gate scripts
The target project’s own language runtimes and package managers
Optional quality tools such as ShellCheck, Gitleaks, Trivy, Terraform, Hadolint, and framework-specific test tools

The skill itself has no database, runtime service, environment variables, paid account, or production dependency.

Install as a Codex skill

Place this directory at the skill path:

~/.codex/skills/production-product-builder/

The installed directory must keep this structure intact:

production-product-builder/
├── SKILL.md
├── agents/
├── data/
├── references/
└── scripts/

For Claude Code, place the same directory at ~/.claude/skills/production-product-builder/. Both hosts read the identical SKILL.md, data/, and scripts/; nothing in the microsite track depends on host-specific tooling.

Restart or refresh the skill list if the host application does not discover filesystem changes automatically.

Use as repository instructions

For repository-local use, keep the package in the project and make the repository’s AGENTS.md or CLAUDE.md explicitly instruct the agent to read skills.md. This repository already includes both instruction files.

Verify installation

Run the skill validator supplied with your Codex installation:

python3 /path/to/skill-creator/scripts/quick_validate.py /path/to/production-product-builder

A valid installation reports:

Skill is valid!

Usage

Invoke the skill explicitly with $production-product-builder, or use a request that clearly matches its description.

Build a SaaS product

Use $production-product-builder to build a multi-tenant client portal with team invitations,
role-based access, file approvals, subscription billing, audit logs, tests, and deployment docs.

Upgrade an existing repository

Use $production-product-builder to audit this repository and turn the current prototype into
a release-ready product. Preserve the stack, finish the onboarding and billing journeys,
fix accessibility and security gaps, add tests, and verify the production build.

Build an AI product

Use $production-product-builder to build a source-grounded support assistant with tenant-safe
retrieval, citations, scoped tools, prompt-injection defenses, evaluations, usage limits,
observability, and a useful provider-outage fallback.

Build an ethical growth loop

Use $production-product-builder to improve activation and organic distribution. Identify the
core value event, implement one share or collaboration loop, instrument the funnel, add fraud
and privacy controls, and document the experiment and rollback plan.

Build a premium public experience

Use $production-product-builder to create a high-converting accessible product site with an
original visual system, restrained motion, optimized 3D only where it explains the product,
SEO/AEO, social previews, responsive verification, and performance budgets.

Build a premium microsite

Use $production-product-builder to build a site for Dr. Sharma, an interventional pulmonologist
in Bhopal. Authority-led, scroll-choreographed, no backend. Use the premium microsite track:
generate the brief from the practitioner-authority archetype, hold the standard budget tier,
and pass scripts/microsite_gate.sh before you report done.

Use $production-product-builder to build a brand site for a soda company with six flavours and a
1974 heritage story. consumer-brand-cpg archetype, playful-pop kit, one WebGL bottle behind a
poster and a capability gate, webgl-centrepiece budget tier.

The agent should run microsite_brief.py first, return the brief with its TODO(client) list, build the static shell before any motion, and finish with gate output rather than a claim.

Plan-only mode

The skill normally continues from planning into implementation. State the limitation explicitly when you want strategy without repository changes:

Use $production-product-builder in planning-only mode. Audit the repository and produce a
dependency-ordered implementation plan with acceptance criteria, risks, and release gates.
Do not edit files.

Bundled tools

Premium microsite knowledge base

Nine CSV datasets under data/ hold the design and content intelligence for content-led sites, queried with a BM25 search over the row text. Standard library Python only — no install step, identical behaviour for Codex and Claude Code.

python3 scripts/microsite_search.py --list-domains
python3 scripts/microsite_search.py "practitioner clinic credentials" --domain archetype
python3 scripts/microsite_search.py "pinned scroll scrub" --domain motion --max-results 3
python3 scripts/microsite_search.py "product bottle glb" --domain webgl --format box
python3 scripts/microsite_search.py "doctor local business" --domain schema --format json

Domain	File	Rows	Contents
`archetype`	`microsite-archetypes.csv`	18	Section order, motion tier, WebGL use, schema types, proof requirements, exclusions
`section`	`section-recipes.csv`	30	Content slots, layout, motion, required states, accessibility, copy rule, common failure
`motion`	`motion-recipes.csv`	26	GSAP/Lenis snippets, reduced-motion end state, cleanup, performance notes, failure mode
`webgl`	`webgl-recipes.csv`	10	Asset spec, libraries, fallback, budget, checks, anti-pattern
`schema`	`schema-recipes.csv`	17	JSON-LD templates, validation route, pitfalls
`stack`	`stack-recipes.csv`	6	Scaffold commands, prerender approach, deploy, gotchas
`brand`	`brand-kits.csv`	10	Contrast-checked palettes, font pairings, fluid type scale, texture direction
`budget`	`perf-budgets.csv`	5	Per-tier JS/CSS/image/font/3D budgets and measurement profile
`content`	`content-formulas.csv`	16	Copy formulas with good/bad examples and truthfulness constraints

Every palette in brand-kits.csv is verified against WCAG 2.2 AA: ink-on-background and muted-ink-on-surface at or above 4.5:1, accent-on-background at or above 3:1.

Microsite build brief

python3 scripts/microsite_brief.py --list
python3 scripts/microsite_brief.py --archetype practitioner-authority --name "Dr. Example" \
  --out docs/MICROSITE_BRIEF.md

Emits the outcome contract, the explicit exclusion list, the client facts that must be supplied, a section map resolved against the section recipes, a CSS design-token block, a motion plan for the archetype's tier, the WebGL decision, structured-data targets, the stack and file plan, the performance budget table, and the verification list. Client-supplied facts are marked TODO(client) and fail the gate until replaced.

Microsite release gate

npm run build
scripts/microsite_gate.sh /path/to/site

Fourteen static checks against the production build: prerendered content, head metadata and social cards, JSON-LD validity, robots and sitemap, image alt text and intrinsic dimensions, initial JS/CSS gzip budgets, 3D absent from the initial load graph, reduced-motion handling, shipped placeholders, asset weights, insecure resources and leaked keys, landmarks and skip link, autoplay media, and anchor targets with scroll-margin.

Budgets are overridable with BUDGET_JS_KB, BUDGET_CSS_KB, BUDGET_IMG_KB, BUDGET_MODEL_KB, and the output directory with BUILD_DIR. The gate is static inspection only and does not replace the browser, keyboard, reduced-motion, throttled-network, Lighthouse, or screen-reader passes.

Repository audit

Run the read-only discovery helper before implementation:

scripts/repo_audit.sh /path/to/product-repository

It reports:

current branch and uncommitted changes;
repository instructions;
JavaScript/TypeScript, Python, Go, Rust, .NET, PHP, Ruby, Java, container, and infrastructure signals;
CI, environment examples, migrations, and test signals;
available package scripts;
follow-up discovery reminders.

The report is orientation evidence, not proof that a capability works or does not exist.

Project quality gate

Run the best-effort release gate near delivery:

scripts/project_gate.sh /path/to/product-repository

The script discovers supported project types and runs available checks:

Ecosystem	Checks when detected
JavaScript/TypeScript	`format:check`, lint, typecheck, tests, build, dependency audit
Deno	Format, lint, tests
Python	Ruff, mypy, pytest, dependency audit
Go	Tests and vet
Rust	Format, Clippy, tests
PHP	Composer validation/audit, lint and test scripts
Ruby	RuboCop, Rake tests, dependency audit
.NET	Restore, build, tests
Java	Maven verify or Gradle check
Terraform	Recursive format and root-module validation
Dockerfiles	Hadolint
Shell	ShellCheck
Cross-stack security	Gitleaks and Trivy

Project-specific commands must supplement this gate. A skipped tool is a coverage gap, not a successful check.

Repository structure

production-product-builder/
├── AGENTS.md                         # Codex repository instructions
├── CLAUDE.md                         # Claude Code repository instructions
├── README.md                         # Human-facing project guide
├── SKILL.md                          # Skill metadata and core operating workflow
├── skills.md                         # Shared autonomous product-building contract
├── agents/
│   └── openai.yaml                   # Skill-list display metadata and default prompt
├── data/                             # Premium microsite knowledge base (BM25-queried)
│   ├── brand-kits.csv                # Contrast-checked palettes, type pairings, texture
│   ├── content-formulas.csv          # Copy formulas and truthfulness constraints
│   ├── microsite-archetypes.csv      # Site archetypes, section order, proof, exclusions
│   ├── motion-recipes.csv            # GSAP/Lenis recipes with reduced-motion end states
│   ├── perf-budgets.csv              # Budget tiers and measurement profiles
│   ├── schema-recipes.csv            # JSON-LD templates and pitfalls
│   ├── section-recipes.csv           # Section slots, layout, states, accessibility
│   ├── stack-recipes.csv             # Scaffold, prerender and deploy recipes
│   └── webgl-recipes.csv             # 3D patterns, budgets and required fallbacks
├── references/
│   ├── ai-product-playbook.md        # Agents, RAG, voice, evals, AI safety and cost
│   ├── deliverables.md               # Documentation and final-report contract
│   ├── execution-workflow.md         # Discovery-to-delivery sequence
│   ├── growth-playbook.md            # Ethical activation, retention and viral loops
│   ├── premium-microsite-playbook.md # Content-led site doctrine, motion and WebGL rules
│   ├── quality-gates.md               # Product, security and release criteria
│   ├── source-catalog.md              # Licensed libraries, services and asset sources
│   └── tool-routing.md                # Capability selection and evidence hierarchy
└── scripts/
    ├── microsite_brief.py             # Archetype -> build contract, tokens, section map
    ├── microsite_gate.sh              # Microsite release checks against a built site
    ├── microsite_search.py            # BM25 search over the data/ knowledge base
    ├── project_gate.sh                # Multi-stack release checks
    └── repo_audit.sh                  # Read-only repository discovery

Verification

Use these commands after changing the skill:

bash -n scripts/repo_audit.sh scripts/project_gate.sh scripts/microsite_gate.sh
python3 -m py_compile scripts/microsite_search.py scripts/microsite_brief.py
python3 scripts/microsite_search.py --list-domains
python3 scripts/microsite_brief.py --archetype practitioner-authority --name "Verification run"
scripts/repo_audit.sh .
scripts/project_gate.sh .
python3 /path/to/skill-creator/scripts/quick_validate.py .
git diff --check

At the time of this README update:

all three shell scripts passed Bash syntax validation and both Python scripts passed py_compile;
every data/*.csv file parsed with a consistent column count (18/30/26/10/12/6/10/5/16 rows);
all 148 section labels referenced by the 18 archetypes resolved to a canonical section recipe;
all 10 brand-kit palettes passed programmatic WCAG 2.2 AA contrast checks;
microsite_gate.sh reported 14 passed / 0 failed on a compliant fixture build and 7 passed / 7 failed on a real-world client-rendered build, correctly identifying the missing prerender, absent structured data, missing crawl files, over-budget bundle, 3D in the initial chunk, and missing landmarks;
the repository audit executed successfully and the project gate completed with no failures;
JavaScript and Python project gates were not applicable to this instruction-only repository;
ShellCheck, Gitleaks, and Trivy were unavailable and therefore reported as skipped, not passed.

Safety and authorization

The skill is intentionally conservative around consequential actions.

It does not authorize an agent to:

commit, push, open a pull request, deploy, publish, or change production;
purchase services, paid templates, media, animations, fonts, models, or licenses;
access external accounts, customer data, paid sources, or production systems;
message users, send invitations, create campaigns, or mutate third-party systems;
run intrusive security testing against production or third-party targets;
copy proprietary designs, bypass paywalls, remove watermarks, expose secrets, or invent evidence.

Those actions require explicit user authorization and exact target verification. External writes should be previewed when possible and re-read after execution.

The growth system additionally rejects spam, contact scraping, forced invites, hidden consent, fake social proof, fake scarcity, deceptive experiments, referral farming, and notification traps.

Customization

Change when the skill triggers

Edit only the name and description YAML fields at the top of SKILL.md. The description is the primary implicit-trigger mechanism, so include both what the skill does and the situations in which it should be used.

Change the visible skill metadata

Update agents/openai.yaml. Keep:

display_name human-readable;
short_description between 25 and 64 characters;
default_prompt short and explicitly containing $production-product-builder.

Extend a specialist workflow

Add focused guidance under references/ and link it directly from SKILL.md. Avoid deeply nested references and avoid expanding the always-loaded core with framework-specific material.

Add a deterministic tool

Place repeatable, fragile, or evidence-producing automation under scripts/. Make the script safe by default, parameterize the target, validate paths, avoid secrets, and execute representative tests before delivery.

Add a third-party service or asset source

Update references/source-catalog.md with official source, license/plan constraints, intended usage, attribution, operational trade-offs, and fallback. Never treat a catalog entry as permission to install, purchase, or access it.

Troubleshooting

The skill does not trigger

Invoke it explicitly with $production-product-builder.
Confirm the folder is named production-product-builder.
Confirm SKILL.md exists at the folder root and its YAML frontmatter is valid.
Run the skill validator and restart or refresh the host’s skill discovery.

The repository audit misses a file

The audit intentionally limits traversal and excludes common generated/vendor directories. Use rg --files and inspect the relevant source directly. The script is a fast orientation tool, not a complete inventory system.

The project gate skips checks

Install the target project’s required runtime or optional scanner, or run the repository’s native command directly. Skips are reported because absence of a tool is not evidence of correctness.

The project gate fails

Read the first causal error, run the smallest failing command directly, fix the cause, rerun the focused check, then rerun the full gate. Do not delete or weaken meaningful tests solely to obtain a green result.

The agent stops after planning

Confirm the prompt did not request planning-only mode and that the environment permits file writes. The operating contract instructs the agent to continue into implementation for normal build and upgrade requests.

A paid asset or external integration is unavailable

Provide lawful access and compatible licensing, select an open/free commercial-use alternative, create an original replacement, or accept a clearly documented placeholder. The skill will not bypass account or licensing requirements.

Known limitations

The skill improves execution discipline; it cannot guarantee commercial success, virality, product-market fit, security, legal compliance, or a production deployment.
Dynamic browser, accessibility, performance, payment, webhook, cloud, and security verification depends on available tools and an authorized test environment.
The generic project gate cannot understand every monorepo, custom build system, nested Terraform module, mobile-native toolchain, or organization-specific release policy.
Current external documentation, pricing, licenses, model behavior, regulations, and platform APIs must be verified from official sources when selected.
Human review remains important for brand, legal, medical, financial, safety-critical, high-impact AI, production migration, and irreversible operational decisions.
This repository currently has no declared software license. Confirm or add an appropriate license before redistribution.

Contributing

Keep changes scoped and preserve the progressive-disclosure design:

Read AGENTS.md, skills.md, and SKILL.md.
Put universal workflow rules in SKILL.md and detailed specialist guidance in a directly linked reference.
Add scripts only for repeatable operations that benefit from deterministic execution.
Use official sources and document license, privacy, maintenance, performance, and fallback implications.
Test new scripts and run the verification commands above.
Report exact results and distinguish skipped or blocked coverage from successful checks.
Do not commit or push unless the repository owner explicitly requests it.

Security reports

Do not publish secrets, exploit details, or sensitive vulnerability evidence in a public issue. Contact the repository owner through an approved private channel. No dedicated security-reporting address is configured in this repository yet.

Start with:

Use $production-product-builder to audit this repository, define the core value and acceptance
criteria, implement the highest-value end-to-end journey, add the right growth or AI systems,
verify the result, and provide an evidence-based handoff.

Startup Builder Pro

At a glance

README