diff --git a/src/lint/linter/ArcanistLesscLinter.php b/src/lint/linter/ArcanistLesscLinter.php
index 4032b1ed..f49d48ae 100644
--- a/src/lint/linter/ArcanistLesscLinter.php
+++ b/src/lint/linter/ArcanistLesscLinter.php
@@ -1,183 +1,183 @@
 <?php
 
 /**
  * A linter for LESSCSS files.
  *
  * This linter uses [[https://github.com/less/less.js | lessc]] to detect
  * errors and potential problems in [[http://lesscss.org/ | LESS]] code.
  */
 final class ArcanistLesscLinter extends ArcanistExternalLinter {
 
   const LINT_RUNTIME_ERROR   = 1;
   const LINT_ARGUMENT_ERROR  = 2;
   const LINT_FILE_ERROR      = 3;
   const LINT_NAME_ERROR      = 4;
   const LINT_OPERATION_ERROR = 5;
   const LINT_PARSE_ERROR     = 6;
   const LINT_SYNTAX_ERROR    = 7;
 
   private $strictMath = false;
   private $strictUnits = false;
 
   public function getInfoName() {
-    return 'Less';
+    return 'CSS pre-processor';
   }
 
   public function getInfoURI() {
-    return 'https://lesscss.org/';
+    return 'http://lesscss.org/';
   }
 
   public function getInfoDescription() {
     return pht(
       'Use the `%s` mode provided by `%s` to detect errors in '.
       'Less source files.',
       '--lint',
       'lessc');
   }
 
   public function getLinterName() {
     return 'LESSC';
   }
 
   public function getLinterConfigurationName() {
     return 'lessc';
   }
 
   public function getLinterConfigurationOptions() {
     return parent::getLinterConfigurationOptions() + array(
       'lessc.strict-math' => array(
         'type' => 'optional bool',
         'help' => pht(
           'Enable strict math, which only processes mathematical expressions '.
           'inside extraneous parentheses.'),
       ),
       'lessc.strict-units' => array(
         'type' => 'optional bool',
         'help' => pht('Enable strict handling of units in expressions.'),
       ),
     );
   }
 
   public function setLinterConfigurationValue($key, $value) {
     switch ($key) {
       case 'lessc.strict-math':
         $this->strictMath = $value;
         return;
       case 'lessc.strict-units':
         $this->strictUnits = $value;
         return;
     }
 
     return parent::setLinterConfigurationValue($key, $value);
   }
 
   public function getLintNameMap() {
     return array(
       self::LINT_RUNTIME_ERROR   => pht('Runtime Error'),
       self::LINT_ARGUMENT_ERROR  => pht('Argument Error'),
       self::LINT_FILE_ERROR      => pht('File Error'),
       self::LINT_NAME_ERROR      => pht('Name Error'),
       self::LINT_OPERATION_ERROR => pht('Operation Error'),
       self::LINT_PARSE_ERROR     => pht('Parse Error'),
       self::LINT_SYNTAX_ERROR    => pht('Syntax Error'),
     );
   }
 
   public function getDefaultBinary() {
     return 'lessc';
   }
 
   public function getVersion() {
     list($stdout) = execx('%C --version', $this->getExecutableCommand());
 
     $matches = array();
     $regex = '/^lessc (?P<version>\d+\.\d+\.\d+)\b/';
     if (preg_match($regex, $stdout, $matches)) {
       $version = $matches['version'];
     } else {
       return false;
     }
   }
 
   public function getInstallInstructions() {
     return pht('Install lessc using `%s`.', 'npm install -g less');
   }
 
   protected function getMandatoryFlags() {
     return array(
       '--lint',
       '--no-color',
       '--strict-math='.($this->strictMath ? 'on' : 'off'),
       '--strict-units='.($this->strictUnits ? 'on' : 'off'),
     );
   }
 
   protected function parseLinterOutput($path, $err, $stdout, $stderr) {
     $lines = phutil_split_lines($stderr, false);
 
     $messages = array();
     foreach ($lines as $line) {
       $matches = null;
       $match = preg_match(
         '/^(?P<name>\w+): (?P<description>.+) '.
         'in (?P<path>.+|-) '.
         'on line (?P<line>\d+), column (?P<column>\d+):$/',
         $line,
         $matches);
 
       if ($match) {
         switch ($matches['name']) {
           case 'RuntimeError':
             $code = self::LINT_RUNTIME_ERROR;
             break;
 
           case 'ArgumentError':
             $code = self::LINT_ARGUMENT_ERROR;
             break;
 
           case 'FileError':
             $code = self::LINT_FILE_ERROR;
             break;
 
           case 'NameError':
             $code = self::LINT_NAME_ERROR;
             break;
 
           case 'OperationError':
             $code = self::LINT_OPERATION_ERROR;
             break;
 
           case 'ParseError':
             $code = self::LINT_PARSE_ERROR;
             break;
 
           case 'SyntaxError':
             $code = self::LINT_SYNTAX_ERROR;
             break;
 
           default:
             throw new RuntimeException(
               pht(
                 'Unrecognized lint message code "%s".',
                 $code));
         }
 
         $code = $this->getLintCodeFromLinterConfigurationKey($matches['name']);
 
         $message = new ArcanistLintMessage();
         $message->setPath($path);
         $message->setLine($matches['line']);
         $message->setChar($matches['column']);
         $message->setCode($this->getLintMessageFullCode($code));
         $message->setSeverity($this->getLintMessageSeverity($code));
         $message->setName($this->getLintMessageName($code));
         $message->setDescription(ucfirst($matches['description']));
 
         $messages[] = $message;
       }
     }
 
     return $messages;
   }
 
 }
