Tweaks to skills + refactored Arm Performance Studio LP

.github/skills/frontmatter-audit/SKILL.md

@@ -25,13 +25,14 @@ For a Learning Path directory:
 - Public pages should have unique `weight` values within the directory.
 - Every page except for `_next-steps.md` must include a description.
 - `_index.md` must include `description`.
-- Required `_index.md` fields include `title`, `description`, `weight`, `layout`, `minutes_to_complete`, `prerequisites`, `author`, `subjects`, `armips`, `tools_software_languages`, `skilllevels`, and `operatingsystems`.
+- Required `_index.md` fields include `title`, `description`, `weight`, `layout`, `minutes_to_complete`, `prerequisites`, `author`, `generate_summary_faq`, `rerun_summary`, `rerun_faqs`, `subjects`, `armips`, `tools_software_languages`, `skilllevels`, and `operatingsystems`.
 - `layout` is usually `learningpathall`.
 - `title` should be task-led and use an imperative structure: verb + technology/tool + outcome.
 - `skilllevels` values are only `Introductory` or `Advanced`.
 - `subjects` and `operatingsystems` must match the closed lists in `content/learning-paths/cross-platform/_example-learning-path/write-2-metadata/`.
 - `armips` should use Arm IP families such as Neoverse, Cortex-A, or Cortex-M, not specific CPU models or Arm architecture versions.
 - `author` can list multiple authors with YAML list syntax.
+- `generate_summary_faq`, `rerun_summary`, and `rerun_faqs` values are only `true` and `false`.
 - Skip `_next-steps.md` for description updates unless the user explicitly asks how to handle it.
 
 ## Install guide checks

.github/skills/writing-style-review/SKILL.md

@@ -18,8 +18,8 @@ Use this skill for granular prose, voice, readability, terminology, and style re
 
 ## Voice and tone
 
-- Use second person: `you` and `your`.
-- Avoid first person: `I` and `we`.
+- Use second person: `you` and `your` for Learning Path summaries, Learning Path content, install guide content, answers to FAQs, and metadata descriptions. Avoid first person for these content types.
+- Use first person: `I` and `we` for FAQs.
 - Use active voice.
 - Use present tense for descriptions.
 - Use imperative mood for commands.
@@ -40,6 +40,7 @@ Use this skill for granular prose, voice, readability, terminology, and style re
 - Use plain English and avoid jargon overload.
 - Define acronyms on first use.
 - Use parallel structure in lists.
+- Avoid starting sentences with "In this Learning Path"/ "In this section"/"On this page" / "In this step".
 - Flag sections over 700 words and suggest natural split points.
 - Identify paragraphs with sentences averaging over 20 words.
 - Note sections that introduce more than two new concepts.
@@ -74,7 +75,7 @@ Use this skill for granular prose, voice, readability, terminology, and style re
 - Use `set up` as a verb and `setup` as a noun.
 - Use `avoid` instead of `try not to`.
 - Use `such as` instead of `like`.
-- Use `after` instead of `once`.
+- Use `after` or `when` instead of `once`.
 
 ## Tone cleanup
 
@@ -111,7 +112,7 @@ Use this skill for granular prose, voice, readability, terminology, and style re
 - Use `arm64` or `aarch64` for CPU architecture based on tool, package, or OS convention.
 - Use `ARM64` only when referring to Windows on Arm or Microsoft documentation.
 - Capitalize `Learning Path`.
-- Use `Azure Cobalt`, `Google Axion`, and `AWS Graviton` as processor names, not VM names.
+- Use `Azure Cobalt`, `Google Axion`, and `AWS Graviton` as processor names, not VM names. `Graviton-based instances`, not `Graviton instances`, for example.
 - Do not use bold or italics for product names such as LiteRT, XNNPACK, KleidiAI, and SME2 unless they are headings or UI labels.
 
 ## Avoid AI-sounding prose

content/learning-paths/mobile-graphics-and-gaming/ams/_index.md

@@ -1,28 +1,77 @@
 ---
-title: Get started with Arm Performance Studio
+title: Profile an Android application with Arm Performance Studio
 
-description: Learn how to use each of the tools supplied with Arm Performance Studio (formerly known as Arm Mobile Studio).
+description: Profile a debuggable Android graphics application with Arm Performance Studio and analyze performance with Streamline, Performance Advisor, Frame Advisor, RenderDoc for Arm GPUs, and Mali Offline Compiler.
 
 minutes_to_complete: 60
 
