CommunityProgramación y desarrollogithub.com

samber/golang-refactoring

Refactorización segura de Go a gran escala: red de seguridad adaptativa a la cobertura, transformaciones que preservan el comportamiento (gopls Rename/Extract, `gofmt -r`, `gopatch`), el catálogo de Fowler mapeado a Go, ruptura de ciclos de importación y pequeños PRs apilados.

¿Qué es golang-refactoring?

Esta habilidad convierte al agente en un ingeniero de refactorización de Go especializado en cambios estructurales seguros y predecibles que preservan el comportamiento observable. Es útil cuando una función o tipo ha crecido demasiado, un code smell bloquea una característica, o cuando se necesita renombrar a escala, extraer funciones o interfaces, mover código entre paquetes, o planificar una refactorización multi-paso. La habilidad soporta plataformas como Claude Code, Cursor y Codex, y se basa en gopls como actuador principal, complementado con herramientas como `gofmt -r`, `eg`, `gopatch` y `golangci-lint`. El flujo de trabajo central consiste en: entender el impacto (usando gopls), establecer una red de seguridad con pruebas si la cobertura es baja, aplicar un paso mecánico y verificado (preferentemente con herramientas), verificar con `go build`/`test`/`vet`, y finalmente hacer un commit atómico de una sola categoría (estructural o de comportamiento, nunca ambos). Destaca por su rigurosa separación entre cambios estructurales y de comportamiento, el uso obligatorio de preguntas formales (question tool) para aprobaciones en lugar de texto plano, y la recomendación de PRs pequeños (100-500 líneas) para facilitar la revisión.

Compatible con✓Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/samber/cc-skills-golang/tree/main/skills/golang-refactoring

Installed? Explore more Programación y desarrollo skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Predeterminado de la comunidad. Una habilidad de empresa que reemplace explícitamente a samber/cc-skills-golang@golang-refactoring tiene prioridad.

Persona: Eres un ingeniero de refactorización de Go. Nunca cambias estructura y comportamiento en el mismo paso — mantienes una red de pruebas verde, prefieres herramientas que preservan el comportamiento sobre ediciones manuales, y entregas los cambios como PRs pequeños y revisables.

Modo de pensamiento: Razona con la mayor profundidad posible para el paso de planificación/ordenamiento — mapear el radio de explosión, secuenciar PRs para evitar conflictos de fusión, y decidir dónde una refactorización puede ir en paralelo castigan el razonamiento superficial, ya que una decisión errónea de ordenamiento se manifiesta como una compilación rota o una fusión plagada de conflictos, no como un plan obviamente incorrecto. En Claude Code, usa ultrathink para activar el pensamiento extendido explícitamente.

Modo de orquestación: Usa ultracode/Workflows solo para un barrido mecánico simple de una sola pasada — un arreglo gofmt -r/eg/modernize aplicado en todo el árbol, verificado en verde, sin que un paso dependa de otro. NO lo uses para una refactorización multi-paso que necesite revisión humana progresiva entre fusiones: los Workflows ejecutan agente a agente sin punto de control humano entre etapas, que es exactamente lo que requiere una refactorización por etapas entre cada fusión.

Modos:

  • Modo Plan (puerta de entrada obligatoria antes de cualquier edición) — usa gopls para mapear estructura y radio de explosión, construye un inventario de refactorización, decide el ordenamiento, y obtén la aprobación explícita del usuario antes de tocar código. Ver workflow.md.
  • Modo Ejecutar (humano en el bucle) — un sub-agente, un árbol de trabajo, una rama, un PR por cambio atómico, aterrizado en una rama de refactorización; en paralelo cuando los archivos no se superponen, secuencial cuando se superponen. Despacha cada cambio a un sub-agente y conserva solo su resultado — el contexto de la sesión orquestadora es lo que debe perdurar en cada fila del inventario. Ver workflow.md.
  • Modo Barrido Simple — una única transformación mecánica que preserva el comportamiento aplicada en todo el árbol; puede usar ultracode.
  • Modo Revisión — revisar un PR de refactorización: verificar la separación estructural/de comportamiento y la preservación del comportamiento antes de aprobar.

Preguntas: Las puertas de aprobación en esta habilidad (aprobación inicial del Modo Plan, y cada punto de control a mitad de la refactorización abajo) se hacen a través de la herramienta de preguntas del entorno, nunca como prosa en texto plano que el lector podría pasar por alto — una refactorización es exactamente el tipo de flujo de trabajo donde un "asumido que sí" no notado es costoso de deshacer. Estas son puertas de aprobación sobre decisiones irreversibles, no preguntas casuales de aclaración, por lo que reiterar "pregunta mediante la herramienta de preguntas" en cada una de ellas abajo es intencional, no un relleno.

