docs: surface code-reduction as the core AI-native value

The real moat of metadata-driven development is not 'low-code UI', it
is that the entire business system is small enough to fit in an AI
agent's context window. Make this an explicit, top-level value across
README and the concept docs.

- README.md
  - Add a 'Key Features' bullet on ~100x less code -> AI maintainability
  - Add 'Code footprint' and 'AI maintainability' rows to the
    Retool/Appsmith comparison table
  - Rewrite the 'Why AI-native?' intro to anchor the value on
    'fit in an agent's context window'

- content/docs/index.mdx
  - Add a second callout under the 'not a low-code UI builder' line
    explaining the ~100x code reduction and AI-co-maintenance angle
  - Fix stale 'npx @objectstack/cli init' -> 'npx create-objectstack'
    quick-start command (matches updated README)

- content/docs/concepts/metadata-driven.mdx
  - Rename benefit #4 'Reduced Boilerplate' -> '~100x Less Code -
    Sized for AI Agents' and reframe around context-window fit
  - Clarify that what gets generated is full CRUD + REST + typed SDK
    + MCP tools + validation + permission scaffolding, not just CRUD

- content/docs/concepts/north-star.mdx
  - Add a sixth non-negotiable tenet: 'Compact by Construction'
    -> a typical enterprise app fits in ~1% of a hand-written
    equivalent, small enough for an AI agent to load and refactor
    end-to-end. Explicitly call this out as the real moat.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: hotlong

README.md

@@ -32,6 +32,7 @@ See [ARCHITECTURE.md](./ARCHITECTURE.md) for the full microkernel and layer arch
 
 ## Key Features
 
+- **~100× less code to write and maintain** — Business objects, permissions, flows, APIs, and UI are declared as typed metadata, not hand-written. A typical enterprise module collapses from tens of thousands of lines of CRUD/glue code into hundreds of lines of declarative schema — small enough for an AI agent to load end-to-end and safely refactor.
 - **Agent-ready metadata** — Business objects, actions, and permissions are explicit enough for AI agents to inspect and use.
 - **Automatic tool surface** — Metadata can power REST APIs, client SDKs, UI views, and MCP tools without redefining each action by hand.
 - **Protocol-first schemas** — All schemas are defined with Zod; TypeScript types are derived via `z.infer<>`.
@@ -51,15 +52,19 @@ See [ARCHITECTURE.md](./ARCHITECTURE.md) for the full microkernel and layer arch
 
 Most internal-tool and low-code platforms were designed for humans clicking screens. AI support is usually added later as a chat box that can call a few predefined queries.
 
-ObjectStack starts from a different assumption: AI agents need a structured, bounded, and auditable business backend before they can safely perform real work.
+ObjectStack starts from a different assumption: **AI agents need a structured, bounded, and auditable business backend before they can safely perform real work** — and the entire business system needs to be small enough to fit in an agent's context window.
+
+A typical enterprise application is tens of thousands of lines of CRUD, forms, queries, permissions, and API glue spread across dozens of files. ObjectStack collapses the same surface into a few hundred lines of typed metadata — roughly **two orders of magnitude less code for a developer (or an AI agent) to read, write, and maintain.** That's what turns AI from an autocomplete tool into a real co-maintainer of production business software.
 
 | Dimension | Retool / Appsmith-style tools | ObjectStack |
 | :--- | :--- | :--- |
 | Business model | Implicit in pages, queries, and scripts | Explicit Zod `ObjectSchema` metadata |
+| Code footprint | Thousands of lines of queries, JS, and UI state per app | **~100× less** — declarative metadata replaces CRUD, forms, validation, and API glue |
 | Business logic | JavaScript snippets and query glue | Flows, policies, conditions, and typed metadata |
 | External contract | App-specific UI state | Self-describing JSON Project Artifact |
 | Agent tools | Manually defined one by one | Generated from metadata and permissions |
