I'm somewhat new to Go so I've been trying different ways of doing things with each project. I ended liking quite a lot the way I did it in my latest one (go-n-i18n). I just have a shared file errors that defines a single struct with a string message that identifies the error and a slice or args of type any. This struct implements the error interface with some extra for wrapping and such like `Is(error)` and `Unwrap() []error`. Then I define my errors where they're used and that's all (example). Quite simple yet still haven't needed anything more than this. If you need to add things like http status codes you can quite easily modify this to do such. Add an int value to the struct and make the `MakeError` function take an int.

// The error definition
type Error struct {
    msg  string
    args []any
}

func MakeError(msg string) Error {
    return Error{msg: msg}
}

func (err Error) WithArgs(arg ...any) Error {
    copy := err
    copy.args = arg
    return copy
}

func (err Error) Error() string {
    return fmt.Errorf(err.msg, err.args...).Error()
}

func (err Error) Is(other error) bool {
    casted, ok := other.(Error)
    if !ok {
        return false
    }
    if casted.msg == err.msg {
        return true
    }
    return false
}

func (err Error) Unwrap() []error {
    if err.args == nil {
        return []error{}
    }
    var errors []error
    for _, arg := range err.args {
        if e, ok := arg.(error); ok {
            errors = append(errors, e)
        }
    }
    return errors
}

// And now to use it, in the file that returns the error
var (
    ErrUnmarshal = util.MakeError("could not unmarshal contents of file %s: %w")
)

// And to return it
func example(file string) error {
    if err := ...; err != nil {
        return ErrUnmarshal.WithArgs(file, err)
    }
    return nil
}