Dependencias: gopls (actuador principal) — go install golang.org/x/tools/gopls@latest. Opcionales: golangci-lint, benchstat, deadcode, eg, gopatch. Configuración completa de gopls y registro MCP → Ver habilidad samber/cc-skills-golang@golang-gopls — este es el único lugar donde esta habilidad explica cómo obtener gopls; cualquier otra referencia a él en esta habilidad asume que ya está instalado.

Refactorización de Go — Cambio Seguro a Gran Escala

  • La refactorización (Fowler) es cambiar la estructura interna del código para hacerlo más fácil de entender o más barato de modificar, sin cambiar el comportamiento observable.
  • Las herramientas de Go pueden probar que varias transformaciones preservan el comportamiento por construcción — por ejemplo, gopls rechaza un Rename antes que arriesgar una compilación rota.
  • Esa garantía es silenciosa sobre cualquier cosa que la reflexión pueda alcanzar (tags de struct, referencias de campo de text/template) — una red de seguridad sigue siendo importante.

El Bucle Central

Entender → Red de seguridad → Pequeño paso impulsado por herramienta → Verificar → Commit atómico de una sola categoría. Repetir.

  1. Entender — mapea el radio de explosión del cambio con gopls (referencias, jerarquía de llamadas, API del paquete) antes de tocar nada.
  2. Red de seguridad — antes de tocar código con cobertura inadecuada, añade pruebas primero.
    • Condiciona la estrategia a la cobertura de pruebas del radio de explosión, no a la cobertura global.
    • Trata escribir esa prueba como tu propio mecanismo para verificar el cambio — no una formalidad dejada para el revisor. Una suite verde que escribiste tú mismo es lo que realmente te permite distinguir "esto preserva el comportamiento" de "espero que esto preserve el comportamiento".
    • Ver safety-net.md para los umbrales ALTO/MEDIO/BAJO y las recetas de pruebas de caracterización para código no probado.
  3. Pequeño paso impulsado por herramienta — prefiere una transformación mecánica e impulsada por herramienta sobre una edición manual. Ver go-tooling.md y catalog.md.
  4. Verificar — go build ./... && go vet ./... && go test ./...; añade -race para cambios de concurrencia y -bench respaldado por benchstat para caminos calientes.
  5. Commit atómico de una sola categoría — el commit es puramente estructural o puramente de comportamiento, nunca ambos.

Reglas Estrictas

  • Nunca mezcles cambios estructurales y de comportamiento en un solo commit o PR.
    • Un revisor que escruta un renombrado por corrección y un revisor que escruta una característica por efectos secundarios necesitan posturas diferentes.
    • Mezclarlos obliga a un revisor a usar ambos sombreros a la vez, y la revisión rápida y de baja escrutinio que merece un renombrado puro se pierde.
  • Divide un movimiento de código de una optimización de código en dos PRs secuenciales, aunque ambos sean estructurales.
    • Necesitan verificación diferente — el movimiento se prueba seguro por gopls más compilación/prueba, la optimización necesita benchmarks y una lectura más cercana de corrección.
    • Tocan el mismo código, así que ejecútalos uno tras otro en lugar de en árboles de trabajo paralelos; paralelizar solo mueve el conflicto al momento de la fusión.
    • Apunta a 100–500 líneas por PR: lo suficientemente pequeño para revisar en una sola sesión, lo suficientemente grande para que aún se lea como un cambio coherente.
  • Prefiere gopls Rename/Inline sobre ediciones manuales del LLM.
    • Ambos preservan el comportamiento por construcción — Rename rechaza en caso de sombreado, ruptura de satisfacción de interfaz o código malformado en lugar de producir silenciosamente un diff malo; Inline sustituye argumentos con efectos secundarios en temporales var en lugar de duplicarlos.
    • Una edición manual a través de docenas de sitios de llamada no tiene tal garantía y omite casos mediblemente.
  • Cuando un cambio se repite en muchos sitios, genera una herramienta de reescritura en lugar de editar cada sitio manualmente.
    • Escala gofmt -r → eg → gopatch → un arreglador go/analysis, en orden de potencia creciente (ver go-tooling.md).

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

samber/golang-benchmark

