Yes, it's syntactic sugar that avoids the "marching pyramid of doom". You can see the difference in the example code from that page:

pub fn with_use() -> Result(String, Nil) {
  use username <- result.try(get_username())
  use password <- result.try(get_password())
  use greeting <- result.map(log_in(username, password))
  greeting <> ", " <> username
}

pub fn without_use() -> Result(String, Nil) {
  result.try(get_username(), fn(username) {
    result.try(get_password(), fn(password) {
      result.map(log_in(username, password), fn(greeting) {
        greeting <> ", " <> username
      })
    })
  })
}

The result is less indentation, and fewer braces, so less syntactic noise. Plus you don't have to figure out which closing brace is which when you make changes.

Regarding your comment I don't think I agree that it hides the underlying concept since the information is all still there: you swap out the fn keyword and a pair of braces for the use keyword, a left arrow. So if you know what you're reading use signals an inline function inside a call-site with an unusual argument notation.

Syntactically it's similar to the await keyword in JavaScript. (But use is much simpler - await conceptually conceals calls to .then). Before async/await the marching pyramid of doom was a common complaint about async javascript, especially from people offended by not being allowed to use threads.

The syntactic simplification also has a strong resemblance to Haskell's "do notation", complete with the left-arrow syntax. But like with await, do notation conceals calls to the bind operator (>>=) which is Haskell's version of flatMap / then.