What I find exciting about software engineering is its potential to automate formerly tedious processes. For instance, realizing I could substitute a tiresome five-minute task with a quick shell command was a game-changer. This is precisely how Graphite enhanced my productivity by streamlining GitHub pull request creation.

Let’s delve into how optimizing the process of creating GitHub pull requests with Graphite has made it easier for reviewers.

What is Graphite?

Imagine an assistant that ensures your code writing is smoother, faster, and less prone to errors. That’s what Graphite is — a robust set of features designed specifically with the software engineer’s productivity in mind.

It’s a powerful alternative to GitHub’s native pull request management tool, packed with features designed to supercharge your productivity:

Graphite CLI — Streamline Git commands and stack pull requests

Graphite CLI helps simplify Git workflows by enabling developers to efficiently stack multiple pull requests (PRs) on top of each other. This approach allows for smaller, incremental code changes that are easier to review and merge, reducing bottlenecks in the development process.

Pull Request Inbox — Manage PRs and review requests in one unified inbox

A unified dashboard that helps developers stay on top of every PR and review request in one place. It provides a centralized view of pull requests, showing reviews, CI status, stack information, and more at a glance. With customizable filters, developers can sort PRs based on author, CI status, labels, and other criteria.

Graphite Reviewer — AI-powered code review feedback

An AI-powered code review tool that provides instant, actionable feedback on pull requests.

I found it incredibly efficient at catching small typos and subtle errors that can be surprisingly hard for a human reviewer to spot. It doesn’t replace a human reviewer, but it’s a powerful complement to your CI flow.

Merge Queue — Automate merges and prevent conflicts

It ensures that pull requests are merged in order, without conflicts. It keeps the main branch green, prevents merge bottlenecks, and optimizes CI time by skipping redundant tests.

Insights and Reports — Real-time developer productivity metrics

Track productivity and identify bottlenecks. Graphite helps teams make data-driven decisions by analyzing historical trends and engineering workflow efficiency.

Create a Pull Request in Just 30 Seconds

1. gt create --all --ai will create a new branch stacked on top of the current branch. The branch name and commit message are AI-generated based on your changes. No more context-switching or thinking up commit messages!
2. gt submit --ai will create a new pull request and generate a summary of all your changes, making it easier for reviewers to understand your work at a glance.
3. You will be redirected to the pull request, allowing you to fine-tune the AI-generated description before publishing.
4. Publish!

Must-Know Graphite Commands

gt sync – Keep Your Stack Up-to-Date, Effortlessly 🔄

✅ Auto-Fetch & Restack — Pulls the latest changes from main and restacks your branches automatically.
✅ Clean Up Merged PRs – Removes stale branches once PRs are merged.
✅ Conflict Prevention – Stay ahead of merge conflicts before they become a problem.

gt absorb – The Smartest Way to Keep Your Commits Clean ✨

Automatically amends staged changes to the most relevant commit in your stack — without manual rebasing

gt log – Instantly Visualize Your Stacked Branches 🔍

✅ See Your Stack at a Glance — No more guessing which branches are linked.
✅ Track Dependencies Easily — Know which PRs depend on others before merging.
✅ Debug Faster — Instantly spot misaligned branches or missing parents.

And many more in the Graphite CLI documentation!

Automating GitHub PRs Like a Pro with Graphite was originally published in Level Up Coding on Medium, where people are continuing the conversation by highlighting and responding to this story.

Recently, I worked on a side project where I needed to extract captions from YouTube videos. While there are plenty of tools available for this, I decided to create my own solution in Go. This was primarily for the sake of learning Go, and now, I’d like to share that experience with you.

YouTube API

My initial approach was to determine if extracting captions was feasible using the official YouTube API. I discovered an endpoint that seemed to allow downloading video captions, so I quickly developed a Go script with the official YouTube Go package to test it out.

This was my first mistake.

I should have spent more time reading the endpoint documentation because, even if this is not clearly mentionned, only the video owner can use this API, or the video must have third-party contributions enabled for captions.

But, not all my time was wasted. I also explored the playlist API, which will be useful to be able to download the captions for an entire playlist.

func downloadPlaylistCaptions(service *youtube.Service, playlistID string, nextPageToken string) error {
   part := []string{"snippet"}
   playlistItemsList := service.PlaylistItems.List(part).PlaylistId(playlistID)
  
   if nextPageToken != "" {
      playlistItemsList = playlistItemsList.PageToken(nextPageToken)
   }
  
   items, err := playlistItemsList.Do()
   if err != nil {
      return fmt.Errorf("unable to list playlist items: %w", err)
   }

   for _, item := range items.Items {
      // ...
   }

   if items.NextPageToken != "" {
      return downloadPlaylistCaptions(service, playlistID, items.NextPageToken)
   }
  
   return nil
}

Unofficial YouTube API

After researching other existing tools, I discovered a surprisingly simple method to download video captions.

All you need to do is open the YouTube video page, such as https://www.youtube.com/watch?v=mT0RNrTDHkI.

Then, open the browser console and enter:

ytInitialPlayerResponse.captions.playerCaptionsTracklistRenderer.captionTracks[0].baseUrl

This will give you a caption file URL.

Also note that the captionTracks array contains the captions for all the available languages.

Then we just need to write a simple script that queries the video page, extracts the necessary variable, and retrieves the base url and language code for each available caption. From there, we can download the caption that interests us.

package main

import (
 "encoding/json"
 "fmt"
 "io"
 "log"
 "net/http"
 "os"
 "path/filepath"
 "strings"
)