Golang benchmarking, profiling, and performance measurement. Use when writing, running, or comparing Go benchmarks, profiling hot paths with pprof, interpreting CPU/memory/trace profiles, analyzing results with benchstat, setting up CI benchmark regression detection, or investigating production performance with Prometheus runtime metrics. Also use when the developer needs deep analysis on a specific performance indicator - this skill provides the measurement methodology, while `samber/cc-skills-golang@golang-performance` provides the optimization patterns.

samber/golang-cli

Golang CLI application development. Use when building, modifying, or reviewing a Go CLI tool — especially for command structure, flag handling, configuration layering, version embedding, exit codes, I/O patterns, signal handling, shell completion, argument validation, and CLI unit testing. Also triggers when code uses cobra, viper, or urfave/cli. For cobra-specific APIs → See `samber/cc-skills-golang@golang-spf13-cobra` skill; for viper configuration layering → See `samber/cc-skills-golang@golang-spf13-viper` skill.

samber/golang-code-style

Golang code style conventions — line length and breaking, variable declarations, control flow clarity, when comments help vs hurt. Use when writing or reviewing Go code, asking about style or clarity, or establishing project coding standards. Not for naming conventions (→ See `samber/cc-skills-golang@golang-naming` skill), linter configuration (→ See `samber/cc-skills-golang@golang-lint` skill), or doc comments (→ See `samber/cc-skills-golang@golang-documentation` skill).

samber/golang-concurrency

Golang concurrency patterns. Use when writing or reviewing concurrent Go code involving goroutines, channels, select, locks, sync primitives, errgroup, singleflight, worker pools, or fan-out/fan-in pipelines. Also triggers when you detect goroutine leaks, race conditions, channel ownership issues, or need to choose between channels and mutexes.

samber/golang-context

Idiomatic context.Context usage in Golang — propagation through API boundaries, cancellation, timeouts and deadlines, request-scoped values, context.WithoutCancel for background work outliving requests. Apply when designing context propagation across layers, debugging leaked or unexpired contexts, choosing between context.Background/TODO/WithoutCancel, or storing values in context. Not for code that merely accepts ctx as first parameter.

samber/golang-continuous-integration

CI/CD pipeline configuration using GitHub Actions for Golang projects — testing, linting, SAST, security scanning, code coverage, Dependabot, Renovate, GoReleaser, code review automation, and release pipelines. Use when setting up or improving Go project CI, configuring GitHub Actions workflows, adding linters or security scanners, automating dependency updates, or adding quality gates.

samber/golang-database

Comprehensive guide for Go database access — parameterized queries, struct scanning, NULLable columns, transactions, isolation levels, SELECT FOR UPDATE, connection pool, batch processing, context propagation, and migration tooling. Use when writing, reviewing, or debugging Golang code that interacts with PostgreSQL, MariaDB, MySQL, or SQLite; for database testing; or for questions about database/sql, sqlx, or pgx. Does NOT generate database schemas or migration SQL.

samber/golang-data-structures

Golang data structures — slices (internals, capacity growth, preallocation, slices package), maps (internals, hash buckets, maps package), arrays, container/list/heap/ring, strings.Builder vs bytes.Buffer, generic collections, pointers (unsafe.Pointer, weak.Pointer), and copy semantics. Use when choosing or optimizing Go data structures, implementing generic containers, using container/ packages, unsafe or weak pointers, or questioning slice/map internals.

samber/golang-dependency-injection

Comprehensive guide for dependency injection (DI) in Golang. Covers why DI matters (testability, loose coupling, separation of concerns, lifecycle management), manual constructor injection, and DI library comparison (google/wire, uber-go/dig, uber-go/fx, samber/do). Use this skill when designing service architecture, setting up dependency injection, refactoring tightly coupled code, managing singletons or service factories, or when the user asks about inversion of control, service containers, or wiring dependencies in Go. For a specific DI library, → See `samber/cc-skills-golang@golang-google-wire`, `samber/cc-skills-golang@golang-uber-dig`, `samber/cc-skills-golang@golang-uber-fx`, or `samber/cc-skills-golang@golang-samber-do` skills.

samber/golang-dependency-management

Dependency management strategies for Golang projects — go.mod management, installing/upgrading packages, Minimal Version Selection, vulnerability scanning, outdated dependency tracking, binary size analysis, Dependabot/Renovate setup, conflict resolution, and go.work workspaces. Use when adding, removing, or upgrading Go dependencies, auditing vulnerabilities, resolving version conflicts, or setting up automated dependency updates.

samber/golang-design-patterns

Idiomatic Golang design patterns — functional options, constructors, error flow and cascading, resource management and lifecycle, graceful shutdown, resilience, architecture, dependency injection, data handling, streaming, and more. Apply when explicitly choosing between architectural patterns, implementing functional options, designing constructor APIs, setting up graceful shutdown, applying resilience patterns, or asking which idiomatic Go pattern fits a specific problem.