-who_is_this_for: Android application and games developers new to Arm Performance Studio.
+who_is_this_for: This is an introductory topic for Android application and games developers new to Arm Performance Studio.
 
 learning_objectives:
-    - Learn the basic features of each component of Arm Performance Studio. 
-    - Get started profiling and optimizing your application.
+    - Capture a Streamline profile from a debuggable Android application
+    - Generate and inspect a Performance Advisor report
+    - Capture and analyze a frame with Frame Advisor and RenderDoc for Arm GPUs
+    - Use Mali Offline Compiler to estimate shader cost
 
 prerequisites:
     - An Android device.
-    - Arm Performance Studio supports applications built with OpenGL ES versions 2.0 to 3.2, or Vulkan versions 1.0 to 1.2.
+    - An debuggable build of your application built with OpenGL ES versions 2.0 to 3.2, or Vulkan versions 1.0 to 1.2.
     - For OpenGL ES applications, your device must be running Android 10 or later.
     - For Vulkan applications, your device must be running Android 9 or later.
-    - A debuggable build of your application. 
     - Arm Performance Studio installed. Follow the [Arm Performance Studio install guide](/install-guides/ams/) for instructions.
-    - Android SDK Platform tools installed. Required for the Android Debug bridge (adb).
+    - Android SDK Platform tools installed for the Android Debug bridge (adb).
+
+# START generated_summary_faq
+generated_summary_faq:
+  template_version: summary-faq-v3
+  generated_at: '2026-06-26T16:37:19Z'
+  generator: ai
+  ai_assisted: true
+  ai_review_required: true
+  model: gpt-5
+  prompt_template: summary-faq-v3
+  source_hash: 80078c6f05717cbf24c3b695a82fa15bbe477bd14a290195569dda4efe6599ee
+  summary_generated_at: '2026-06-26T16:37:19Z'
+  summary_source_hash: 80078c6f05717cbf24c3b695a82fa15bbe477bd14a290195569dda4efe6599ee
+  faq_generated_at: '2026-06-26T16:37:19Z'
+  faq_source_hash: 80078c6f05717cbf24c3b695a82fa15bbe477bd14a290195569dda4efe6599ee
+  summary: >-
+    You'll profile an Android graphics application on Arm
+    Mali-based GPUs using Arm Performance Studio. After preparing a debuggable build, you'll
+    connect an Android device over adb, explore a provided Streamline sample to understand the
+    available views, then capture a profile from your own application and generate a Performance
+    Advisor report with the CLI. You'll also perform frame-level inspection with Frame Advisor
+    and RenderDoc for Arm GPUs, and use Mali Offline Compiler to estimate shader
+    cost. By the end, you'll understand how to progress from example data to capturing on-device
+    profiles and interpreting reports that inform deeper frame and shader analysis.
+  faqs:
+  - question: How do I launch Streamline and select my Android device?
+    answer: >-
+      Open the Performance Studio Hub and launch Streamline. In the Start view, choose Android
+      (adb) as the device type and select your device from the list.
+  - question: What should I check in my app build before profiling with Streamline?
+    answer: >-
+      Build a debuggable version and include options that facilitate call stack unwinding by Streamline.
+      For Unity, enable Development Build in Build settings.
+  - question: What steps import the example Streamline capture?
+    answer: >-
+      In Streamline, select File > Import, choose Import Streamline Sample Captures, then select
+      the Android example and finish. The sample capture is added so you can open it and explore
+      the views.
+  - question: How do I generate a Performance Advisor report from a capture?
+    answer: >-
+      Open a terminal, navigate to the capture location, and run streamline-cli with the -pa option
+      on the .apc file (for example, "Android - GPU Bound Example.apc"). The capture is processed
+      and a Performance Advisor report is produced.
+  - question: Do I need Python for Performance Advisor?
+    answer: >-
+      Yes. Performance Advisor uses a Python script to connect to your device and requires Python
+      3.8 or later.
+# END generated_summary_faq
 
 author: Ronan Synnott
 
-generate_summary_faq: true
+generate_summary_faq: false
 rerun_summary: false
 rerun_faqs: false
 

content/learning-paths/mobile-graphics-and-gaming/ams/ams.md

@@ -1,32 +1,53 @@
 ---
 # User change
