# Clavue Official Website Upgrade Specification

The website source was not present in this repository when preparing the original public-content update. Apply this specification in the website repository or CMS before public release announcements.

This document expands the public site into a complete product, onboarding, documentation, and conversion surface for Clavue. It uses the structure of leading AI coding product pages as a benchmark while keeping the Clavue product identity, wording, and feature narrative independent.

## Goals

- Make `www.clavue.com` explain Clavue as an execution-first AI coding CLI, not a provider wrapper.
- Give new users a clear path from landing page to install, first run, provider setup, first useful prompt, and verification.
- Give power users a credible technical story: direct repo tools, shell execution, provider routing, MCP, skills, task tracking, worktrees, permissions, and long-session recovery.
- Give teams enough information to evaluate rollout: workflows, security posture, observability, plans, and best practices.
- Upgrade the UI from a static brochure into an interactive product guide with copyable commands, scenario tabs, workflow diagrams, and documentation entry points.

## Benchmark Takeaways To Adapt

Do not copy competitor copy. Adapt these structural patterns:

- Lead with a developer outcome, then immediately show how to start.
- Use repeated dual CTAs: self-serve start and team/sales contact.
- Put install commands in a prominent copyable module with tabs for `npx`, global npm, and curl installer.
- Explain every access surface and workflow in concrete terms instead of abstract AI claims.
- Add product proof through use cases, workflow examples, command snippets, and trust/security notes.
- Make docs discoverable from the homepage with clear paths for beginner, advanced, provider, and team audiences.
- Use motion carefully: terminal typing, route cards, status chips, and collapsible examples should clarify the workflow rather than decorate it.

## Top-Level Navigation

Recommended primary navigation:

```text
Clavue
Product
  Overview
  CLI Workflows
  Provider Routing
  Team Workflows
  MCP + Skills
Docs
  Quickstart
  Provider Setup
  Commands
  Best Practices
  Troubleshooting
Pricing
Changelog
Resources
  Use Cases
  Security
  FAQ
Get started
```

Header behavior:

- Sticky after scroll with compressed logo and persistent `Get started` CTA.
- Mobile navigation uses grouped accordions instead of a long flat list.
- Add a small `Copy install command` button in the header after the user scrolls past the hero.

## Homepage Information Architecture

### 1. Hero

Primary copy:

```text
Clavue is an execution-first AI coding CLI.
```

Supporting copy:

```text
Inspect files, edit code, run commands, verify changes, and route models through provider profiles without making the provider the product identity. Clavue keeps serious software work inside the terminal, close to your repository, permissions, tasks, and project state.
```

Primary CTAs:

```text
Get started
Read the docs
```

Secondary utility CTA:

```text
Copy install command
```

Hero command card:

```bash
npx -y clavue@8.8.125
```

Hero terminal animation:

```text
$ clavue
> Inspect the failing provider-routing test, make the smallest source fix, run the targeted test, then verify before reporting back.

Clavue
  ✓ inspected tests/provider-config-manager.test.mjs
  ✓ edited src/utils/providerProfiles.ts
  ✓ ran node --test tests/provider-config-manager.test.mjs
  ✓ verified npm run validate:repo
```

Design notes:

- Use a split hero: left copy, right terminal/workflow card.
- Add status chips under the headline: `Direct repo tools`, `Provider routing`, `MCP`, `Worktrees`, `Task tracking`, `Long-session recovery`.
- Avoid provider logos in the hero. Provider compatibility belongs in the routing section.

### 2. Install And First Run

Section headline:

```text
Start from the terminal. Stay in the execution loop.
```

Section copy:

```text
Run Clavue once with npx, install it globally when it becomes part of your daily loop, or use the install script for a pinned release.
```

Tabbed command block:

```bash
# Try once
npx -y clavue@8.8.125 --version
npx -y clavue@8.8.125
```

```bash
# Install globally
npm install -g clavue@8.8.125
clavue
```

```bash
# Install pinned release
curl -fsSL https://unpkg.com/clavue@8.8.125/install.sh | bash -s -- 8.8.125
```

First-run setup card:

```text
Choose your API setup mode:
  1. Official login
  2. Custom API configuration
  3. CCR-compatible proxy
  4. Manual setup later
```

Guidance copy:

