diff --git a/.golangci.yaml b/.golangci.yaml
index 602f126303..6ab8bb2fef 100644
--- a/.golangci.yaml
+++ b/.golangci.yaml
@@ -16,9 +16,11 @@ linters-settings:
         replacement: 'a[b:]'
       - pattern: 'interface{}'
         replacement: 'any'
+  errcheck:
+    exclude-functions:
+      - (*github.com/spf13/cobra.Command).RegisterFlagCompletionFunc
+      - (*github.com/spf13/cobra.Command).MarkFlagRequired
+      - (*github.com/spf13/pflag.FlagSet).MarkDeprecated
+      - (*github.com/spf13/pflag.FlagSet).MarkHidden
 issues:
   exclude-dirs-use-default: false  # recommended by docs https://golangci-lint.run/usage/false-positives/
-  exclude-rules:
-    - path-except: (_test\.go|internal)
-      linters:
-        - errcheck
diff --git a/bundle/config/mutator/initialize_urls.go b/bundle/config/mutator/initialize_urls.go
index 3193059121..4cf7ed72c0 100644
--- a/bundle/config/mutator/initialize_urls.go
+++ b/bundle/config/mutator/initialize_urls.go
@@ -32,7 +32,10 @@ func (m *initializeURLs) Apply(ctx context.Context, b *bundle.Bundle) diag.Diagn
 	}
 	orgId := strconv.FormatInt(workspaceId, 10)
 	host := b.WorkspaceClient().Config.CanonicalHostName()
-	initializeForWorkspace(b, orgId, host)
+	err = initializeForWorkspace(b, orgId, host)
+	if err != nil {
+		return diag.FromErr(err)
+	}
 	return nil
 }
 
diff --git a/bundle/config/mutator/resolve_resource_references.go b/bundle/config/mutator/resolve_resource_references.go
index 89eaa346c6..bf902f9282 100644
--- a/bundle/config/mutator/resolve_resource_references.go
+++ b/bundle/config/mutator/resolve_resource_references.go
@@ -36,8 +36,7 @@ func (m *resolveResourceReferences) Apply(ctx context.Context, b *bundle.Bundle)
 				return fmt.Errorf("failed to resolve %s, err: %w", v.Lookup, err)
 			}
 
-			v.Set(id)
-			return nil
+			return v.Set(id)
 		})
 	}
 
diff --git a/bundle/deploy/state_pull.go b/bundle/deploy/state_pull.go
index 5e301a6f35..96f138e9d3 100644
--- a/bundle/deploy/state_pull.go
+++ b/bundle/deploy/state_pull.go
@@ -62,8 +62,14 @@ func (s *statePull) Apply(ctx context.Context, b *bundle.Bundle) diag.Diagnostic
 	}
 
 	// Truncating the file before writing
-	local.Truncate(0)
-	local.Seek(0, 0)
+	err = local.Truncate(0)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+	_, err = local.Seek(0, 0)
+	if err != nil {
+		return diag.FromErr(err)
+	}
 
 	// Write file to disk.
 	log.Infof(ctx, "Writing remote deployment state file to local cache directory")
diff --git a/bundle/render/render_text_output.go b/bundle/render/render_text_output.go
index 92dacb4488..bf7c9a53a9 100644
--- a/bundle/render/render_text_output.go
+++ b/bundle/render/render_text_output.go
@@ -171,10 +171,16 @@ func RenderDiagnostics(out io.Writer, b *bundle.Bundle, diags diag.Diagnostics,
 			if err != nil {
 				return fmt.Errorf("failed to render summary: %w", err)
 			}
-			io.WriteString(out, "\n")
+			_, err = io.WriteString(out, "\n")
+			if err != nil {
+				return err
+			}
 		}
 		trailer := buildTrailer(diags)
-		io.WriteString(out, trailer)
+		_, err = io.WriteString(out, trailer)
+		if err != nil {
+			return err
+		}
 	}
 
 	return nil
diff --git a/cmd/auth/describe.go b/cmd/auth/describe.go
index 3a6e3d5d77..c5fa8d26bf 100644
--- a/cmd/auth/describe.go
+++ b/cmd/auth/describe.go
@@ -141,7 +141,10 @@ func render(ctx context.Context, cmd *cobra.Command, status *authStatus, templat
 		if err != nil {
 			return err
 		}
-		cmd.OutOrStdout().Write(buf)
+		_, err = cmd.OutOrStdout().Write(buf)
+		if err != nil {
+			return err
+		}
 	default:
 		return fmt.Errorf("unknown output type %s", root.OutputType(cmd))
 	}
