     }
     labelsToAdd.append(contentsOf: labelsFromPaths)
     if let titleLabel = getTitleLabel(title: PRData.title) {
-      // check if there is a title label but it needs fixing.
-      let unbracketedTitleLabel = String(titleLabel.dropFirst().dropLast())
-      for label in labelsFromPaths {
-        let unbracketedLabel = String(label.dropFirst().dropLast())
-        if label == titleLabel {
-          break
-        } else if checkIfTwoStringsAreSimilar(str1: unbracketedLabel,
-                                                              str2: unbracketedTitleLabel,
-                                                              threshold: 2) {
+      // The label in the title isn't part of the changed componentry
+      if !labelsFromPaths.contains(titleLabel) {
+        // Check if it's close to a component name, and then fix it
+        var labelDist = [String: Int]()
+        let unbracketedTitleLabel = String(titleLabel.dropFirst().dropLast())
+        for label in labelsFromPaths {
+          let unbracketedLabel = String(label.dropFirst().dropLast())
+          labelDist[label] = getStringDistance(str1: unbracketedLabel.lowercased(),
+                                              str2: unbracketedTitleLabel.lowercased())
+        }
+        // get minimum distance
+        let (lbl, dist) = labelDist.reduce(("", Int.max)) { $0.1 > $1.value ? ($1.key, $1.value) : $0 }
+        if dist <= 2 {
+          labelsToAdd.append(lbl)
+          // update title
           if let range = PRData.title.range(of: "]") {
             let titleWithoutLabel = PRData.title[range.upperBound...]
-            var updatedTitle = label
+            var updatedTitle = lbl
             if titleWithoutLabel.first != " " {
               updatedTitle += " " + titleWithoutLabel
             } else {

    }
  }

  /// This method gets two strings and uses the Levenshtein Distance algorithm with some
  /// initial constraints to find out how similar they are. It is also given a threshold as to
  /// how similar they can be and returns True if the difference is lower than or equal to the
  /// threshold, and False otherwise. Every deletion/addition/reorder action is worth
  /// 1 "point" of difference.
  ///
  /// - Parameters:
  ///   - str1: The first string to compare. This is the "correct" string that the other string is compared to.
  ///   - str2: The second string to compare.
  ///   - threshold: The given threshold of allowed difference
  /// - Returns: returns true if the strings are similar based on the threshold, and false otherwise.
  class func checkIfTwoStringsAreSimilar(str1: String, str2: String, threshold: Int) -> Bool {
    if str1.isEmpty || str2.isEmpty {
      return false
    }
    let str1 = str1.lowercased()
    var str2 = str2.lowercased()
    if let ind = str2.index(of: str1.first!), ind != str1.startIndex {
      str2 = String(str2[ind...])
    }

    if str2.contains(str1) {
      return true
    }

    var distance = Array(repeating: Array(repeating: 0, count: str2.count + 1), count: str1.count + 1)
    for i in 1...str1.count {
      distance[i][0] = i

        }
      }
    }
    return distance[str1.count][str2.count]
  }

  /// Adds a "Needs actionability review" label to the issue.