```text
Use official login for the hosted Anthropic account flow. Use custom API configuration when your team has an API base URL and key. Use CCR-compatible proxy routing when your environment standardizes provider access through a proxy. Skip only when you want to configure later with `clavue provider` or `/provider`.
```

### 3. What Makes Clavue Different

Section headline:

```text
Built for software work that has to finish.
```

Cards:

1. **Execution-first loop**
   - Inspect repository files directly.
   - Make targeted edits.
   - Run concrete commands.
   - Verify before claiming completion.

2. **Terminal-owned workflow**
   - Keep decisions near diffs, tests, logs, and permissions.
   - Use the CLI as the control surface instead of a detached chat box.

3. **Provider control without provider lock-in**
   - Configure official login, custom API profiles, compatible gateways, and model slots.
   - Keep Clavue as the product identity while providers remain routes.

4. **Native coding workflows**
   - Use direct tools, shell execution, tasks, worktrees, MCP resources, and bundled skills in one runtime.

5. **Long-session continuity**
   - Recover from context pressure, continue long tasks, and keep task state visible across extended work.

6. **Team-ready operations**
   - Inspect local team readiness, active configuration, permission posture, and rollout state.

### 4. Product Workflow Diagram

Recommended interactive component:

```text
Open repo
  ↓
Ask for a reviewable unit
  ↓
Clavue inspects files and project instructions
  ↓
Clavue edits the smallest necessary source surface
  ↓
Clavue runs targeted verification
  ↓
Clavue reports what changed and what passed
```

Each node expands with examples:

- Open repo: `cd ~/code/my-app && clavue`
- Ask: `Fix the failing auth retry test and verify it.`
- Inspect: `Read`, `Grep`, `Glob`, project instructions, memory where relevant.
- Edit: `Edit`, `Write`, `NotebookEdit` when appropriate.
- Verify: `npm test`, `node --test`, `pytest`, `go test`, `cargo test`, or the smallest repo-specific command.
- Report: include file references and verification results.

### 5. Provider Routing

Section headline:

```text
Route models deliberately. Keep the workflow Clavue-native.
```

Section copy:

```text
Clavue treats providers as configurable routes. Operators can save profiles, switch routes, validate reachability, repair drift, and assign model slots without changing the product identity or daily workflow.
```

Command examples:

```text
/provider
/provider list
/provider current
/provider doctor
/provider validate
/provider repair
/provider use gpt54-main
/provider save-current kimi-main
```

CLI examples:

```bash
clavue provider
clavue provider list
clavue provider current
clavue provider doctor
clavue provider validate
```

Model-slot explanation:

```text
Primary model: main coding work
Small/fast model: short helper tasks and lightweight decisions
Plan/explore model: high-capability planning or analysis lanes
Subagent model: delegated searches and background investigations
Team/guide model: specialized workflows where configured
```

Dialect guidance:

```text
Proxy GPT routes stay on the Anthropic-compatible `/v1/messages` path by default. Set `CLAVUE_API_DIALECT=openai_responses` only when you explicitly want the Responses adapter for that gateway. `MYCLAUDE_API_DIALECT` remains a legacy-compatible alias.
```

### 6. Native Workflows

Section headline:

```text
One CLI for coding, review, rescue, and retrospective improvement.
```

Workflow cards:

#### `/provider` — Route control center

Use for setup, switching, validation, repair, profile adoption, and environment inspection.

```text
/provider doctor
/provider validate
/provider repair
```

#### `/mao` — Review, rescue, and delivery gates

Use for Codex-style review, adversarial review, background review, rescue flows, and final delivery-gate checks through the active Clavue provider profile.

```text
/mao setup
/mao review --background
/mao adversarial-review --base main auth and retry handling
/mao rescue --write fix the provider override bug and verify it
/mao status
/mao gate
/mao gate --json
/mao result
```

#### `/team` — Team readiness inspection

Use to inspect local team configuration, active team state, and rollout readiness.

```text
/team
/team list
/team current
/team check
```

#### `/retro` — Multi-round improvement loop

Use to run a repository retrospective and convert findings into focused upgrade work.

```text
/retro onboarding and route validation
/retro provider control center stability
```

#### Worktrees — Isolated implementation sessions

Use when the user explicitly asks to work in a worktree. Keep branch and filesystem isolation clear.

#### MCP + skills — Extend the runtime