diff --git a/cmd/auth/env.go b/cmd/auth/env.go
index e72d153998..52b7cbbfdf 100644
--- a/cmd/auth/env.go
+++ b/cmd/auth/env.go
@@ -138,7 +138,7 @@ func newEnvCommand() *cobra.Command {
 		if err != nil {
 			return err
 		}
-		cmd.OutOrStdout().Write(raw)
+		_, _ = cmd.OutOrStdout().Write(raw)
 		return nil
 	}
 
diff --git a/cmd/auth/token.go b/cmd/auth/token.go
index 3f9af43fa4..fbf8b68f6e 100644
--- a/cmd/auth/token.go
+++ b/cmd/auth/token.go
@@ -94,7 +94,7 @@ func newTokenCommand(persistentAuth *auth.PersistentAuth) *cobra.Command {
 		if err != nil {
 			return err
 		}
-		cmd.OutOrStdout().Write(raw)
+		_, _ = cmd.OutOrStdout().Write(raw)
 		return nil
 	}
 
diff --git a/cmd/bundle/debug/terraform.go b/cmd/bundle/debug/terraform.go
index 843ecac4ec..c7d49ebb2f 100644
--- a/cmd/bundle/debug/terraform.go
+++ b/cmd/bundle/debug/terraform.go
@@ -60,13 +60,13 @@ For more information about filesystem mirrors, see the Terraform documentation:
 		}
 		switch root.OutputType(cmd) {
 		case flags.OutputText:
-			cmdio.Render(cmd.Context(), dependencies.Terraform)
+			_ = cmdio.Render(cmd.Context(), dependencies.Terraform)
 		case flags.OutputJSON:
 			buf, err := json.MarshalIndent(dependencies, "", "  ")
 			if err != nil {
 				return err
 			}
-			cmd.OutOrStdout().Write(buf)
+			_, _ = cmd.OutOrStdout().Write(buf)
 		default:
 			return fmt.Errorf("unknown output type %s", root.OutputType(cmd))
 		}
diff --git a/cmd/bundle/run.go b/cmd/bundle/run.go
index 7a92766d90..3bcebddd59 100644
--- a/cmd/bundle/run.go
+++ b/cmd/bundle/run.go
@@ -159,13 +159,19 @@ task or a Python wheel task, the second example applies.
 				if err != nil {
 					return err
 				}
-				cmd.OutOrStdout().Write([]byte(resultString))
+				_, err = cmd.OutOrStdout().Write([]byte(resultString))
+				if err != nil {
+					return err
+				}
 			case flags.OutputJSON:
 				b, err := json.MarshalIndent(output, "", "  ")
 				if err != nil {
 					return err
 				}
-				cmd.OutOrStdout().Write(b)
+				_, err = cmd.OutOrStdout().Write(b)
+				if err != nil {
+					return err
+				}
 			default:
 				return fmt.Errorf("unknown output type %s", root.OutputType(cmd))
 			}
diff --git a/cmd/bundle/summary.go b/cmd/bundle/summary.go
index 8c34dd6122..7c669c8454 100644
--- a/cmd/bundle/summary.go
+++ b/cmd/bundle/summary.go
@@ -73,7 +73,7 @@ func newSummaryCommand() *cobra.Command {
 			if err != nil {
 				return err
 			}
-			cmd.OutOrStdout().Write(buf)
+			_, _ = cmd.OutOrStdout().Write(buf)
 		default:
 			return fmt.Errorf("unknown output type %s", root.OutputType(cmd))
 		}
diff --git a/cmd/bundle/validate.go b/cmd/bundle/validate.go
index 5331e7e7b1..3b50cc2580 100644
--- a/cmd/bundle/validate.go
+++ b/cmd/bundle/validate.go
@@ -20,7 +20,7 @@ func renderJsonOutput(cmd *cobra.Command, b *bundle.Bundle, diags diag.Diagnosti
 	if err != nil {
 		return err
 	}
-	cmd.OutOrStdout().Write(buf)
+	_, _ = cmd.OutOrStdout().Write(buf)
 	return diags.Error()
 }
 
