GitHub Copilot en GoLand: la mejor configuración para escribir Go más rápido

Escribir Go en GoLand ya es una experiencia sólida. Agregarle GitHub Copilot encima deja el combo casi injustamente bueno. Pero hay una trampa: el Copilot genérico tiende a sugerir código que no es idiomático de Go (abuso de interfaces, errores que se tragan, generics donde no van). En esta guía te voy a mostrar la configuración que uso para que Copilot tenga cara de gopher, y los atajos que más tiempo ahorran día a día.

Si también trabajás con front-end, vale la pena mirar mi otra guía: GitHub Copilot en WebStorm: la mejor configuración para turbinar tu día a día.

Antes de empezar: requisitos

Para seguir este tutorial, vas a necesitar:

• GoLand 2024.3.6 o superior (recomiendo la build más reciente, que resolvió el conflicto del Tab)
• Go 1.22 o superior instalado y configurado en GoLand
• gopls actualizado (GoLand lo instala automáticamente, pero vale la pena verificar)
• Cuenta en GitHub con licencia activa de Copilot (Individual, Business o Enterprise)
• Conexión a internet estable

Si todavía estás en una versión vieja de GoLand, actualizá antes. Las versiones anteriores tienen conflicto entre Copilot y el Full Line Code Completion peleando por el Tab.

Paso 1: instalar el plugin oficial

1. Abrí GoLand
2. Andá a Settings (Cmd + , en Mac / Ctrl + Alt + S en Windows/Linux)
3. Navegá hasta Plugins
4. Clickeá la pestaña Marketplace
5. Escribí GitHub Copilot en la búsqueda
6. Clickeá Install en el plugin oficial de GitHub
7. A continuación, instalá también GitHub Copilot Chat (viene separado en algunas versiones)
8. Reiniciá GoLand cuando te lo pida

En GoLand 2025+ el plugin GitHub Copilot ya incluye el chat. Si solo ves un plugin llamado GitHub Copilot, ese es el que trae todo junto.

Paso 2: hacer login con tu cuenta de GitHub

Después del reinicio, el ícono de Copilot aparece en la barra inferior derecha.

1. Clickeá el ícono de Copilot
2. Elegí Login to GitHub
3. Copiá el device code que aparece
4. GoLand abre el navegador en github.com/login/device
5. Pegá el código y autorizá el acceso
6. Volvé a GoLand y esperá la confirmación

Cuando el ícono se pone verde, Copilot está listo para usar.

Paso 3: resolver el conflicto con el Full Line Code Completion

Este es el paso más importante para quien quiere el Tab funcionando sin sorpresas. GoLand tiene el Full Line Code Completion nativo, que también ocupa el Tab y compite con Copilot. Si quedás con los dos, nunca sabés cuál va a aceptar.

Opción A (recomendada): desactivar el Full Line

1. Settings > Editor > General > Inline Completion
2. Destildá Enable local full line completion suggestions
3. Aplicá y cerrá

Opción B: mantener los dos con atajos separados

1. Settings > Keymap
2. Buscá Insert Inline Completion
3. Remapeá el de GoLand a un atajo que no entre en conflicto, tipo Cmd + Shift + ] (Mac) / Ctrl + Shift + ] (Windows/Linux)
4. Dejá Apply completions to Editor (el de Copilot) en el Tab

En la práctica, para Go prefiero la opción A: Copilot sabe más sobre el contexto del proyecto entero y el Full Line termina aportando poco.

Paso 4: configuración fina del plugin

Andá a Settings > Tools > GitHub Copilot > Completions y ajustá:

En la sección Languages, mi recomendación para el día a día con Go:

• Activo: Go, Go Module, Go Sum, Go Template, YAML, TOML, Markdown, Dockerfile, SQL, Shell, JSON, Protobuf
• Desactivado: archivos generados automáticamente (*_gen.go, *.pb.go, mock_*.go): Copilot solo estorba acá

Si usás mucho Bazel o Buf, activá también los archivos .bazel, .bzl y buf.yaml.

Paso 5: activar el Copilot Chat y el Agent Mode

Abrí el chat con Ctrl + Shift + C o por la barra lateral derecha, en el ícono de Copilot.

Los tres modos disponibles:

• Ask: resuelve dudas, explica código Go, enseña patrones idiomáticos
• Edit: edita archivos específicos que vos le indicás
• Agent: resuelve tareas enteras (él mismo elige los archivos y ejecuta)

Para habilitar el Agent Mode:

1. Settings > Tools > GitHub Copilot > Chat
2. Tildá Enable Agent Mode
3. Tildá Enable Agent Skills (preview, pero vale mucho)
4. Elegí el modelo por defecto (para Go recomiendo Claude Sonnet por la calidad en refactors y GPT por la velocidad en funciones chicas)

Paso 6: custom instructions idiomáticas para Go

Este es el secreto para que Copilot deje de sugerir código JavaScript disfrazado de Go. Las custom instructions son reglas que Copilot lee antes de cada respuesta.

Configurando en el proyecto

