Every fallible operation returns (value, error). The caller checks err != nil immediately and either handles the error or returns it up the stack. There is no exception machinery to short-circuit the stack, which makes control flow obvious at the cost of more typing. errors.New("text") builds a plain error; fmt.Errorf("context: %v", inner) includes the inner error's message but loses the type, while the %w verb (next accordion) preserves the original for unwrapping. Always handle errors at the layer that has enough context to make a meaningful decision; do not blanket-log-and-continue.

fmt.Errorf with the %w verb attaches an inner error to the new one, building a chain. The outer error carries human-readable context ("deposit 42:") while the inner sentinel value is preserved for programmatic inspection. errors.Is(err, target) walks the chain looking for the target value, regardless of how many layers wrap it. This pattern replaces the pre-1.13 ad-hoc convention of comparing strings or exporting wrapper types. Use a small set of exported sentinel errors (ErrNotFound, ErrConflict) plus wrapping for context, and your call sites stay readable while still being introspectable.

When the inner error carries a custom type (with extra fields like Field here), errors.As(err, &target) walks the wrap chain and assigns the first error of the matching type into target. It returns true if it found one, false otherwise. Compared to a type assertion or switch, errors.As works through arbitrary wrap depth. Use it whenever you want to inspect the structured details of an error rather than just whether it equals a sentinel; the typical pattern is one errors.Is for sentinel cases and one errors.As for typed-error cases at API boundaries.