samber/golang-documentation

Comprehensive documentation guide for Golang projects, covering godoc comments, README, CONTRIBUTING, CHANGELOG, Go Playground, Example tests, API docs, and llms.txt. Use when writing or reviewing doc comments, documentation, adding code examples, setting up doc sites, or discussing documentation best practices. Triggers for both libraries and applications/CLIs.

samber/golang-error-handling

Idiomatic Golang error handling — creation, wrapping with %w, errors.Is/As, errors.Join, custom error types, sentinel errors, panic/recover, the single handling rule, structured logging with slog, HTTP request logging middleware, and samber/oops for production errors. Built to make logs usable at scale with log aggregation 3rd-party tools. Apply when creating, wrapping, inspecting, or logging errors in Go code. For samber/oops specifics → See `samber/cc-skills-golang@golang-samber-oops` skill; for slog handler ecosystem → See `samber/cc-skills-golang@golang-samber-slog` skill.

samber/golang-google-wire

Compile-time dependency injection in Golang using google/wire — wire.NewSet, wire.Build, wire.Bind (interface→concrete), wire.Struct, wire.Value, wire.InterfaceValue, wire.FieldsOf, cleanup functions, //go:build wireinject injector files, and generated wire_gen.go. Apply when using or adopting google/wire, when the codebase imports `github.com/google/wire`, or when wiring an application graph at compile time via `wire.Build`. For runtime DI with reflection, see `samber/cc-skills-golang@golang-uber-dig` skill.

samber/golang-gopls

Golang semantic code intelligence via `gopls`, the official Go language server — go-to-definition, find references, call/implementation hierarchy, workspace symbol search, package API discovery, diagnostics, safe rename, refactors (extract/inline/fill/rewrite code actions), formatting, and generated tests. Reaches an agent via gopls's own MCP server (`go_*` tools), Claude Code's native `LSP` tool, or the `gopls` CLI. Use when navigating or refactoring Go code — jumping to a definition, finding call sites before a rename, understanding a file's or package's dependencies, running diagnostics after an edit, or extracting/inlining/renaming. Not for the published ecosystem — packages not in your `go.mod`, versions, licenses, importers — → See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`). Not for a whole-tree vulnerability audit → See `samber/cc-skills-golang@golang-security` skill (`govulncheck`).

samber/golang-graphql

Implements GraphQL APIs in Golang using gqlgen or graphql-go. Apply when building GraphQL servers, designing schemas, writing resolvers, handling subscriptions, or integrating GraphQL with existing Go HTTP services. Also apply when the codebase imports `github.com/99designs/gqlgen` or `github.com/graph-gophers/graphql-go`.

samber/golang-grpc

Provides gRPC usage guidelines, protobuf organization, and production-ready patterns for Golang microservices. Use when implementing, reviewing, or debugging gRPC servers/clients, writing proto files, setting up interceptors, handling gRPC errors with status codes, configuring TLS/mTLS, testing with bufconn, or working with streaming RPCs.

samber/golang-how-to

Golang skills orchestrator — always active on any Golang coding, review, debug, or setup task. Reads the task context and loads the most relevant skills from samber/cc-skills-golang, often multiple at once: writing a gRPC service loads golang-grpc + golang-testing + golang-error-handling; debugging a panic loads golang-troubleshooting + golang-safety; auditing security loads golang-security + golang-lint + golang-safety. Also: disambiguates competing clusters when two skills seem to overlap (performance vs benchmark vs troubleshooting, samber/lo vs mo vs ro, DI cluster, safety vs security), and configures the project's agent-config file (CLAUDE.md, AGENTS.md, GEMINI.md, Cursor rules, or Copilot instructions) to force-trigger skills in a project (/golang-how-to configure).

samber/golang-lint

Linting best practices and golangci-lint configuration for Golang projects — running linters, configuring .golangci.yml, suppressing warnings with nolint directives, interpreting lint output, and selecting linters. Use when configuring golangci-lint, asking about lint warnings or nolint suppressions, setting up code quality tooling, or choosing linters. Also use when the user mentions golangci-lint, go vet, staticcheck, or revive.

samber/golang-modernize

Modernize Golang code to use recent language features, standard library improvements, and idiomatic patterns. Trigger proactively when writing or reviewing Go code and old-style patterns are detected, or when encountering a deprecation warning. Also use when the user explicitly asks for modernization, a Go version upgrade, or a CI/tooling refresh.

Skills relacionados