samber

Technical videos lose clarity when narration, screen actions, and timing are planned separately. This skill combines them into a script with recording states and cuts.

Developer relations teams can spread limited capacity across activities without a clear business purpose. This skill guides interviews and decisions into a focused, reviewable charter.

Developers can finish a walkthrough without learning how to repeat the task independently. This skill structures tutorials around demonstrable objectives, progressive exercises, resumable checkpoints, and learner verification.

Developer-content plans slip when writing commitments ignore technical review and fixed deadlines. This skill builds quarterly publishing slots with named owners, reviewers, capacity estimates, and reserved reactive time.

Plain Go errors can lose diagnostic context and produce inconsistent public messages. This skill guides structured error creation, wrapping, context propagation, and logging with samber/oops.

Optional values and repeated error checks can make multi-step Go workflows difficult to maintain. This skill guides explicit type choices and composable samber/mo pipelines.

Repeated backend reads can increase latency and overload services. This skill guides samber/hot cache design with workload-based eviction, expiration, loaders, concurrency controls, and monitoring.

Manual service wiring becomes difficult to maintain as Go applications grow. This skill guides samber/do v2 registration, lifecycle management, modular organization, and isolated testing.

Large Go refactors can break callers, hide behavior changes, and create conflicting pull requests. This skill guides tool-driven changes with targeted tests and staged human review.

Missing telemetry makes production failures difficult to diagnose. This skill guides Go instrumentation with structured logs, metrics, traces, profiling, and analytics privacy considerations.

Go tasks often span several specialties, making skill selection difficult. This orchestrator maps task intent to complementary skills and explains overlapping responsibilities.

Go dependency graphs become difficult to maintain as constructors and interfaces change. This skill guides Wire provider design, injector generation, cleanup handling, and testing.

Hidden dependencies and global state make Go services difficult to test and maintain. This skill guides constructor injection, library selection, and incremental refactoring with practical examples.

Go database code can hide query vulnerabilities, connection leaks, and concurrency errors. This skill guides explicit SQL access, transaction handling, performance reviews, and database testing.

Go test suites can miss edge cases, leak goroutines, and fail unpredictably. This skill guides test design, review, and debugging with concrete Go testing patterns.

Go services can expose sensitive data through unsafe input handling, weak authentication, and insecure configuration. This skill guides structured reviews, threat modeling, and mitigation planning.

Unclear package boundaries make Go projects harder to maintain. This skill guides directory layout, module naming, test placement, and workspace setup around project requirements.

Inconsistent Go names make APIs and reviews harder to understand. This skill provides focused conventions and examples for choosing clear, consistent names.

Go services become harder to maintain when initialization, resource ownership, and architectural boundaries are unclear. This skill guides practical pattern selection with focused Go examples.

Broken context propagation leaves downstream work running after requests end. This skill guides context lifecycles across Go handlers, services, and databases.

Concurrent Go code can hide goroutine leaks, shared-state races, and blocked pipelines. This skill guides implementation and review with lifecycle checklists and synchronization examples.

Complex Go services need predictable dependency wiring and lifecycle management. This skill provides practical Uber Fx guidance for modular applications, graceful shutdown, and focused tests.

Go API annotations often become incomplete, inconsistent, or difficult to generate. This skill guides accurate OpenAPI documentation, Swagger UI wiring, and schema generation with swaggo.

Poor type boundaries make Go code harder to test, extend, and review. This skill applies focused interfaces, useful structs, safe assertions, and clear composition patterns.