Would you consider yourself a novice, intermediate, or experienced Go programmer? - intermediate.
What other languages do you have experience with? - rust/haskell/c/ruby.
Would this change make Go easier or harder to learn, and why? - no effect.
Has this idea, or one like it, been proposed before? - can't say.
Who does this proposal help, and why? - possibly it will help everyone, because it will make whole error handling more convenient.
Is the goal of this change a performance improvement? - no
Does this affect error handling? - yes. Key differences: backward compatible, (kinda) looks like other parts of the go, no new types, function signatures the same.

What is the proposed change?

• return of nil value for error will be optional.
• new keyword handle, that will work with errors.
• In language spec Errors section will be changed due to new way of error handling

Please also describe the change informally, as in a class teaching Go.

Basically, there will be easier way of error handling with new keyword handle, that checks if function returns error and if there is no handle body, it will just return error or exit function with default values for other return parameters. Additionally, returning nil value for error will be optional.

Is this changes backward compatible?

Yes, because nothing there will change function signatures, or anything else that can break backward compatibility.

Example

before

package main

import ...

func get(url string) (string, error) {
    resp, err := http.Get(url)
    if err != nil {
        return "", err
    }

    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return "", err
    }

    return string(body), nil
}

func main() {
     contents, err := get("http://example.com")
     if err != nil {
         fmt.Println(err)
         os.Exit(1)
     }
     fmt.Println(contents)
}

after

package main

import ...

func get(url string) (string, error) {
    // will return error if http.Get() returns error
    resp := handle http.Get(url)

    defer resp.Body.Close()

    body := handle io.ReadAll(resp.Body)
    return string(body)
}

func main() {
     // handle logic can be changed with this syntax
     // -> err syntax means that error will be put in variable with that name.
     // but "-> err" can look better i think 
     contents := handle get("http://example.com") -> err {
          fmt.Println(err)
          os.Exit(1)
     }
     fmt.Println(contents)
}

Affected tools

• gopls
• gofmt

Other pros

• Better readability
• Smaller functions
• Clearer code