Use MCP servers for external resources and skills for reusable workflows such as config updates, verification passes, reviews, and repo-specific development routines.

### 7. Best Use Cases

#### Fix a failing test

Prompt:

```text
Inspect the failing test around provider routing, make the smallest source fix, run the targeted test, then run the relevant verification command before reporting back.
```

Expected behavior:

- Read the failing test and nearby source.
- Identify the smallest cause.
- Edit only the necessary files.
- Run the targeted test first.
- Run a broader verification command if relevant.
- Report changed files and verification results.

#### Add a feature without losing control

Prompt:

```text
Add a settings screen option for provider validation. Follow the existing UI pattern, avoid unrelated refactors, and verify with the smallest relevant test.
```

Best-practice notes:

- Ask Clavue for one reviewable unit.
- Require existing patterns before new abstractions.
- Keep verification concrete.

#### Review a risky branch

Prompt:

```text
Review this branch for routing regressions, permission boundary issues, and missing verification. Prioritize findings with file references.
```

Recommended workflow:

```text
/mao adversarial-review --base main provider routing and permissions
```

#### Prepare a team rollout

Prompt:

```text
Inspect the local team configuration and tell me what is ready, what is missing, and what should be verified before rollout.
```

Recommended workflow:

```text
/team check
/provider doctor
```

#### Recover a long session

Prompt:

```text
Continue from the current task board. Finish the next unblocked task, verify it, and do not restart planning unless the existing approach is wrong.
```

Best-practice notes:

- Let task state drive continuation.
- Use focused verification before claiming completion.
- Avoid repeating already-completed investigation.

#### Configure a custom provider

Prompt:

```text
Open provider setup, create a saved profile for this API route, validate it, and make it the default if validation passes.
```

Command path:

```bash
clavue provider
```

### 8. Documentation Landing Page

Docs homepage headline:

```text
Learn Clavue from first install to advanced team workflows.
```

Docs cards:

1. **Quickstart**
   - Install with npx, npm, or curl.
   - Launch Clavue in a repository.
   - Choose setup mode.
   - Run the first useful session.

2. **Provider setup**
   - Official login.
   - Custom API profiles.
   - CCR-compatible proxy routing.
   - Model slots.
   - Validation and repair.

3. **Daily workflows**
   - Fix bugs.
   - Add features.
   - Review branches.
   - Write tests.
   - Verify changes.

4. **Commands**
   - `/provider`
   - `/mao`
   - `/team`
   - `/retro`
   - `/approvals`
   - `/help`

5. **Permissions and safety**
   - Permission modes.
   - Destructive action confirmation.
   - Local credential storage.
   - Worktree isolation.

6. **Troubleshooting**
   - Provider validation failures.
   - Auth and token confusion.
   - Long-context recovery.
   - Command failures.
   - macOS credential behavior.

7. **Team rollout**
   - Shared standards.
   - Team readiness checks.
   - Provider profile conventions.
   - Verification policy.

8. **Advanced runtime**
   - MCP servers.
   - Skills.
   - Subagents.
   - Background tasks.
   - Long-session recovery controls.

### 9. Quickstart Page Copy

```markdown
# Quickstart

Clavue is an execution-first AI coding CLI. Start it from a repository, ask for a concrete engineering task, and let it inspect files, edit code, run commands, and verify results.

## Install

```bash
npx -y clavue@8.8.125
```

For a global install:

```bash
npm install -g clavue@8.8.125
clavue
```

## First launch

Choose one setup mode:

- Official login if you want the hosted Anthropic account flow.
- Custom API configuration if you have an API base URL and key.
- CCR-compatible proxy if your environment routes through a proxy.
- Manual setup later if you will use `clavue provider` after launch.

## First useful prompt

```text
Inspect the failing test around provider routing, make the smallest source fix, run the targeted test, then run the relevant verification command before reporting back.
```

## What good output looks like

A good Clavue session reports the files changed, the commands run, and whether verification passed. If verification cannot run, it says exactly what remains unverified.
```

### 10. Provider Setup Page Copy

