diff --git a/_google/googlepixel3a.markdown b/_google/googlepixel3a.markdown
index 93ab8b9..7177b33 100644
--- a/_google/googlepixel3a.markdown
+++ b/_google/googlepixel3a.markdown
@@ -4,29 +4,37 @@
 codename: sargo
 downloadfolder: sargo
 supportstatus: Current
-maintainer: ZVNexus
+maintainer: Captain_Throwback
 oem: Google
 devicetree: https://github.com/TeamWin/android_device_google_bonito
+<p class="text"><a href="https://twrp.zulipchat.com/#narrow/stream/290973-support-device/topic/Pixel.203a.20.28sargo.29.2FPixel.203a.20XL.20.28bonito.29">Support topic on Zulip</a></p>
 ---
 
 {% include disclaimer.html %}
 
 {% include supportstatus.html %}
-Please note that you cannot install this on stock, unless you are running a kernel that supports LZMA compression.
 
 {% include download.html %}
 
+{% include dynamicpartitions.html %}
+
 <div class='page-heading'>Installation:</div>
-If you already have TWRP installed:
-Download the latest zip and install the zip using TWRP.
+WARNING: If you accidently flash TWRP to your device using fastboot instead of temporarily booting the image, you will need to download the latest factory image for your device and reflash the boot image.
 
-If you do not already have TWRP installed:
-Download both the img and the zip. You will need to have fastboot binaries and the correct drivers installed. Power off your device completely. Hold volume down and turn on the device. Your device should now be in the bootloader. Connect the device to your PC. Open a command window and run the following command from the proper location:
+<p class="text"><a href="https://developer.android.com/studio/releases/platform-tools">You will need the platform-tools from the Android SDK on your computer.</a> Download the platform-tools as per your operating system.</p>
 
-fastboot boot path/to/twrp.img
+Windows users will need proper drivers installed on their computer. You can try the <a href="https://forum.xda-developers.com/android/software-hacking/live-iso-adb-fastboot-driver-issues-t3526755" target=_blank>simple FWUL adb/fastboot ISO</a> or the <a href="http://www.xda-developers.com/universal-naked-driver-solves-your-adb-driver-problems-on-windows/">Naked ADB drivers</a> or the <a href="https://adb.clockworkmod.com/">Universal ADB drivers</a> if you don't already have a working driver installed
 
-This will temporarily boot TWRP on your device. Use ADB or MTP to transfer the zip onto your device.
+Download the correct image file and copy the file into the same folder as your platform-tools as well as device's storage. Rename the image to twrp.img.
 
-Go to install and browse to the zip and install the zip. The zip will install TWRP to both boot slots. Installing TWRP at this time will remove root if you are currently rooted.
+Now reboot to fastboot/download/bootloader mode by using adb or manual key combos (Use Google to find that if you are not sure). To use adb to reboot, use the following command:
 
-If you accidently flash TWRP to your device using fastboot instead of temporarily booting the image, you will need to download the latest factory image for your device and reflash the boot image.
+<code>adb reboot bootloader</code>
+
+Temporary boot the downloaded image using the following command:
+
+<code>fastboot boot twrp.img</code>
+
+Once booted, navigate to the Advanced > Flash Current TWRP option. This will install the TWRP image you just booted permanently to the device.
+
+After this is done, you have successfully installed TWRP on your device.
\ No newline at end of file
diff --git a/_google/googlepixel3axl.markdown b/_google/googlepixel3axl.markdown
index bed3218..3789697 100644
--- a/_google/googlepixel3axl.markdown
+++ b/_google/googlepixel3axl.markdown
@@ -4,29 +4,37 @@
 codename: bonito
 downloadfolder: bonito
 supportstatus: Current
-maintainer: ZVNexus
+maintainer: Captain_Throwback
 oem: Google
 devicetree: https://github.com/TeamWin/android_device_google_bonito
+<p class="text"><a href="https://twrp.zulipchat.com/#narrow/stream/290973-support-device/topic/Pixel.203a.20.28sargo.29.2FPixel.203a.20XL.20.28bonito.29">Support topic on Zulip</a></p>
 ---
 
 {% include disclaimer.html %}
 
 {% include supportstatus.html %}
-Please note that you cannot install this on stock, unless you are running a kernel that supports LZMA compression.
 
 {% include download.html %}
 
+{% include dynamicpartitions.html %}
+
 <div class='page-heading'>Installation:</div>
-If you already have TWRP installed:
-Download the latest zip and install the zip using TWRP.
+WARNING: If you accidently flash TWRP to your device using fastboot instead of temporarily booting the image, you will need to download the latest factory image for your device and reflash the boot image.
 
-If you do not already have TWRP installed:
-Download both the img and the zip. You will need to have fastboot binaries and the correct drivers installed. Power off your device completely. Hold volume down and turn on the device. Your device should now be in the bootloader. Connect the device to your PC. Open a command window and run the following command from the proper location:
+<p class="text"><a href="https://developer.android.com/studio/releases/platform-tools">You will need the platform-tools from the Android SDK on your computer.</a> Download the platform-tools as per your operating system.</p>
 
-fastboot boot path/to/twrp.img
+Windows users will need proper drivers installed on their computer. You can try the <a href="https://forum.xda-developers.com/android/software-hacking/live-iso-adb-fastboot-driver-issues-t3526755" target=_blank>simple FWUL adb/fastboot ISO</a> or the <a href="http://www.xda-developers.com/universal-naked-driver-solves-your-adb-driver-problems-on-windows/">Naked ADB drivers</a> or the <a href="https://adb.clockworkmod.com/">Universal ADB drivers</a> if you don't already have a working driver installed
 
-This will temporarily boot TWRP on your device. Use ADB or MTP to push the zip to your device.
+Download the correct image file and copy the file into the same folder as your platform-tools as well as device's storage. Rename the image to twrp.img.
 
-Go to install and browse to the zip and install the zip. The zip will install TWRP to both boot slots. Installing TWRP at this time will remove root if you are currently rooted.
+Now reboot to fastboot/download/bootloader mode by using adb or manual key combos (Use Google to find that if you are not sure). To use adb to reboot, use the following command:
 
-If you accidently flash TWRP to your device using fastboot instead of temporarily booting the image, you will need to download the latest factory image for your device and reflash the boot image.
+<code>adb reboot bootloader</code>
+
+Temporary boot the downloaded image using the following command:
+
+<code>fastboot boot twrp.img</code>
+
+Once booted, navigate to the Advanced > Flash Current TWRP option. This will install the TWRP image you just booted permanently to the device.
+
+After this is done, you have successfully installed TWRP on your device.
\ No newline at end of file