diff --git a/src/lint/linter/ArcanistPEP8Linter.php b/src/lint/linter/ArcanistPEP8Linter.php
index f1cb21ee..682ac6a8 100644
--- a/src/lint/linter/ArcanistPEP8Linter.php
+++ b/src/lint/linter/ArcanistPEP8Linter.php
@@ -1,98 +1,98 @@
 <?php
 
 /**
  * Uses "pep8.py" to enforce PEP8 rules for Python.
  */
 final class ArcanistPEP8Linter extends ArcanistExternalLinter {
 
   public function getInfoName() {
-    return 'pep8';
+    return 'Python PEP 8';
   }
 
   public function getInfoURI() {
     return 'https://pypi.python.org/pypi/pep8';
   }
 
   public function getInfoDescription() {
     return pht(
       'pep8 is a tool to check your Python code against some of the '.
       'style conventions in PEP 8.');
   }
 
   public function getLinterName() {
     return 'PEP8';
   }
 
   public function getLinterConfigurationName() {
     return 'pep8';
   }
 
   public function getDefaultBinary() {
     return 'pep8';
   }
 
   public function getVersion() {
     list($stdout) = execx('%C --version', $this->getExecutableCommand());
 
     $matches = array();
     if (preg_match('/^(?P<version>\d+\.\d+(?:\.\d+)?)\b/', $stdout, $matches)) {
       return $matches['version'];
     } else {
       return false;
     }
   }
 
   public function getInstallInstructions() {
     return pht('Install PEP8 using `%s`.', 'easy_install pep8');
   }
 
   protected function parseLinterOutput($path, $err, $stdout, $stderr) {
     $lines = phutil_split_lines($stdout, false);
 
     $messages = array();
     foreach ($lines as $line) {
       $matches = null;
       if (!preg_match('/^(.*?):(\d+):(\d+): (\S+) (.*)$/', $line, $matches)) {
         continue;
       }
       foreach ($matches as $key => $match) {
         $matches[$key] = trim($match);
       }
       $message = new ArcanistLintMessage();
       $message->setPath($path);
       $message->setLine($matches[2]);
       $message->setChar($matches[3]);
       $message->setCode($matches[4]);
       $message->setName('PEP8 '.$matches[4]);
       $message->setDescription($matches[5]);
       $message->setSeverity($this->getLintMessageSeverity($matches[4]));
 
       $messages[] = $message;
     }
 
     return $messages;
   }
 
   protected function getDefaultMessageSeverity($code) {
     if (preg_match('/^W/', $code)) {
       return ArcanistLintSeverity::SEVERITY_WARNING;
     } else {
       return ArcanistLintSeverity::SEVERITY_ERROR;
     }
   }
 
   protected function getLintCodeFromLinterConfigurationKey($code) {
     if (!preg_match('/^(E|W)\d+$/', $code)) {
       throw new Exception(
         pht(
           'Unrecognized lint message code "%s". Expected a valid PEP8 '.
           'lint code like "%s" or "%s".',
           $code,
           'E101',
           'W291'));
     }
 
     return $code;
   }
 
 }