const baseURL = "https://www.youtube.com/watch?v="

type ytInitialPlayerResponse struct {
 Captions struct {
  PlayerCaptionsTracklistRenderer struct {
   CaptionTracks []struct {
    BaseUrl      string `json:"baseUrl"`
    LanguageCode string `json:"languageCode"`
   } `json:"captionTracks"`
  } `json:"playerCaptionsTracklistRenderer"`
 } `json:"captions"`
}

type Caption struct {
 BaseUrl      string
 LanguageCode string
}

func (c *Caption) Download(targetPath string) error {
 resp, err := http.Get(c.BaseUrl)
 if err != nil {
  return fmt.Errorf("unable to download caption: %w", err)
 }

 defer resp.Body.Close()

 file, err := os.Create(targetPath)
 if err != nil {
  return fmt.Errorf("unable to create file: %w", err)
 }

 defer file.Close()

 _, err = io.Copy(file, resp.Body)
 if err != nil {
  return fmt.Errorf("unable to write file: %w", err)
 }

 return nil
}

func listVideoCaptions(videoID string) ([]Caption, error) {
 resp, err := http.Get(baseURL + videoID)
 if err != nil {
  return nil, fmt.Errorf("unable to download video page: %w", err)
 }

 defer resp.Body.Close()

 content, err := io.ReadAll(resp.Body)
 if err != nil {
  return nil, fmt.Errorf("unable to read response body: %w", err)
 }

 pageContent := string(content)

 // Find ytInitialPlayerResponse variable
 pageContentSplited := strings.Split(pageContent, "ytInitialPlayerResponse = ")
 if len(pageContentSplited) < 2 {
  return nil, fmt.Errorf("unable to find ytInitialPlayerResponse variable")
 }

 // Find the end of the variable
 pageContentSplited = strings.Split(pageContentSplited[1], ";</script>")
 if len(pageContentSplited) < 2 {
  return nil, fmt.Errorf("unable to find the end of the ytInitialPlayerResponse variable")
 }

 ytInitialPlayerResponse := ytInitialPlayerResponse{}
 err = json.Unmarshal([]byte(pageContentSplited[0]), &ytInitialPlayerResponse)
 if err != nil {
  return nil, fmt.Errorf("unable to unmarshal ytInitialPlayerResponse: %w", err)
 }

 captions := make([]Caption, 0, len(ytInitialPlayerResponse.Captions.PlayerCaptionsTracklistRenderer.CaptionTracks))
 for _, caption := range ytInitialPlayerResponse.Captions.PlayerCaptionsTracklistRenderer.CaptionTracks {
  captions = append(captions, Caption{
   BaseUrl:      caption.BaseUrl,
   LanguageCode: caption.LanguageCode,
  })
 }

 return captions, nil
}

func main() {
 if len(os.Args) < 2 {
  log.Fatalf("usage: %s <videoID>", filepath.Base(os.Args[0]))
 }

 videoID := os.Args[1]

 captions, err := listVideoCaptions(videoID)
 if err != nil {
  log.Fatalf("unable to list video captions: %v", err)
 }

 for _, caption := range captions {
  if caption.LanguageCode == "en" {
   err := caption.Download(fmt.Sprintf("%s.xml", videoID))
   if err != nil {
    log.Printf("unable to download caption: %v", err)
   }
  }
 }
}

And try it with:

go run main.go mT0RNrTDHkI && cat mT0RNrTDHkI.xml

And voilà! Here’s a link to the GitHub repository. The implementation has evolved a bit, but the idea remains the same.

How to download YouTube captions using a Go script was originally published in Level Up Coding on Medium, where people are continuing the conversation by highlighting and responding to this story.

After 3 years of running, 2024 was the year I decided to run my first Paris marathon, but not everything went as planned.

🫣 0–2km

I’m feeling a bit stressed before the start, but I’m confident because I’ve followed all the recommendations to succeed in my first marathon:

• I stopped my 6 months of training 1 month before the race, because of a re-emerging autoimmune disease that prevents me from running without experiencing severe pain in my legs.

• To ensure I feel my best on race day and minimize discomfort, I took a heavy anti-inflammatory medication for three consecutive days leading up to the marathon.
• 12 hours before the race, I made adjustments to my nutrition and pacing strategies.

Everything should be fine, right ? Right ?!?

😀 2–27km

What a nice race!

The marathon circuit is really beautiful and the cheering helps me feel good. The weather is very hot and humid for April in Paris, but at least it’s not raining.

I started slow and I decide to keep this pace because I’m feeling very well.

Good thing I decided to hide my heart rate on my watch because this is a bit scary:

To give you an idea, before I stopped my training I was used to be around 145 at this pace…

🥵 27–32km

Okay, now my disease is coming to say hello, but I carry on and don’t listen, but the descent into hell begins little by little, km after km.

😭 32–41km

Why I’m doing this?

When negative thoughts start creeping in during a race, it’s nearly impossible to shake them off.

Unfortunately, my body is also protesting, and the lack of training is becoming all too clear.

Still, I’m relieved because I know I’ll finish no matter what — I’ve already completed three-quarters of the race!

🥹 41–42km

I can finally see the end!

And…. I DID IT, I DIT ITTTTTTTTT!!!!!!!

https://www.strava.com/activities/11127367442/overview

Maybe it’s time to get some rest, I can’t forget that I have a hospital appointment the next day at 7:30 a.m. I don’t know how I’m going to explain this to my doctor.