```markdown
# Provider Setup

Clavue keeps provider routing explicit. A provider is a route for model calls; Clavue remains the coding runtime.

## Open setup

```bash
clavue provider
```

Inside a session:

```text
/provider
```

## Common commands

```text
/provider list
/provider current
/provider doctor
/provider validate
/provider repair
/provider use <profile>
/provider save-current <profile>
```

## Recommended profile names

- `gpt54-main` for a validated GPT route across primary and inherited slots.
- `gpt53-all` when a route is validated for GPT-5.3 Codex-style lanes.
- `kimi-main` or `glm-main` for provider-native routing.

## Dialects

Use the default Anthropic-compatible messages path unless your gateway specifically requires the Responses adapter. Set `CLAVUE_API_DIALECT=openai_responses` only for that explicit case.
```

### 11. Commands Page Copy

Use a searchable command table:

| Command | Use it for | Example |
| --- | --- | --- |
| `/provider` | Provider profiles, validation, repair | `/provider doctor` |
| `/approvals` | Default permission mode | `/approvals` |
| `/mao` | Review, adversarial review, rescue | `/mao review --background` |
| `/team` | Team readiness and active config | `/team check` |
| `/retro` | Repo retrospective and upgrade loops | `/retro onboarding` |
| `/help` | Built-in CLI help | `/help` |

Add copy buttons for every example.

### 12. Best Practices Page Copy

```markdown
# Best Practices

## Ask for one reviewable unit

Prefer:

```text
Fix the failing auth retry test, make the smallest source change, and run the targeted test.
```

Avoid vague prompts such as:

```text
Make the app better.
```

## Require verification

Ask Clavue to run the smallest relevant verification command before reporting completion.

## Keep scope tight

Tell Clavue what not to change when risk is high:

```text
Do not refactor unrelated provider code. Keep this to the failing validation path.
```

## Use provider profiles intentionally

Save validated routes with clear names and use `/provider doctor` when behavior drifts.

## Use worktrees only when isolation matters

Worktrees are best for branch isolation, parallel experiments, or risky changes. They are not needed for every small edit.
```

### 13. Security And Trust Page Copy

```markdown
# Security And Trust

Clavue is designed for local, explicit software execution.

## Permission boundaries

Clavue should ask before destructive or shared-state actions such as deleting files, force-pushing, changing remote infrastructure, or publishing content.

## Local credentials

On macOS, Clavue avoids Keychain by default and stores local credentials in `~/.clavue/.credentials.json` to prevent startup Keychain prompts. Set `CLAVUE_USE_KEYCHAIN=1 clavue` only if you explicitly want the old Keychain behavior.

## Provider routes

Custom API URLs, API keys, tokens, and model slots are operator-controlled. Use `/provider current`, `/provider doctor`, and `/provider validate` to inspect and verify routing.

## Verification discipline

Clavue should not claim completion without concrete checks. When checks cannot run, it should report the exact unverified area.
```

### 14. Pricing Page Improvements

Keep existing Free, Pro, Max, Team, Enterprise structure. Add outcome-oriented comparisons:

- **Free**: try Clavue on small repository tasks.
- **Pro**: daily individual coding loop with provider profiles and native workflows.
- **Max 5×**: longer sessions, more review/rescue cycles, heavier repository work.
- **Max 20×**: power-user lane for all-day CLI operation and large tasks.
- **Team**: shared rollout, team readiness, standards, and provider conventions.
- **Enterprise**: procurement, compliance, managed rollout, and support.

Add a comparison table:

| Capability | Free | Pro | Max | Team | Enterprise |
| --- | --- | --- | --- | --- | --- |
| Direct repo tools | Limited | Yes | Yes | Yes | Yes |
| Provider profiles | Basic | Yes | Yes | Team standards | Managed |
| MCP resources | Basic | Yes | Yes | Shared | Managed |
| Worktrees | Yes | Yes | Yes | Yes | Yes |
| Team readiness | No | No | No | Yes | Yes |
| Support | Community | Standard | Priority | Team | Enterprise |

Do not publish numeric usage limits unless they are backed by billing implementation.

### 15. Changelog / Logs Page Improvements

Current navigation includes `Logs`. Turn it into a public trust surface:

- Release highlights.
- Breaking changes.
- Provider routing changes.
- Verification and recovery improvements.
- Security-sensitive behavior changes.
- Known issues and mitigations.

Recommended entry format:

```markdown
## 8.8.125

### Highlights
- Website, package README, and public install documentation refreshed to the current release line.
- Execution-first website and documentation refresh.
- Provider setup guidance clarified around official login, custom API, and CCR-compatible routes.

### Verification
- `npm run validate:repo`
- `npm run verify:dist`
- `npm test`

### Migration notes
- Prefer `CLAVUE_API_DIALECT` over the legacy-compatible `MYCLAUDE_API_DIALECT` alias.
```

### 16. FAQ

Add these FAQs:

#### Is Clavue a provider-specific product?

No. Clavue is the coding CLI. Providers are configurable routes for model calls.

#### Do I need official login?

No. Use official login only when you want that hosted account flow. Custom API and compatible proxy setup are supported through provider profiles.

#### Can Clavue edit my files and run commands?

Yes, when the runtime has the relevant tools available and permissions allow it. Clavue should inspect files, edit source, run commands, and verify work directly.

#### Does Clavue support MCP?

Yes. MCP resources can be part of the runtime loop alongside direct tools and skills.

#### How should I ask Clavue for work?

Ask for a concrete, reviewable unit with a verification requirement.

#### What if a command fails?

Clavue should read the error, diagnose the cause, make a focused fix when appropriate, and rerun the relevant check instead of blindly retrying.

#### Where are credentials stored?

By default on macOS, Clavue stores local credentials in `~/.clavue/.credentials.json`; Keychain can be requested explicitly with `CLAVUE_USE_KEYCHAIN=1`.

## UI And Interaction Upgrade

### Visual Direction

- Use a dark technical theme with warm accent highlights and high-contrast text.
- Keep the product feeling operational: terminals, diffs, task boards, route cards, verification badges.
- Avoid generic robot or cloud imagery.
- Prefer crisp diagrams and interface mockups over decorative illustrations.

### Core Components

#### Copyable command block

Features:

- Tabs for install method.
- Copy button with success state.
- Version selector defaulting to `8.8.125`.
- Optional `latest` toggle only if package release tooling supports it.

#### Workflow simulator

Features:

- User prompt input examples.
- Step-by-step execution timeline.
- File, edit, command, verification, and report states.
- Reduced-motion fallback showing all steps statically.

#### Provider route card

Fields:

```text
Profile name
API base URL
Credential type
Primary model
Small/fast model
Plan/explore model
Validation status
Last checked
```

Actions:

```text
Validate
Repair
Use profile
Copy command
```

#### Command palette for docs

A searchable docs command palette:

- Search commands.
- Search setup topics.
- Jump to examples.
- Copy snippets.

#### Use-case tabs

Tabs:

- Fix bugs.
- Add features.
- Review branches.
- Configure providers.
- Team rollout.
- Recover long sessions.

Each tab shows prompt, expected Clavue behavior, and verification command examples.

### Accessibility Requirements

- All interactive cards must be keyboard reachable.
- Copy buttons need visible focus and ARIA labels.
- Motion must respect `prefers-reduced-motion`.
- Terminal animations need static accessible text equivalents.
- Color contrast must pass WCAG AA.
- Do not encode provider validation state by color alone; include text labels.

### Performance Requirements

- Keep hero animation CSS-only where possible.
- Lazy-load below-the-fold diagrams.
- Avoid large decorative images in the first viewport.
- Pre-render docs pages for search and sharing.
- Keep JavaScript optional for core docs reading.

## Image And Visual Asset Briefs

No image-generation tool is available in this repository session. If using `gpt-image-2` or the product image pipeline later, generate assets from these prompts and review them for brand fit before publishing.

### Hero Visual Prompt

```text
A premium dark-mode product hero illustration for an AI coding CLI named Clavue. Show a modern terminal interface with a task timeline: inspect files, edit code, run tests, verify. Include subtle provider route cards and MCP nodes in the background. No robots, no human faces, no third-party logos. Elegant warm amber and electric blue accents, crisp vector-like UI, high readability, website hero composition, 16:9.
```

### Provider Routing Visual Prompt

```text
Technical UI diagram for Clavue provider routing. A central Clavue terminal routes to several abstract provider profile cards with model slots labeled primary, fast, plan, and subagent. Show validation badges and repair action hints. Dark background, clean glass panels, no real provider logos, no brand confusion, 16:9.
```

### Team Workflow Visual Prompt

```text
A software team operations dashboard for Clavue showing readiness checks, permission posture, provider profile standards, verification status, and rollout checklist. Premium developer-tool UI, dark theme, high contrast, minimal decorative elements, 16:9.
```