diff --git a/cmd/root/io.go b/cmd/root/io.go
index b224bbb27a..96c5a9a266 100644
--- a/cmd/root/io.go
+++ b/cmd/root/io.go
@@ -21,7 +21,7 @@ func initOutputFlag(cmd *cobra.Command) *outputFlag {
 	// Configure defaults from environment, if applicable.
 	// If the provided value is invalid it is ignored.
 	if v, ok := env.Lookup(cmd.Context(), envOutputFormat); ok {
-		f.output.Set(v)
+		f.output.Set(v) //nolint:errcheck
 	}
 
 	cmd.PersistentFlags().VarP(&f.output, "output", "o", "output type: text or json")
diff --git a/cmd/root/logger.go b/cmd/root/logger.go
index 48cb99a370..38e09b9c9f 100644
--- a/cmd/root/logger.go
+++ b/cmd/root/logger.go
@@ -45,7 +45,10 @@ func (f *logFlags) makeLogHandler(opts slog.HandlerOptions) (slog.Handler, error
 
 func (f *logFlags) initializeContext(ctx context.Context) (context.Context, error) {
 	if f.debug {
-		f.level.Set("debug")
+		err := f.level.Set("debug")
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	opts := slog.HandlerOptions{}
@@ -81,13 +84,13 @@ func initLogFlags(cmd *cobra.Command) *logFlags {
 	// Configure defaults from environment, if applicable.
 	// If the provided value is invalid it is ignored.
 	if v, ok := env.Lookup(cmd.Context(), envLogFile); ok {
-		f.file.Set(v)
+		f.file.Set(v) //nolint:errcheck
 	}
 	if v, ok := env.Lookup(cmd.Context(), envLogLevel); ok {
-		f.level.Set(v)
+		f.level.Set(v) //nolint:errcheck
 	}
 	if v, ok := env.Lookup(cmd.Context(), envLogFormat); ok {
-		f.output.Set(v)
+		f.output.Set(v) //nolint:errcheck
 	}
 
 	flags := cmd.PersistentFlags()
diff --git a/cmd/root/progress_logger.go b/cmd/root/progress_logger.go
index 7d6a1fa46d..1458de13a3 100644
--- a/cmd/root/progress_logger.go
+++ b/cmd/root/progress_logger.go
@@ -59,7 +59,7 @@ func initProgressLoggerFlag(cmd *cobra.Command, logFlags *logFlags) *progressLog
 	// Configure defaults from environment, if applicable.
 	// If the provided value is invalid it is ignored.
 	if v, ok := env.Lookup(cmd.Context(), envProgressFormat); ok {
-		f.Set(v)
+		_ = f.Set(v)
 	}
 
 	flags := cmd.PersistentFlags()
diff --git a/libs/auth/callback.go b/libs/auth/callback.go
index 5a24006978..3893a5041a 100644
--- a/libs/auth/callback.go
+++ b/libs/auth/callback.go
@@ -53,7 +53,9 @@ func newCallback(ctx context.Context, a *PersistentAuth) (*callbackServer, error
 		a:           a,
 	}
 	cb.srv.Handler = cb
-	go cb.srv.Serve(cb.ln)
+	go func() {
+		_ = cb.srv.Serve(cb.ln)
+	}()
 	return cb, nil
 }
 
diff --git a/libs/cmdio/logger.go b/libs/cmdio/logger.go
index 45b1883ce8..5e89b3a34f 100644
--- a/libs/cmdio/logger.go
+++ b/libs/cmdio/logger.go
@@ -188,29 +188,29 @@ func (l *Logger) writeJson(event Event) {
 		// we panic because there we cannot catch this in jobs.RunNowAndWait
 		panic(err)
 	}
-	l.Writer.Write([]byte(b))
-	l.Writer.Write([]byte("\n"))
+	_, _ = l.Writer.Write([]byte(b))
+	_, _ = l.Writer.Write([]byte("\n"))
 }
 
 func (l *Logger) writeAppend(event Event) {
-	l.Writer.Write([]byte(event.String()))
-	l.Writer.Write([]byte("\n"))
+	_, _ = l.Writer.Write([]byte(event.String()))
+	_, _ = l.Writer.Write([]byte("\n"))
 }
 
 func (l *Logger) writeInplace(event Event) {
 	if l.isFirstEvent {
 		// save cursor location
-		l.Writer.Write([]byte("\033[s"))
+		_, _ = l.Writer.Write([]byte("\033[s"))
 	}
 
 	// move cursor to saved location
-	l.Writer.Write([]byte("\033[u"))
+	_, _ = l.Writer.Write([]byte("\033[u"))
 
 	// clear from cursor to end of screen
-	l.Writer.Write([]byte("\033[0J"))
+	_, _ = l.Writer.Write([]byte("\033[0J"))
 
-	l.Writer.Write([]byte(event.String()))
-	l.Writer.Write([]byte("\n"))
+	_, _ = l.Writer.Write([]byte(event.String()))
+	_, _ = l.Writer.Write([]byte("\n"))
 	l.isFirstEvent = false
 }
 
diff --git a/libs/cmdio/render.go b/libs/cmdio/render.go
index c68ddca0df..1529274a3c 100644
--- a/libs/cmdio/render.go
+++ b/libs/cmdio/render.go
@@ -361,7 +361,9 @@ func renderUsingTemplate(ctx context.Context, r templateRenderer, w io.Writer, h
 		if err != nil {
 			return err
 		}
-		tw.Write([]byte("\n"))
+		if _, err := tw.Write([]byte("\n")); err != nil {
+			return err
+		}
 		// Do not flush here. Instead, allow the first 100 resources to determine the initial spacing of the header columns.
 	}
 	t, err := base.Parse(tmpl)
diff --git a/libs/dyn/convert/from_typed.go b/libs/dyn/convert/from_typed.go
index cd92ad0eb2..ed1b85a365 100644
--- a/libs/dyn/convert/from_typed.go
+++ b/libs/dyn/convert/from_typed.go
@@ -126,7 +126,7 @@ func fromTypedStruct(src reflect.Value, ref dyn.Value, options ...fromTypedOptio
 
 		// Either if the key was set in the reference or the field is not zero-valued, we include it.
 		if ok || nv.Kind() != dyn.KindNil {
-			out.Set(refk, nv)
+			out.Set(refk, nv) // nolint:errcheck
 		}
 	}
 
@@ -184,7 +184,7 @@ func fromTypedMap(src reflect.Value, ref dyn.Value) (dyn.Value, error) {
 
 		// Every entry is represented, even if it is a nil.
 		// Otherwise, a map with zero-valued structs would yield a nil as well.
-		out.Set(refk, nv)
+		out.Set(refk, nv) //nolint:errcheck
 	}
 
 	return dyn.V(out), nil
diff --git a/libs/dyn/convert/normalize.go b/libs/dyn/convert/normalize.go
index 106add35df..31cd8b6e3f 100644
--- a/libs/dyn/convert/normalize.go
+++ b/libs/dyn/convert/normalize.go
@@ -116,7 +116,7 @@ func (n normalizeOptions) normalizeStruct(typ reflect.Type, src dyn.Value, seen
 				}
 			}
 
-			out.Set(pk, nv)
+			out.Set(pk, nv) //nolint:errcheck
 		}
 
 		// Return the normalized value if missing fields are not included.
@@ -162,7 +162,7 @@ func (n normalizeOptions) normalizeStruct(typ reflect.Type, src dyn.Value, seen
 				continue
 			}
 			if v.IsValid() {
-				out.Set(dyn.V(k), v)
+				out.Set(dyn.V(k), v) // nolint:errcheck
 			}
 		}
 