1. En la raíz del proyecto, creá la carpeta .github/ (si no existe)
2. Dentro de ella, creá el archivo copilot-instructions.md
3. Pegá algo así:

# Instrucciones para Copilot

Este es un servicio en Go 1.22+ que expone una API HTTP.

## Stack
- Go 1.22 (standard library preferida siempre que se pueda)
- Router: net/http con el ServeMux nuevo (sin frameworks externos)
- Base de datos: PostgreSQL vía pgx/v5 (sin ORM)
- Logging: log/slog estructurado en JSON
- Tests: testing estándar + testify para assertions

## Patrones idiomáticos obligatorios
- Nunca tragarse errores: siempre retornar o loguear con contexto
- Usar errors.Is / errors.As, nunca comparar errores con ==
- Nunca usar panic en código de producción, solo en init o main
- Pointer receivers solo cuando necesitás mutar o el struct es grande
- Funciones que retornan error deben retornar (T, error), nunca al revés
- Nunca nombrar variables con err genéricos cuando hay más de un error en el scope
- Usar context.Context como primer parámetro en cualquier función que toque I/O

## Tests
- Siempre usar table-driven tests
- Subtests vía t.Run con nombres descriptivos
- Usar t.Helper() en funciones auxiliares de test
- Usar t.Cleanup en vez de defer cuando sea apropiado
- Mocks solo para interfaces de I/O externo, nunca para lógica interna

## Concurrencia
- Nunca crear goroutines sin un plan claro de término (context o WaitGroup)
- Channels con buffer solo con justificación clara
- Proteger estado compartido con sync.Mutex, no con canales si es un lock simple
- Preferir errgroup.Group para fan-out con error

## Qué nunca hacer
- Nunca usar init() para lógica de negocio
- Nunca usar variables globales mutables
- Nunca retornar nil para slice o map cuando el caller espera iterar (retornar vacío)
- Nunca ignorar el retorno de Close() en archivos y conexiones

Guardá, reiniciá el chat y vas a sentir la diferencia en la primera sugerencia.

Configurando globalmente

Para reglas que valen para todos los proyectos Go:

1. Settings > Tools > GitHub Copilot > Customizations
2. En la sección Global Custom Instructions, pegá un conjunto más chico de reglas
3. Aplicá

AGENTS.md y CLAUDE.md

A partir de la versión 2026.2 Copilot también lee AGENTS.md y CLAUDE.md anidados. Si ya usás Claude Code, aprovechá el mismo archivo: Settings > Tools > GitHub Copilot > Customizations > Enable nested AGENTS.md and CLAUDE.md.

Atajos esenciales (los que uso todos los días)

Sugerencias inline