-| Agent reasoning | Calls predefined queries | Reads schema, composes safe actions, respects boundaries |
+| Agent reasoning | Calls predefined queries | Reads the full schema, composes safe actions, respects boundaries |
+| AI maintainability | Agents must crawl sprawling app code | Whole app fits in an agent's context window |
 | Governance | App-level conventions | Auth, RBAC, RLS, FLS, audit, and versioned artifacts |
 
 This makes ObjectStack a backend substrate for AI-native business applications: CRM agents, support agents, operations agents, workflow agents, and internal tools that must act on real business data without bypassing permissions or audit trails.

content/docs/concepts/metadata-driven.mdx

@@ -197,11 +197,15 @@ Node.js         Python
 React           Flutter
 ```
 
-### 4. Reduced Boilerplate
+### 4. ~100× Less Code — Sized for AI Agents
 
-**Traditional:** ~300 lines of code for a simple CRUD feature  
+**Traditional:** ~300 lines of code for a simple CRUD feature
 **ObjectStack:** ~30 lines of metadata
 
+For a complete enterprise module (CRM, ticketing, approvals, …) the gap typically widens to **roughly two orders of magnitude** — tens of thousands of lines of hand-written CRUD, forms, validation, and API glue collapse into a few hundred lines of typed metadata.
+
+The point isn't lines of code. The point is **fit in an agent's context window.** When the entire business system is small, typed, and declarative, an AI agent can load it end-to-end, reason about every dependency, and safely refactor across data, API, UI, and permissions in a single change. That turns AI from an autocomplete tool into a real co-maintainer.
+
 ```typescript
 // All you need:
 import { ObjectSchema, Field } from '@objectstack/spec/data';
@@ -232,7 +236,8 @@ export const Task = ObjectSchema.create({
   },
 });
 
-// That's it. Full CRUD functionality is ready.
+// That's it. Full CRUD, REST endpoints, typed SDK, MCP tools,
+// validation, and permission scaffolding are ready.
 ```
 
 ### 5. Agent-Ready by Construction

content/docs/concepts/north-star.mdx

@@ -31,9 +31,10 @@ Phase 1 is deliberately **code-first**:
   metadata in Phase 1.
 - ObjectOS runtimes are stateless consumers of the Project's current Version artifact.
 
-Five non-negotiable tenets:
+Six non-negotiable tenets:
 
 - **Agent-Ready Business Metadata** - objects, fields, functions, views, flows, permissions, and tools are all explicit metadata artifacts
+- **Compact by Construction** - because the whole business system is declarative metadata, a typical enterprise app fits in roughly **1% of the code** of a hand-written equivalent. Small enough for an AI agent to load end-to-end, reason about every dependency, and safely refactor across data, API, UI, and permissions in a single change - this is the real moat, not "low-code UI"
 - **Versioned Artifacts, Stateless Runtime** - every publish creates an immutable Project Version; ObjectOS runtimes pull the current Version artifact and serve it
 - **TS-Authored, JSON-Stored** - TypeScript is the authoring form (type safety, IDE intelligence, AI-assisted editing); JSON is the wire and storage form (Project Version artifact payload, Artifact API response body, local artifact cache). Zod schemas are the only bridge between the two.
 - **Local-First (development)** - every project can run against local drivers (memory, SQLite, embedded Turso replica); cloud is an enhancement, not a dependency. This refers to the *developer/runtime* mode, not to data sovereignty on end-user devices.

content/docs/index.mdx

@@ -10,8 +10,10 @@ Define business objects, permissions, workflows, APIs, UI metadata, and agent to
 
 > ObjectStack is **not another low-code UI builder**. It is the **structured execution layer** for AI-native business software: agent-ready, permission-aware, versioned, and auditable.
 
+> **~100× less code to write and maintain.** A typical enterprise application is tens of thousands of lines of CRUD, forms, queries, permissions, and API glue. ObjectStack collapses the same surface into a few hundred lines of typed metadata — small enough to fit in an AI agent's context window so the agent can reason about the whole system end-to-end and safely refactor across data, API, UI, and permissions in a single change.
+
 ```bash
-npx @objectstack/cli init my-app && cd my-app && os studio
+npx create-objectstack my-app && cd my-app && pnpm dev
 ```
 
 Open [http://localhost:3000/_studio/](http://localhost:3000/_studio/) to browse objects, test APIs, inspect metadata, and review the agent-ready tool surface.