Apply suggestions from code review

Co-authored-by: Amir Hossein Hashemi <87268103+amirhhashemi@users.noreply.github.com>

Author: LadyBluenotes

src/routes/getting-started/quick-start.mdx

@@ -6,7 +6,7 @@ order: 1
 The fastest way to try Solid is to create a new project and run it locally.
 In just a few minutes, you’ll have a working Solid app running in your browser.
 
-## Solid in your Browser
+## Solid in Your Browser
 
 If you're looking to experiment with Solid without setting up a local environment, open the [Solid Playground](https://playground.solidjs.com/) in your browser.
 
@@ -31,21 +31,23 @@ solid
 3. **Follow the CLI prompts** to select your project name, template (JavaScript or TypeScript), and other options.
 
 ```sh
-◆ Project Name
-|  <solid-project>
+◆  Project Name
+│  solid-project
 
-◆ Is this a SolidStart project?
-|  ● Yes / ○ No
+◆  What type of project would you like to create?
+│  ○ SolidStart
+│  ● SolidJS + Vite
+│  ○ Library
 
-◆ Which template would you like to use?
+◆  Use Typescript?
+│  ● Yes / ○ No
+
+◆  Which template would you like to use?
 │  ● ts
 │  ○ ts-vitest
 │  ○ ts-uvu
 │  ○ ts-unocss
 │  ○ ts-tailwindcss
-
-◆ Use TypeScript?
-│  ● Yes / ○ No
 ```
 
 4. **Follow the instructions to install the dependencies and start the development server:**

src/routes/getting-started/understanding-jsx.mdx

@@ -16,10 +16,10 @@ const element = <h1>I'm JSX!!</h1>
 
 Unlike some other frameworks, Solid compiles JSX directly to real DOM nodes.
 This means:
+
 - JSX expressions map closely to HTML.
 - You can use variables and functions inline using curly braces `{}`.
 - Only the parts of the DOM that depend on reactive state update.
-This avoids the whole component re-rendering, improving performance.
 
 ```tsx
 const component = () => {
@@ -105,6 +105,7 @@ const isActive = true;
 ```
 
 For more information on:
+
 - [Using Event Listeners](/components/how-to/event-listeners)
 - [Styling Components](/components/how-to/styling)
 
@@ -131,10 +132,12 @@ function Greeting(props) {
 ```
 
 The core concepts of JSX properties in Solid include:
-- **Static props**: Directly integrated into the HTML by cloning the template and using them as attributes.
-- **Dynamic props**: Rely on state, allowing content or properties to change in response to user interactions or other events.
+
+- **Static props:** Directly integrated into the HTML by cloning the template and using them as attributes.
+- **Dynamic props:** Rely on state, allowing content or properties to change in response to user interactions or other events.
 An example is changing the style of an element based on a signal (`value={value()}`).
-- **Data transfer**: Props can be used to fill components with data from resources, such as API responses or context providers.
+- **Data transfer:** Props can be used to fill components with data from resources, such as API responses or context providers.
+
 This allows for components to update reactively when the underlying data changes.
 
 :::note
@@ -144,6 +147,7 @@ When order matters, make sure to define expressions in the sequence the element
 :::
 
 ## Related Pages
+
 - [Using Event Listeners](/components/how-to/event-listeners)
 - [Styling Components](/components/how-to/styling)
 - [Passing Data with Props](/components/props)

src/routes/reactivity/basics.mdx

@@ -7,7 +7,8 @@ order: 1
 Reactivity is the foundation of Solid.  
 It’s the programming model where **changes in data automatically update the parts of your app that depend on it**.  
 
-Solid’s approach is **fine-grained**: instead of re-rendering entire components, only the exact parts of the DOM that depend on a value update. This makes applications efficient and responsive, even as they grow.
+Solid’s approach is **fine-grained**: only the exact parts of the DOM that depend on a value update.
+This makes applications efficient and responsive, even as they grow.
 
 ## Core Principles of Reactivity
 
@@ -18,6 +19,7 @@ Together, these create a system where updates are precise, automatic, and effici
 
 A **signal** is a reactive value container.
 They consist of 2 parts:
+
 - **Getter** → reads the current value.  
 - **Setter** → updates the value and notifies dependents.  
 
@@ -30,9 +32,9 @@ console.log(count()); // 1
 ```
 
 Signals can hold any type of value:
-- primitives (string, number, boolean)
-- objects and arrays
-- application state (user, theme, current page)
+
+- Primitives (string, number, boolean).
+- Objects and arrays.
 
 Learn more in the [Signals page](/reactivity/signals).
 
@@ -41,9 +43,10 @@ Learn more in the [Signals page](/reactivity/signals).
 If signals are the **source of truth**, subscribers are the **reactive consumers**.
 
 A subscriber is any function or construct that reads a signal inside a tracking scope and automatically re-runs whenever it changes.
-This is what makes Solid’s reactivity *fine-grained*: only the subscribers that depend on a signal update, not the entire component.
+This is what makes Solid’s reactivity *fine-grained*: only the subscribers that depend on a signal update.
 
 How subscribers work:
+
 1. **Observation** → subscriber runs and reads signals.
 2. **Dependency tracking** → those signals register the subscriber.
 3. **Response** → when a signal changes, the subscriber re-runs.
@@ -55,8 +58,9 @@ When a signal is read within a tracking scope, it registers the current subscrib
 Once that signal changes, it will notify the subscriber to re-run and update accordingly.
 
 Tracking scopes within Solid include:
-- Component render functions (JSX return values)
-- Reactive computations (e.g., `createMemo`)
+
+- Component render functions (JSX return values).
+- Reactive computations (e.g., `createMemo`).
 - Effects (e.g., `createEffect`)
 
 Example of a tracking vs non-tracking scope:
@@ -78,7 +82,7 @@ function Counter() {
 }
 ```
 
-Tracking scopes are what enable **precise DOM updates**: only parts of the UI that depend on signals re-run, not the entire component.
+Tracking scopes are what enable **precise DOM updates**: only parts of the UI that depend on signals re-run.
 You can learn more about [component lifecycles in the Intro to Components page](/components/intro).
 
 

src/routes/reactivity/signals.mdx

@@ -13,11 +13,9 @@ You can use signals for any kind of state:
 
 ## What is a Signal?
 
-A **signal** is a reactive value container.  
-- It holds a value.  
-- It provides a **getter** to read the value.  
-- It provides a **setter** to update the value.  
-- When the value changes, any reactive computations that depend on it are updated automatically.  
+A **signal** is a reactive value container. 
+It holds a value and provides a **getter** to read the value and a **setter** to update it.
+When the value changes, it automatically triggers updates in any dependent computations.
 
 They can be thought of as a **reactive variable**.
 
@@ -73,4 +71,3 @@ function Counter() {
 }
 ```
 
-:::