Refactor documentation for Zephyr Workbench, enhancing clarity and consistency across installation, development, and debugging sections.

Author: madeline-underwood

content/learning-paths/embedded-and-microcontrollers/zephyr_vsworkbench/1_installation.md

@@ -10,13 +10,13 @@ layout: learningpathall
 
 Setting up a [Zephyr](https://zephyrproject.org/) RTOS development environment from scratch can be challenging, requiring you to manually install SDKs, configure toolchains, and initialize workspace directories. These steps often vary across operating systems and board vendors, leading to a fragmented and error-prone setup process.
 
-[Workbench for Zephyr](https://zephyr-workbench.com/) is an open-source Visual Studio Code [extension](https://marketplace.visualstudio.com/items?itemName=Ac6.zephyr-workbench) that transforms Zephyr RTOS development into a streamlined IDE experience. Created by [Ac6](https://www.ac6.fr/en/), it automates toolchain setup, project management, and debugging, making Zephyr projects faster to start and easier to scale.
+[Workbench for Zephyr](https://zephyr-workbench.com/) is an open-source [Visual Studio Code extension](https://marketplace.visualstudio.com/items?itemName=Ac6.zephyr-workbench) that transforms Zephyr RTOS development into a streamlined IDE experience. Created by [Ac6](https://www.ac6.fr/en/), it automates toolchain setup, project management, and debugging, making Zephyr projects faster to start and easier to scale.
 
-In this Learning Path, you'll learn the essential steps to install Workbench for Zephyr and configure a complete development environment on your local machine. Once complete, you'll be ready to create, build, and debug applications for Arm Cortex-M platforms using Zephyr RTOS.
+In this Learning Path, you'll follow clear steps to install Workbench for Zephyr and set up a full development environment on your computer. By the end, you'll be able to create, build, and debug applications for Arm Cortex-M boards using Zephyr RTOS.
 
-Workbench for Zephyr provides one-click environment setup that automatically installs the required tools including Python, CMake, Ninja, and Git. It supports importing and managing Zephyr SDKs with version and architecture selection, while initializing west workspaces and creating board-specific applications from samples. The extension builds Zephyr applications and flashes hardware directly from the VS Code interface. It also provides breakpoint debugging and memory usage insights with hardware probe support.
+Workbench for Zephyr makes it easy to set up your development environment with a single click. It automatically installs all the tools you need, such as Python, CMake, Ninja, and Git. You can import and manage different versions of the Zephyr SDK, choose the right architecture, and quickly initialize west workspaces. The extension lets you create board-specific applications from sample projects, build and flash them to your hardware, and debug your code, all within Visual Studio Code. You also get features like breakpoint debugging and memory usage insights when using a supported hardware probe.
 
-## What you need before installing Workbench for Zephyr
+## Install dependencies 
 
 To get started with Workbench for Zephyr you need to have Visual Studio Code downloaded, installed, and running on your computer.
 
@@ -32,7 +32,7 @@ On MacOS, the Homebrew package manager is required. To install Homebrew, run the
 
 **Linux:**
 - A recent 64-bit X64 distribution such as Ubuntu 20.04 or later, Fedora, Clear Linux OS, or Arch Linux
-- Other distributions might work, but may require manual configuration of system packages
+- Other distributions might work, but might require manual configuration of system packages
 - After installation, use the Workbench host tools manager to verify that all required tools were installed correctly
 
 
@@ -42,57 +42,61 @@ Zephyr Workbench supports STM32 development boards (STM32 Discovery, Nucleo seri
 
 This section covers installing the Zephyr Workbench extension and configuring your Arm development environment.
 
-### Install the extension
+### Install the Workbench for Zephyr extension
 
-To install the Workbench for Zephyr extension, open Visual Studio Code and navigate to the Extensions view by selecting the Extensions icon in the Activity Bar. 
+To install the Workbench for Zephyr extension, open Visual Studio Code. In the Activity Bar, select the **Extensions** icon to open the Extensions view.
 
-You can also use the keyboard shortcut `Ctrl+Shift+X` (Windows/Linux) or `Cmd+Shift+X` (macOS).
+You can also use the keyboard shortcut `Ctrl+Shift+X` on Windows or Linux, or `Cmd+Shift+X` on macOS.
 
-In the search box, type "Workbench for Zephyr" and locate the official "Workbench for Workbench" extension by Ac6. Select **Install** to add the extension to VS Code.
+In the search box, enter **Workbench for Zephyr**. Locate the official extension by Ac6 and select **Install**.
 
-The extension icon appears in the Activity Bar, and a welcome message may appear confirming successful installation.
-
-Once installed, the Workbench for Zephyr icon appears in the sidebar with a welcome screen.
+After installation, the Workbench for Zephyr icon appears in the Activity Bar. A welcome screen confirms that the extension is ready to use.
 
 ### Install the required host tools
 
 In the Workbench for Zephyr panel, select **Install Host Tools** to automatically install the required dependencies. 
 
 This process installs Python 3.x, CMake, the Ninja build system, Git, Device Tree Compiler (DTC), and the West meta-tool.
 
-![Install Host Tools #center](images/install_host_tools.png)
+![Workbench for Zephyr extension panel in Visual Studio Code showing the Install Host Tools button highlighted. The panel lists required tools such as Python, CMake, Ninja, Git, and Device Tree Compiler. The environment is a modern code editor interface with a sidebar and clear labels. The tone is instructional and welcoming. Visible text includes Install Host Tools and a checklist of dependencies to be installed. alt-text#center](images/install_host_tools.png "Workbench for Zephyr extension panel")
 
 {{% notice Note %}}
-On Windows, you may be prompted for permission when tools are executed. Select "Allow" when requested.
-{{% /notice %}}
+On Windows, you might see permission prompts when Workbench for Zephyr installs or runs tools. Select **Allow** to continue with the setup.
+
+When the installation completes, select **Verify Host Tools** to confirm that each required package is installed and up to date. The panel displays the version and status for Python, CMake, Ninja, Git, and Device Tree Compiler. If any tool is missing or out of date, follow the prompts to resolve the issue before continuing.
+### Import and configure the Zephyr toolchain
+
+To build and debug Zephyr applications for Arm Cortex-M boards, you need to import and configure the Zephyr toolchain using Workbench for Zephyr.
 
-When the installation completes, select **Verify Host Tools** to check the version of each installed package.
+In the Workbench for Zephyr panel, select **Import Toolchain**. This opens a guided setup panel.
 
-### Import and configure the toolchain
+- For **Toolchain Family**, select *Zephyr SDK*.
+- For **SDK Type**, choose *Minimal* to install only the essential components.
+- For **Version**, pick the Zephyr SDK release you want to use, such as v0.17.0 or v0.17.3.
+- For **Target Architectures**, select *arm* to target Arm-based boards.
 
-Next, download and configure the toolchain by selecting **Import Toolchain** in the Workbench for Zephyr panel. Select the toolchain family (*Zephyr SDK*) and configure the SDK Type by choosing *Minimal* for basic functionality.
+Next, specify the directory where you want to install the SDK. Select **Import** to start the download and installation process. When the import completes, the panel displays a confirmation that the toolchain is ready.
 
-Select your desired version (such as v0.17.0 or v0.17.3) and choose the target architectures. For this Learning Path, you only need to select *arm*. 
+If you see errors during import, check your internet connection and confirm you have at least 2 GB of free disk space. For more troubleshooting tips, review the extension's documentation or check the Visual Studio Code output panel.
 
-Specify the parent directory for SDK installation and select **Import** to download and install the SDK.
 
-![Import Toolchain #center](images/import_toolchain.png)
+![Workbench for Zephyr Import Toolchain panel in Visual Studio Code. The panel displays options for selecting the toolchain family, SDK type, version, and target architectures. Visible text includes Import Toolchain, Zephyr SDK, Minimal, v0.17.0, v0.17.3, and arm. The interface is organized and user-friendly, with clearly labeled dropdown menus and buttons. The overall tone is instructional and welcoming, set within a modern code editor workspace.](images/import_toolchain.png "Workbench for Zephyr Import Toolchain panel")
 
 
 ### Initialize the Zephyr project workspace
 
 Zephyr uses a Git-based workspace manager called West to organize its source code, modules, and samples. Use Workbench for Zephyr to initialize your first West workspace.
 
-In the Workbench for Zephyr panel, select **Initialize Workspace** to set up your project environment. Configure the workspace settings by selecting "Minimal from template" for the source location and using the default path `https://github.com/zephyrproject-rtos/zephyr`. 
+In the Workbench for Zephyr panel, select **Initialize Workspace** to set up your project environment. Configure the workspace settings by selecting **Minimal from template** for the source location and using the default path `https://github.com/zephyrproject-rtos/zephyr`. 
 
 Choose a target-specific template (such as STM32 or NXP) and select your Zephyr version (such as v3.7.0 or v4.1.0). Specify the directory for your workspace, keeping in mind that initialization takes approximately 10 minutes to complete. 
 
 Select **Import** to create and update the workspace.
 
-![Initialize West Workspace #center](images/initialize_workspace.png)
+![Workbench for Zephyr Initialize Workspace panel in Visual Studio Code. The panel displays options for setting up a new West workspace, including fields for source location, template selection, Zephyr version, and workspace directory. Visible text includes Initialize Workspace, Minimal from template, https://github.com/zephyrproject-rtos/zephyr, STM32, NXP, v3.7.0, v4.1.0, and Import. The interface is organized and user-friendly, with dropdown menus and buttons clearly labeled. The overall tone is instructional and welcoming, set within a modern code editor workspace. alt-text#center](images/initialize_workspace.png "Workbench for Zephyr Initialize Workspace panel in Visual Studio Code.")
 
 {{% notice Note %}}
-The workspace initialization downloads the Zephyr source code and dependencies. This process may take several minutes depending on your internet connection speed.
+The workspace initialization downloads the Zephyr source code and dependencies. This process can take several minutes depending on your internet connection speed.
 {{% /notice %}}
 
 ### Verify setup

content/learning-paths/embedded-and-microcontrollers/zephyr_vsworkbench/2_development.md

@@ -26,15 +26,15 @@ In the Zephyr Workbench panel:
    - Select a sample app (for example, `hello_world`)
    - Provide a project name
 
-![Create App](images/create_app.png)
+![Zephyr Workbench Create New Application panel in VS Code showing workspace selection SDK version target board dropdown sample application selection and project name fields. The interface is clean and organized with clear labels and buttons. The wider VS Code environment is visible in the background with a neutral and professional tone. All text in the panel is legible and guides the user through creating a new Zephyr application.](images/create_app.png "Zephyr Workbench Create New Application panel")
 
 ### Build the application
 
 Select the **Build** button in Workbench for Zephyr or press `Ctrl+Shift+B`.
 
 The build system compiles your application and links it against the Zephyr kernel and board-specific drivers.
 
-![Build Application](images/build_application.png)
+![VS Code Zephyr Workbench build application panel showing workspace selection, SDK version, target board dropdown, sample application selection, and project name fields. The primary subject is the Zephyr Workbench interface guiding users through building a Zephyr application. Visible text includes labels such as Workspace, SDK, Target Board, Sample Application, and Project Name, with buttons for Create New Application and Build. The wider VS Code environment is visible in the background, presenting a clean and organized workspace with a neutral, professional tone. alt-text#center]
 
 ### Install board-specific debug utilities
 
@@ -83,4 +83,4 @@ int main(void)
 
 Now that the app works, try editing the message in `printk()` or changing the board target in the application settings. Then rebuild and observe the output. This helps verify that your toolchain and workspace respond correctly to code and config changes.
 
-With your first Zephyr application successfully built, you're ready to take the next step—debugging. In the next module, you'll launch a debug session, set breakpoints, and perform memory analysis using Workbench for Zephyr. These skills help you validate and optimize applications running on real Arm Cortex-M hardware.
+With your first Zephyr application successfully built, you're ready to take the next step, which is debugging. In the next module, you'll launch a debug session, set breakpoints, and perform memory analysis using Workbench for Zephyr. These skills help you validate and optimize applications running on real Arm Cortex-M hardware.

content/learning-paths/embedded-and-microcontrollers/zephyr_vsworkbench/3_debug.md

@@ -8,26 +8,28 @@ layout: learningpathall
 
 ## Analyze and debug Zephyr applications in VS Code
 
-In this module, you'll learn how to inspect memory usage and perform live debugging on your Zephyr applications using Workbench for Zephyr. These capabilities are essential for diagnosing bugs and optimizing embedded firmware performance on Arm Cortex-M platforms.
+In this section, you'll learn how to inspect memory usage and perform live debugging on your Zephyr applications using Workbench for Zephyr. These capabilities are essential for diagnosing bugs and optimizing embedded firmware performance on Arm Cortex-M platforms.
 
 ## Analyze memory usage
 
 Understanding how your application uses memory is crucial for optimizing embedded firmware on resource-constrained Arm Cortex-M systems. Workbench for Zephyr provides built-in tools to generate detailed memory usage reports after a successful build, helping you identify ROM and RAM consumption hotspots early in development.
 
 ### Generate memory reports
 
-After building your Zephyr application, analyze how memory is allocated and used. Workbench for Zephyr offers built-in memory reporting tools that help you visualize RAM and ROM usage, identify inefficient memory patterns, and guide optimization efforts. These insights are especially useful when working with constrained Arm Cortex-M platforms.
+After building your Zephyr application, you can analyze how memory is allocated and used. Workbench for Zephyr offers built-in memory reporting tools that help you visualize RAM and ROM usage, identify inefficient memory patterns, and guide optimization efforts. These insights are especially useful when working with constrained Arm Cortex-M platforms.
 
-To generate memory reports, open the **Zephyr Workbench** panel and select **Memory Analysis** after a successful build. The tool generates detailed reports showing RAM usage (stack, heap, static variables), ROM usage (code size, constants), and **Puncover** analysis for binary analysis including function size, call graphs, and timing on Arm Cortex-M processors.
+To generate memory reports, open the **Workbench for Zephyr** panel and select **Memory Analysis** after building your application. This tool provides detailed insights into RAM usage (including stack, heap, and static variables), ROM usage (such as code size and constants), and integrates **Puncover** for advanced binary analysis. With Puncover, you can visualize function sizes, call graphs, and timing information specific to Arm Cortex-M processors.
 
-The following steps show how to generate and review memory reports:
+Follow these steps to generate and review memory reports:
 
-- Open the **Workbench for Zephyr** panel
-- Select **Memory Analysis** after a successful build
-- Review detailed memory reports:
-  - **RAM usage**: stack, heap, static variables
-  - **ROM usage**: code size, constants
-  - **Puncover**: binary analysis for function size, call graphs, and timing on Arm Cortex-M
+1. Open the **Workbench for Zephyr** panel.
+2. Select **Memory Analysis** after a successful build.
+3. Review the generated reports:
+  - **RAM usage**: View stack, heap, and static variable allocation.
+  - **ROM usage**: Examine code size and constant data.
+  - **Puncover analysis**: Explore function sizes, call graphs, and timing metrics for your Arm Cortex-M application.
+
+These insights help you identify memory bottlenecks and optimize your embedded firmware for Arm platforms.
 
 ![Memory Analysis](images/memory_analysis.png)
 
@@ -189,7 +191,7 @@ The ELF executable path is auto-filled after build. You can optionally add a **C
 ### Debug server
 Choose the runner from OpenOCD, J-Link, LinkServer, or PyOCD. If the system doesn't detect your runner automatically, enter the runner path manually. Select **Apply** to save your settings or launch debug directly.
 
-![Debug Manager](images/debug_manager.png)
+![Debug Manager panel in Workbench for Zephyr showing a list of connected debug runners and configuration options. The interface displays fields for selecting the runner executable path, board profile, and status indicators for each tool. The environment is a VS Code window with the Zephyr Workbench sidebar open. The tone is technical and neutral. Visible text includes Debug Manager, Runner Path, Board Profile, and status labels for detected runners.](images/debug_manager.png "Debug Manager panel in Workbench for Zephyr")
 
 ### Manual debug runner configuration
 
@@ -203,7 +205,7 @@ Manual configuration might be required on first-time setups or if using custom r
 
 You can start debugging from Workbench for Zephyr by selecting **Debug**, or from VS Code by going to **Run and Debug** (`Ctrl+Shift+D`), selecting the debug config, and selecting **Run**.
 
-![Debug Application](images/debug_app.png)
+![VS Code window displaying the Zephyr Workbench Debug Application panel. The main subject is the debug interface showing active debugging controls, breakpoints, and variable watch windows. The environment is a technical workspace with the Zephyr Workbench sidebar open in Visual Studio Code. Visible text includes Debug Application, Breakpoints, Variables, and Call Stack. The tone is neutral and focused on software development tasks.](images/debug_app.png "VS Code window displaying the Zephyr Workbench Debug Application panel.")
 
 ### Debug toolbar controls
 

content/learning-paths/embedded-and-microcontrollers/zephyr_vsworkbench/_index.md

@@ -1,10 +1,6 @@
 ---
 title: Build Zephyr projects with Workbench for Zephyr in VS Code
 
-draft: true
-cascade:
-    draft: true
-
 minutes_to_complete: 30
 
 who_is_this_for: This is an introductory topic for embedded developers targeting Arm-based platforms with the Zephyr RTOS using the Workbench for Zephyr extension for VS Code.
@@ -18,7 +14,7 @@ learning_objectives:
 
 prerequisites:
     - Basic familiarity with embedded C programming
-    - Visual Studio Code installed and running
+    - Visual Studio Code
     - A Cortex-M development board
     - Windows 10+ (64-bit), macOS with Homebrew, or Linux (preferably Ubuntu 20.04+)