### Docs Visual Prompt

```text
Documentation landing page illustration for Clavue with cards for Quickstart, Provider Setup, Commands, Best Practices, Security, Troubleshooting, and Team Rollout. Modern technical style, dark interface, sharp typography, no human figures, no third-party logos, 16:9.
```

## SEO And Metadata

Homepage title:

```text
Clavue — Execution-first AI coding CLI
```

Homepage description:

```text
Clavue is an execution-first AI coding CLI for inspecting files, editing code, running commands, verifying changes, and routing models through provider profiles from the terminal.
```

Docs title:

```text
Clavue Docs — Quickstart, provider setup, commands, and workflows
```

Docs description:

```text
Learn how to install Clavue, configure provider profiles, use native coding workflows, run reviews, manage permissions, and verify software changes from the terminal.
```

Suggested keywords:

```text
AI coding CLI, terminal AI coding assistant, coding agent, provider routing, MCP coding tools, AI code review CLI, Clavue
```

Open Graph image guidance:

- Use the hero visual with readable `Clavue` wordmark.
- Include subtitle: `Execution-first AI coding CLI`.
- Avoid provider names in OG text.

## Conversion Paths

### Individual Developer

```text
Homepage → Copy install command → Quickstart → First useful prompt → Best practices
```

### Power User

```text
Homepage → Provider routing → Commands → /mao and /retro examples → Pricing Max
```

### Team Evaluator

```text
Homepage → Team workflows → Security → Team rollout docs → Pricing Team/Enterprise
```

### Existing User With A Problem

```text
Docs → Troubleshooting → /provider doctor → /provider validate → command-specific recovery
```

## Implementation Checklist

### Content

- [ ] Replace stale homepage version text such as `8.8.57`, `8.8.58`, or `8.8.93` with `8.8.125`.
- [ ] Replace generic hero copy with the execution-first Clavue positioning above.
- [ ] Add install tabs for npx, npm global, and pinned curl installer.
- [ ] Add first-run setup mode explanation.
- [ ] Add provider routing page and homepage section.
- [ ] Add command reference table.
- [ ] Add best use cases with prompts and expected behavior.
- [ ] Add security/trust page.
- [ ] Add FAQ.
- [ ] Update pricing page with outcome-based plan descriptions.
- [ ] Turn logs/changelog into a release trust surface.

### UI

- [ ] Build copyable command block.
- [ ] Build workflow simulator or static reduced-motion equivalent.
- [ ] Build provider route cards.
- [ ] Build use-case tabs.
- [ ] Add docs search or command palette.
- [ ] Add sticky header copy-install CTA.
- [ ] Ensure mobile navigation groups are clear.

### Quality

- [ ] Verify no public copy describes Clavue as Claude, Anthropic, or a provider-first shell.
- [ ] Verify all install commands use `clavue@8.8.125` where pinned.
- [ ] Verify `MYCLAUDE_API_DIALECT` appears only as a legacy-compatible alias.
- [ ] Verify all code snippets are copyable and syntactically correct.
- [ ] Verify docs pages have title, description, canonical URL, and OG image.
- [ ] Verify keyboard navigation, focus states, reduced motion, and color contrast.
- [ ] Run the website build, lint, and link checker in the website repo/CMS pipeline.

## Public Copy Rules

- Prefer `Clavue` for product name and `clavue` for CLI command.
- Avoid `myclaude` except when documenting a legacy-compatible alias or migration note.
- Do not imply Clavue is Anthropic-native or provider-owned.
- Say `provider profile`, `route`, or `model slot` when describing configurable model access.
- Say `verify` only when a concrete command or check exists.
- Avoid broad claims such as “autonomous software engineer” unless tied to explicit permission and verification boundaries.

## Minimum Launch Scope

If time is limited, ship these first:

1. New homepage hero, install module, and first useful prompt.
2. Provider routing section with `/provider` commands.
3. Docs landing page with Quickstart, Provider Setup, Commands, Best Practices, and Troubleshooting.
4. Use-case tabs for bug fix, feature work, review, provider setup, and team rollout.
5. Pricing copy refresh to align plans with Clavue workflows.
6. FAQ and security/trust notes.

This minimum scope gives the website a complete product story even before deeper animation, image generation, or docs search are implemented.