@@ -201,7 +201,7 @@ func (n normalizeOptions) normalizeMap(typ reflect.Type, src dyn.Value, seen []r
 				}
 			}
 
-			out.Set(pk, nv)
+			out.Set(pk, nv) //nolint:errcheck
 		}
 
 		return dyn.NewValue(out, src.Locations()), diags
diff --git a/libs/dyn/jsonloader/json.go b/libs/dyn/jsonloader/json.go
index cbf539263a..3f2dc859fe 100644
--- a/libs/dyn/jsonloader/json.go
+++ b/libs/dyn/jsonloader/json.go
@@ -70,7 +70,7 @@ func decodeValue(decoder *json.Decoder, o *Offset) (dyn.Value, error) {
 					return invalidValueWithLocation(decoder, o), err
 				}
 
-				obj.Set(keyVal, val)
+				obj.Set(keyVal, val) //nolint:errcheck
 			}
 			// Consume the closing '}'
 			if _, err := decoder.Token(); err != nil {
diff --git a/libs/dyn/mapping.go b/libs/dyn/mapping.go
index f9f2d2e97e..f5dbd18e6c 100644
--- a/libs/dyn/mapping.go
+++ b/libs/dyn/mapping.go
@@ -41,7 +41,7 @@ func newMappingWithSize(size int) Mapping {
 func newMappingFromGoMap(vin map[string]Value) Mapping {
 	m := newMappingWithSize(len(vin))
 	for k, v := range vin {
-		m.Set(V(k), v)
+		m.Set(V(k), v) //nolint:errcheck
 	}
 	return m
 }
@@ -144,6 +144,6 @@ func (m Mapping) Clone() Mapping {
 // Merge merges the key-value pairs from another Mapping into the current Mapping.
 func (m *Mapping) Merge(n Mapping) {
 	for _, p := range n.pairs {
-		m.Set(p.Key, p.Value)
+		m.Set(p.Key, p.Value) //nolint:errcheck
 	}
 }
diff --git a/libs/dyn/merge/merge.go b/libs/dyn/merge/merge.go
index 29decd7793..a83bbc1527 100644
--- a/libs/dyn/merge/merge.go
+++ b/libs/dyn/merge/merge.go
@@ -88,10 +88,10 @@ func mergeMap(a, b dyn.Value) (dyn.Value, error) {
 			if err != nil {
 				return dyn.InvalidValue, err
 			}
-			out.Set(pk, merged)
+			out.Set(pk, merged) //nolint:errcheck
 		} else {
 			// Otherwise, just set the value.
-			out.Set(pk, pv)
+			out.Set(pk, pv) //nolint:errcheck
 		}
 	}
 
diff --git a/libs/dyn/pattern.go b/libs/dyn/pattern.go
index aecdc3ca63..2d2e9cae7b 100644
--- a/libs/dyn/pattern.go
+++ b/libs/dyn/pattern.go
@@ -69,7 +69,7 @@ func (c anyKeyComponent) visit(v Value, prefix Path, suffix Pattern, opts visitO
 			return InvalidValue, err
 		}
 
-		m.Set(pk, nv)
+		m.Set(pk, nv) //nolint:errcheck
 	}
 
 	return NewValue(m, v.Locations()), nil
diff --git a/libs/dyn/visit.go b/libs/dyn/visit.go
index 38adec24ff..95515115ea 100644
--- a/libs/dyn/visit.go
+++ b/libs/dyn/visit.go
@@ -122,7 +122,7 @@ func (component pathComponent) visit(v Value, prefix Path, suffix Pattern, opts
 
 		// Return an updated map value.
 		m = m.Clone()
-		m.Set(V(component.key), nv)
+		m.Set(V(component.key), nv) //nolint:errcheck
 		return Value{
 			v: m,
 			k: KindMap,
diff --git a/libs/dyn/visit_map.go b/libs/dyn/visit_map.go
index 3f0cded03b..db45260381 100644
--- a/libs/dyn/visit_map.go
+++ b/libs/dyn/visit_map.go
@@ -25,7 +25,7 @@ func Foreach(fn MapFunc) MapFunc {
 				if err != nil {
 					return InvalidValue, err
 				}
-				m.Set(pk, nv)
+				m.Set(pk, nv) //nolint:errcheck
 			}
 			return NewValue(m, v.Locations()), nil
 		case KindSequence:
diff --git a/libs/dyn/visit_set.go b/libs/dyn/visit_set.go
index b086fb8a91..9991d311fa 100644
--- a/libs/dyn/visit_set.go
+++ b/libs/dyn/visit_set.go
@@ -41,7 +41,7 @@ func SetByPath(v Value, p Path, nv Value) (Value, error) {
 
 				// Return an updated map value.
 				m = m.Clone()
-				m.Set(V(component.key), nv)
+				m.Set(V(component.key), nv) //nolint:errcheck
 				return Value{
 					v: m,
 					k: KindMap,
diff --git a/libs/dyn/walk.go b/libs/dyn/walk.go
index c51a11e22c..b3576e0881 100644
--- a/libs/dyn/walk.go
+++ b/libs/dyn/walk.go
@@ -45,7 +45,7 @@ func walk(v Value, p Path, fn func(p Path, v Value) (Value, error)) (Value, erro
 			if err != nil {
 				return InvalidValue, err
 			}
-			out.Set(pk, nv)
+			out.Set(pk, nv) //nolint:errcheck
 		}
 		v.v = out
 	case KindSequence:
diff --git a/libs/dyn/yamlloader/loader.go b/libs/dyn/yamlloader/loader.go
index a77ee0744a..965753ccd4 100644
--- a/libs/dyn/yamlloader/loader.go
+++ b/libs/dyn/yamlloader/loader.go
@@ -129,7 +129,7 @@ func (d *loader) loadMapping(node *yaml.Node, loc dyn.Location) (dyn.Value, erro
 			return dyn.InvalidValue, err
 		}
 
-		acc.Set(k, v)
+		acc.Set(k, v) //nolint:errcheck
 	}
 
 	if merge == nil {
diff --git a/libs/env/loader.go b/libs/env/loader.go
index f441ffa15e..74c54cee8f 100644
--- a/libs/env/loader.go
+++ b/libs/env/loader.go
@@ -43,7 +43,9 @@ func (le *configLoader) Configure(cfg *config.Config) error {
 			if v == "" {
 				continue
 			}
-			a.Set(cfg, v)
+			if err := a.Set(cfg, v); err != nil {
+				return err
+			}
 		}
 	}
 	return nil
diff --git a/libs/git/config.go b/libs/git/config.go
index fafd81bd67..f7ff057e1b 100644
--- a/libs/git/config.go
+++ b/libs/git/config.go
@@ -155,8 +155,8 @@ func globalGitConfig() (*config, error) {
 	// > are missing or unreadable they will be ignored.
 	//
 	// We therefore ignore the error return value for the calls below.
-	config.loadFile(vfs.MustNew(xdgConfigHome), "git/config")
-	config.loadFile(vfs.MustNew(config.home), ".gitconfig")
+	_ = config.loadFile(vfs.MustNew(xdgConfigHome), "git/config")
+	_ = config.loadFile(vfs.MustNew(config.home), ".gitconfig")
 
 	return config, nil
 }
diff --git a/libs/process/stub.go b/libs/process/stub.go
index 8472f65d5b..8ab6fd705f 100644
--- a/libs/process/stub.go
+++ b/libs/process/stub.go
@@ -148,13 +148,20 @@ func (s *processStub) run(cmd *exec.Cmd) error {
 		if !re.MatchString(norm) {
 			continue
 		}
+		err := resp.err
 		if resp.stdout != "" {
-			cmd.Stdout.Write([]byte(resp.stdout))
+			_, err1 := cmd.Stdout.Write([]byte(resp.stdout))
+			if err == nil {
+				err = err1
+			}
 		}
 		if resp.stderr != "" {
-			cmd.Stderr.Write([]byte(resp.stderr))
+			_, err1 := cmd.Stderr.Write([]byte(resp.stderr))
+			if err == nil {
+				err = err1
+			}
 		}
-		return resp.err
+		return err
 	}
 	if s.callback != nil {
 		return s.callback(cmd)
@@ -163,8 +170,12 @@ func (s *processStub) run(cmd *exec.Cmd) error {
 	if s.reponseStub == zeroStub {
 		return fmt.Errorf("no default process stub")
 	}
+	err := s.reponseStub.err
 	if s.reponseStub.stdout != "" {
-		cmd.Stdout.Write([]byte(s.reponseStub.stdout))
+		_, err1 := cmd.Stdout.Write([]byte(s.reponseStub.stdout))
+		if err == nil {
+			err = err1
+		}
 	}
-	return s.reponseStub.err
+	return err
 }
diff --git a/libs/sync/output.go b/libs/sync/output.go
index c01b25ef64..e6ac8c56c7 100644
--- a/libs/sync/output.go
+++ b/libs/sync/output.go
@@ -43,9 +43,9 @@ func TextOutput(ctx context.Context, ch <-chan Event, w io.Writer) {
 			// Log only if something actually happened.
 			// Sync events produce an empty string if nothing happened.
 			if str := e.String(); str != "" {
-				bw.WriteString(str)
-				bw.WriteString("\n")
-				bw.Flush()
+				_, _ = bw.WriteString(str)
+				_, _ = bw.WriteString("\n")
+				_ = bw.Flush()
 			}
 		}
 	}