Every ship, since day one.

Write access is now opt-in at the scope level. Legible installs with read-only scopes; the write_products scope is requested only when you first click Apply — so you can run the full audit without granting any write access. Apply also now publishes structured product metafields, not just descriptions. And a new before/after sales-impact view uses a data-minimized order read to show the effect of your optimizations.

• write_products moved to an optional scope — granted via Shopify's optional-scope prompt on first Apply, never at install
• Metafield write-back: Apply can now publish a structured product metafield via metafieldsSet, in addition to description rewrites via productUpdate
• Server-side scope guard verifies the live granted scopes before every write and refuses with insufficientScope if write access wasn't granted
• Sales impact: read_orders added (data-minimized — order quantities, products, and totals only; no customer data), storing only non-personal per-product daily sales aggregates
• Install scopes: read_products + read_locales + read_translations + read_orders. Optional: write_products. No customer data is requested.

The first feature that changes something in your Shopify catalog. Every AI-generated description rewrite is now reviewable and writable in one click — and undoable for 30 days. Hallucination scan rejects unsupported claims. Conflict-guard refuses to silently overwrite foreign edits.

• Apply-to-Shopify button on every AI rewrite — publishes the description via productUpdate (description field only)
• 30-day Undo on every applied change with a tenant-isolated audit log
• Conflict guard: if Shopify drifts between Apply and Undo, three-way diff for manual resolution instead of silent overwrite
• Hallucination scan rejects unsupported regulatory, numeric, or brand claims before the rewrite ever reaches your dashboard
• Per-plan daily caps: Starter 500 / Pro 2,000 / Business 10,000 writes per rolling 24h (reverts exempt)
• Four scopes: read_products + write_products + read_locales + read_translations. No customer or order data, ever.

Shopify Billing API is live. Merchants can now subscribe to a paid plan directly from the app — no manual invoicing, no workarounds. The free trial is built in and auto-activates on install. (Launch entry — the trial is now 14 days and pricing is $49 / $89 / $199; this dated note reflects the values at launch.)

• Three plans at $39 / $59 / $149 per month (Starter, Pro, Business) — launch pricing; current pricing is $49 / $89 / $199, see Pricing
• 7-day free trial on all plans, no credit card required at install — the trial is now 14 days
• Subscription webhook handles terminal states (cancelled, expired, frozen)
• Auto-test-mode on dev stores — billing flows work in development without real charges

The dashboard got a full interaction pass. The goal was to make a data-heavy app feel light — quick to scan, easy to act on, no friction between seeing a problem and knowing what to do about it.

• Momentum strip shows your score trend at a glance
• Ranked opportunities surface the highest-impact fixes first
• Setup guide walks first-time users through the initial sync
• Inline drill-in lets you expand any pillar without leaving the dashboard
• Micro-interactions on state transitions — loading, empty, error all have real UI now

Rebuilt the visual layer from scratch with a proper token system. Color, spacing, and typography are now consistent and themeable. The score and pillars communicate severity without needing to read every number.

• Design token system for color, spacing, and type scale
• Severity-coded card grid: red / amber / green by pillar score
• Score hero with animated ring and delta indicator
• Pillar tiles with inline progress bars
• Dedicated empty state, loading skeleton, and error state for every view

Pillar 6 shipped: the multilingual audit. Legible now reads your translations, checks coverage per locale, and surfaces which markets are exposed. Metafield coverage was also extended to include the namespaces AI shopping agents actually query.

• Per-locale readiness score across all six pillars
• Detection of placeholder strings and machine-translated-and-forgotten copy
• Metafield audit extended to AI-agent-relevant namespaces (material, audience, origin, care)

Near-duplicate grouping is live. We embed every product and cluster variants, re-releases, and accidental duplicates by similarity. Switched from OpenAI to Voyage AI for embeddings — better price-to-quality ratio for catalog-scale volume.

• Embedding-based duplicate groups using Voyage AI (voyage-3-lite)
• Confidence score per cluster
• Confidence score and member list for each group
• Swapped OpenAI embeddings for Voyage — lower cost, comparable quality at catalog scale

Every product description now gets a quality score from Claude Haiku. The rubric mirrors what LLMs look for when deciding whether to recommend a product: concrete attributes, materials, use cases, fit, what problem it solves. The dashboard shows the distribution across your catalog.

• Per-product description score 0–100
• Scoring rubric built against real agent decision criteria
• Distribution chart shows where your catalog clusters
• Ranked list of the highest-leverage descriptions to fix

Scores now persist between sessions. Prisma-backed storage means your catalog is held and re-scored incrementally — you don't lose progress between visits. Pagination was rebuilt to handle catalogs of 10,000+ SKUs without timeouts.

• Prisma-backed full catalog storage
• Score recomputes on sync, diffs against previous run
• Pillars scale to 10k SKUs in the same request cycle

The first real score. Five mechanical pillars scored live against your catalog, displayed in a dashboard you can actually read. The average gives you one number to track over time.

• Readiness score 0–100 (average of six pillars)
• Five pillars: descriptions, metafields, alt text, taxonomy, duplicates
• Live-read dashboard — no export step, no CSV

First live data. A GraphQL read of the merchant's catalog lands in the dashboard. Products, variants, and basic metafields. No scoring yet — just proof the pipe works end to end.

• Live GraphQL read of connected dev-store catalog
• Products and variants displayed in dashboard table
• Foundation for the scoring layer in v0.3

Day one. The app scaffolded, authenticated, and loading in a Shopify admin. OAuth to a dev store working. Embedded UI renders. The foundation everything else is built on.

• Shopify app scaffolded with Remix + Polaris
• OAuth handshake to dev store complete
• Embedded admin UI loads inside Shopify admin