docs

Author: mudgen

website/docs/intro.mdx

@@ -10,53 +10,64 @@ import Callout from '@site/src/components/ui/Callout';
 import FeatureGrid, { FeatureGridItem } from '@site/src/components/features/FeatureGrid';
 import DiamondFacetsSVG from '@site/static/img/svg/compose_diamond_facets.svg'
 
+{/*
 <DocHero
   title="Build with the Compose"
   subtitle="Compose is a general purpose smart contract library. It helps you create smart contract systems."
   variant="gradient"
   height="medium"
 />
+*/}
+
+**Compose** is a general-purpose smart contract library that helps you build smart contract systems.
+
+Traditional smart contract libraries give you source code that you must modify, extend, and deploy yourself to one or more blockchains.
 
-Past smart contract libraries gave you source code and expected you to extend or modify it and then deploy it to one or more blockchains. 
+**Compose takes a different approach.**
 
-Compose is different. We **don't** expect you to do that. We take a different approach.
+Compose provides a set of **reusable on-chain contracts** that already exist on blockchains—you don't need to deploy or manage them yourself. The heavy lifting has been done.
 
-Compose gives you a set of reusable smart contracts that already exist on blockchains. You don't have to deploy Compose source code. It's already been done. The smart contracts are already deployed for your use.
+For your next project, instead of deploying new contracts, simply **use the existing on-chain contracts** provided by Compose.
 
-For your new project, instead of deploying new contracts, use existing onchain smart contracts provided by Compose.
 
 :::tip[Key Insight]
 Compose is a general purpose **onchain** smart contract library. 
 :::
 
 :::info[In Development]
-  We haven't actually deployed smart contracts yet because we are in early development. We are building. If this is exciting to you, come join us.
+Compose is still in early development, and its smart contracts haven't been deployed yet.
+We're actively building—and if this vision excites you, we'd love for you to join us.
 :::
 
 
 ## Reusable Smart Contracts
 
-You might wonder how to create a new project without deploying new smart contracts. How does Compose enable people to create new smart contract systems using existing onchain contracts?
+You might be wondering: **How can I create a new project without deploying new smart contracts?**
 
-This is where Compose's smart contract architecture comes in. Compose uses [diamond contracts](https://eips.ethereum.org/EIPS/eip-2535) 
-to organize smart contracts and make them reusable. 
+How does Compose make it possible to build new systems from existing onchain contracts?
 
-A diamond contract is a simple, small contract that uses the code of other onchain contracts.
+The answer lies in Compose’s smart contract architecture, which is based on [diamond contracts](https://eips.ethereum.org/EIPS/eip-2535).
 
-A diamond contract creates and maintains its own storage data using code from other contracts. These "other contracts" are called facets. Here is a diagram of a diamond that shows it gets its code from facets.
+A diamond contract is a simple, tiny contract that **uses the code of other onchain contracts** called **facets**. Each diamond uses the code of other contracts (facets) to create and maintain its storage data and state.
+
+Below is a diagram showing a diamond connected to multiple facets that provide its functionality.
 
 <DiamondFacetsSVG style={{ width: '800', height: 'auto' }} />
 
-Using Compose you do actually deploy new contracts. Specifically you deploy a small diamond contract that uses existing onchain facets.
+When you use Compose, you *do* deploy new contracts—but only the small diamond contract that ties together existing onchain facets.
+
+Let's look at a simple example.
+
+Suppose you want to create a new ERC-20 token that supports gasless approvals (permit) and cross-chain bridging.
 
-Let's look at a simple example of how this works. Let's say that you want to create a new ERC20 token that uses the gasless "permit" function and can be bridged to other blockchains. **Use Compose to:**
+With Compose, you can:
 
-1. Find and choose onchain facets you need. In this case `ERC20Facet`, `ERC20PermitFacet` and `ERC20BridgableFacet`.
-2. Setup initialization information such as the name of your ERC20 token, its total supply, etc.
-3. Deploy a diamond which initializes your ERC20 token and uses the onchain facets in step 1.
+1. **Select the facets you need** – for example, `ERC20Facet`, `ERC20PermitFacet`, and `ERC20BridgableFacet`.
+2. **Provide initialization data** – such as the token name, symbol, and total supply.
+3. **Deploy your diamond** – which initializes your ERC-20 token and connects it to the chosen facets.
 
 :::tip[Key Insight]
-Many diamond contracts are deployed that reuse the same onchain facets.
+Many diamond contracts can be deployed that **reuse the same onchain facets**.
 :::
 
 ## Composable Contracts
@@ -125,7 +136,7 @@ Isolated, small, simply written onchain components that are composed with your u
 <FeatureGrid columns={3}>
   <FeatureGridItem
     icon={<Icon name="package" size={32} />}
-    title="On-Chain Standard Library"
+    title="Onchain Standard Library"
     description="Access verified, audited facets deployed once and reused across multiple diamonds on multiple blockchains."
   />
   <FeatureGridItem