Importante para quienes usan teclado ABNT2: el estándar oficial de Copilot es Option + ], Option + [ y Option + \, pero en el teclado brasileño esas combinaciones generan caracteres tipográficos («, », entre otros) y nunca llegan a Copilot. La solución es agregar Shift a la combinación (queda Shift + Option + ...), que es lo que dejé en la tabla de arriba. Si usás teclado US, podés usar el estándar sin el Shift.

Inline chat (el más poderoso en el día a día con Go)

Con el inline chat seleccionás una función, apretás Ctrl + Shift + I, escribís “escribí table-driven tests para esta función” y Copilot genera directo en el archivo de test.

Chat completo

Atajos customizados para Go

En Settings > Keymap, buscá copilot y vas a ver que el plugin solo expone algunas acciones bindables (copilot.chat.show, copilot.chat.inline, copilot.openCopilot, copilot.applyInlays, copilot.cycleNextInlays, copilot.cyclePrevInlays y copilot.requestCompletions). Las funcionalidades tipo “explain”, “fix”, “generate tests” no son acciones del plugin: son slash commands que escribís dentro del chat (mirá la próxima sección).

Lo que dejo en mi keymap:

Si algún atajo entra en conflicto, Keymap te avisa. Cmd + Shift + K por defecto abre Push… de Git en GoLand: yo prefiero disparar Push por el menú y libero esa tecla para Copilot. Si usás Push por atajo, elegí otra combinación (tipo Cmd + Alt + K).

Una vez que el chat está abierto, los slash commands resuelven el resto:

• /explain explica la función seleccionada
• /fix corrige errores reportados por gopls
• /tests genera table-driven tests
• /doc genera comentario godoc
• /simplify propone una versión más idiomática

Trucos que multiplican la productividad

Los comentarios godoc se convierten en prompts completos

Escribí un godoc descriptivo arriba de la función y Copilot implementa en base a él:

// FetchActivePosts retorna los posts publicados en los últimos 30 días,
// ordenados por fecha de publicación descendente, limitados a 10.
// Retorna error si la base de datos no está disponible o si falla la query.
// El contexto se usa para cancelación.
func (r *PostsRepository) FetchActivePosts(ctx context.Context) ([]Post, error) {
    // Copilot completa acá siguiendo el patrón del resto del repositorio
}

Cuanto más específico sea el godoc, mejor la sugerencia. Agregar el nombre de archivos relevantes al comentario ayuda todavía más.

Table-driven tests con un comando

Seleccioná la función, apretá Ctrl + Shift + I y escribí:

escribí table-driven tests para esta función, cubriendo el camino feliz, error de base de datos, contexto cancelado y slice vacía. Usá testify/require en las assertions.

Copilot genera el archivo _test.go completo, con t.Run y subtests nombrados.

Refactor de errores con Agent Mode

Si el proyecto todavía usa fmt.Errorf("%v") y querés migrar a %w + errors.Is, abrí el chat en Agent Mode y pedí:

Refactorizá todos los wrappers de error del paquete internal/service para que usen %w y reemplazá las comparaciones con == por errors.Is. Mantené los tests pasando.

Vos revisás los cambios archivo por archivo antes de aceptar.

Usá # para contextualizar el chat

En el chat, escribí #internal/repository/posts.go y #internal/service/posts.go para cargar los archivos como contexto. Te ahorra pegar código.

Slash commands dentro del chat

• /tests: genera tests para el código seleccionado
• /doc: genera comentario godoc
• /fix: corrige errores reportados por gopls
• /explain: explica el código seleccionado
• /simplify: propone una versión más idiomática

Para Go, /simplify es oro: suele proponer versiones que eliminan loops innecesarios, aprovechan slices de la stdlib y achican el código sin perder legibilidad.

Generación de mocks y stubs

Si usás interfaces para I/O, seleccioná la interfaz, abrí el inline chat y pedí:

generá un mock para esta interfaz usando testify/mock, en el archivo mocks/mock_repository.go

Respeta las custom instructions y genera algo consistente con el resto del proyecto.

Integración opcional con gopls vía MCP

Si querés que Copilot use el gopls de tu proyecto como fuente de verdad (go to definition, coverage, go test, go mod tidy), podés configurar un servidor MCP como mcp-gopls. Copilot pasa a consultar el LSP de Go antes de sugerir, lo que reduce mucho la alucinación en proyectos grandes. Es avanzado, pero vale la curva de aprendizaje si trabajás en un monorepo Go.

Ajustes finos por tipo de proyecto

Microservicios con net/http

• Dejá en las custom instructions si usás el ServeMux nuevo o gorilla/chi
• Indicá el patrón de middleware (func(http.Handler) http.Handler)
• Avisá si tenés context key tipado o string suelto

gRPC / Protobuf

• Desactivá Copilot en archivos .pb.go (son generados, cualquier sugerencia rompe el generator)
• Dejalo activo en .proto si vas a escribir contratos
• Avisá en las custom instructions qué generator usás (protoc, buf)

CLI (Cobra / urfave/cli)

• Indicá qué biblioteca estás usando
• Avisá si tenés una convención de subcomandos
• Dejá el patrón de error handling explícito (normalmente el run retorna error)

Proyectos con sqlc o GORM

• Importante marcar en las custom instructions qué enfoque usás
• Si es sqlc, listá los archivos donde están las queries
• Si es GORM, avisá qué versión

Problemas comunes y soluciones

El Tab no acepta sugerencias

Full Line Code Completion peleando. Volvé al Paso 3 y aplicá una de las dos soluciones.

Sugerencias poco idiomáticas

Probablemente las custom instructions estén vacías o sean genéricas. Revisá el Paso 6 y detallá los patrones idiomáticos que usás.

Copilot lento en monorepo

1. Abrí solo la carpeta del servicio en el que estás trabajando, no el monorepo entero
2. En Settings > Tools > GitHub Copilot > Completions, destildá Show completions automatically y llamalo a demanda con Shift + Option + \ (Mac) / Shift + Alt + \ (Windows/Linux)
3. Verificá que gopls no esté indexando demasiado (mirá Help > Activity Monitor)

Ícono de Copilot en rojo

1. Clickealo para ver el error
2. Not signed in: volvé a hacer login
3. Network error: verificá el proxy en Settings > Appearance & Behavior > System Settings > HTTP Proxy
4. Quota exceeded: te pasaste del límite mensual

El chat no abre

Instalá el plugin GitHub Copilot Chat por separado (algunas versiones todavía vienen separadas).

Copilot sugiriendo interface{} o any de más

Agregá a las custom instructions: “Evitá any e interface{} excepto cuando realmente no haya un tipo conocido. Preferí tipos concretos o generics tipados.”

Checklist final

• Plugin GitHub Copilot instalado y actualizado
• Plugin GitHub Copilot Chat instalado
• Logueada con la cuenta correcta de GitHub
• Full Line Code Completion desactivado (o remapeado)
• Copilot activo para los lenguajes de tu proyecto Go
• Agent Mode habilitado en Settings
• Archivo .github/copilot-instructions.md creado con reglas idiomáticas
• Atajos customizados configurados en el Keymap
• Ícono verde en la barra inferior
• gopls actualizado y corriendo sin errores

Con este setup cerrado, Copilot deja de ser un auto-completador genérico y se vuelve un pair programmer que entiende Go. En una semana de uso vas a estar escribiendo godocs que generan funciones enteras y usando el inline chat para generar table-driven tests sin sacar las manos del teclado.