-title: "What is Arm Performance Studio?"
+title: Set up Arm Performance Studio 
+
+description: Install and launch Arm Performance Studio, update your PATH, and confirm the profiling tools are available for the Android application workflow.
 
 weight: 2 # 1 is first, 2 is second, etc.
 
 # Do not modify these elements
 layout: "learningpathall"
 ---
-[Arm Performance Studio](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio) is a performance analysis tool suite for developers to performance test their applications on devices with Mali-based GPUs. It consists of 4 easy-to-use tools that show you how well your application performs either on off-the-shelf Android devices, or Linux targets. The tools help you to identify problems that might slow down performance, overheat the device, or drain the battery.
+## What is Arm Performance Studio?
+
+[Arm Performance Studio](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio) is a performance analysis tool suite that you can use to performance test applications on devices with Mali-based GPUs. 
+
+Performance Studio consists of four tools that show you how well your application performs either on off-the-shelf Android devices, or Linux targets. You can use the tools to identify problems that might slow down performance, overheat the device, or drain the battery.
 
 | Component | Functionality |
 |----------|-------------|
-| [Streamline](https://developer.arm.com/Tools%20and%20Software/Streamline%20Performance%20Analyzer) with [Performance Advisor](https://developer.arm.com/Tools%20and%20Software/Performance%20Advisor) | Capture a performance profile that shows all the performance counter activity from the device. Generate an easy-to-read performance summary from an annotated Streamline capture, and get actionable advice about where you should optimize. |
+| [Streamline](https://developer.arm.com/Tools%20and%20Software/Streamline%20Performance%20Analyzer) with [Performance Advisor](https://developer.arm.com/Tools%20and%20Software/Performance%20Advisor) | Capture a performance profile that shows all the performance counter activity from the device. Generate a performance summary from an annotated Streamline capture, and get actionable advice about where you should optimize. |
 | [Frame Advisor](https://developer.arm.com/Tools%20and%20Software/Frame%20Advisor) | Capture the API calls and rendering from a problem frame and get comprehensive geometry metrics to discover what might be slowing down your application. |
 | [Mali Offline Compiler](https://developer.arm.com/Tools%20and%20Software/Mali%20Offline%20Compiler) | Analyze how efficiently your shader programs perform on a range of Mali GPUs. |
 | [RenderDoc for Arm GPUs](https://developer.arm.com/Tools%20and%20Software/RenderDoc%20for%20Arm%20GPUs) | The industry-standard tool for debugging Vulkan graphics applications, including early support for Arm GPU extensions and Android features. |
 
-## Download and Install Arm Performance Studio
+## Download and install Arm Performance Studio
+
+Arm Performance Studio is supported on Windows, Linux, and macOS hosts. To download Arm Performance Studio, see the [Arm Performance Studio downloads page](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio#Downloads).
+
+For installation instructions, see the [Arm Performance Studio install guide](/install-guides/ams/).
+
+## Update your PATH environment variable (Linux and macOS)
+
+Edit your `PATH` environment variable to add the paths to the Streamline and Mali Offline Compiler executables. By adding the paths, you can run Streamline's `Streamline-cli -pa` command and Mali Offline Compiler's `malioc` command from any directory. This step isn't necessary on Windows, as this is done automatically when Arm Performance Studio is installed.
+
+On macOS, edit your `/etc/paths` file to add the following paths:
 
-Arm Performance Studio is supported on Windows, Linux, and macOS hosts. Get the [Arm Performance Studio installation package](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio#Downloads).
+```
+/<installation_directory>/streamline
+/<installation_directory>/mali_offline_compiler
+```
 
-Refer to the [Arm Performance Studio install guide](/install-guides/ams/) for installation instructions.
+On Linux, edit your `PATH` environment variable to add the paths to the Performance Advisor executable. Add this command to the `.bashrc` file in your home directory, so that this environment variable is set whenever you initialize a shell session.
 
-## Launch the tools
+```
+ PATH=$PATH:/<installation_directory>/streamline
+ PATH=$PATH:/<installation_directory>/mali_offline_compiler
+```
 
-To open the tools, launch the Performance Studio Hub:
+## What you've accomplished and what's next
 
-- On Windows, search for Performance Studio.
-- On macOS and Linux, open the Performance Studio application file from the install directory.
+You've set up Arm Performance Studio and updated your `PATH` so you can use the profiling tools from a terminal.
 
-   ![Performance Studio Hub](images/ps_hub.png)
+Next, you'll set up the application that you'll profile in this Learning Path.