GitHub Copilot no GoLand: a melhor configuração para escrever Go mais rápido

Escrever Go no GoLand já é uma experiência sólida. Adicionar o GitHub Copilot em cima deixa o combo quase injusto de bom. Mas tem uma pegadinha: o Copilot genérico tende a sugerir código que não é idiomático de Go (abuso de interfaces, erros engolidos, generics onde não cabe). Neste guia eu vou te mostrar a configuração que eu uso pra deixar o Copilot com cara de gopher, e os atalhos que mais economizam tempo no dia a dia.

Se você também trabalha com front-end, vale dar uma olhada no meu outro guia: GitHub Copilot no WebStorm: a melhor configuração para turbinar seu dia a dia.

Antes de começar: requisitos

Pra seguir esse tutorial, você vai precisar de:

• GoLand 2024.3.6 ou superior (recomendo a build mais recente, que resolveu o conflito do Tab)
• Go 1.22 ou superior instalado e configurado no GoLand
• gopls atualizado (o GoLand instala automaticamente, mas vale conferir)
• Conta no GitHub com licença ativa do Copilot (Individual, Business ou Enterprise)
• Conexão com a internet estável

Se você ainda está numa versão antiga do GoLand, atualize antes. Versões anteriores têm conflito entre Copilot e Full Line Code Completion disputando o Tab.

Passo 1: instalar o plugin oficial

1. Abra o GoLand
2. Vá em Settings (Cmd + , no Mac / Ctrl + Alt + S no Windows/Linux)
3. Navegue até Plugins
4. Clique na aba Marketplace
5. Digite GitHub Copilot na busca
6. Clique em Install no plugin oficial da GitHub
7. Na sequência, instale também GitHub Copilot Chat (ele vem separado em algumas versões)
8. Reinicie o GoLand quando for pedido

No GoLand 2025+ o plugin GitHub Copilot já inclui o chat. Se você só vê um plugin chamado GitHub Copilot, é ele que traz tudo junto.

Passo 2: fazer login com sua conta do GitHub

Depois do restart, o ícone do Copilot aparece na barra inferior direita.

1. Clique no ícone do Copilot
2. Escolha Login to GitHub
3. Copie o device code que aparece
4. O GoLand abre o navegador em github.com/login/device
5. Cole o código e autorize o acesso
6. Volte pro GoLand e aguarde a confirmação

Quando o ícone ficar verde, o Copilot está pronto pra uso.

Passo 3: resolver o conflito com o Full Line Code Completion

Esse é o passo mais importante pra quem quer o Tab funcionando sem surpresa. O GoLand tem o Full Line Code Completion nativo, que também ocupa o Tab e compete com o Copilot. Se ficar nos dois, você nunca sabe qual vai aceitar.

Opção A (recomendada): desligar o Full Line

1. Settings > Editor > General > Inline Completion
2. Desmarque Enable local full line completion suggestions
3. Aplique e feche

Opção B: manter os dois com atalhos separados

1. Settings > Keymap
2. Procure Insert Inline Completion
3. Remapeie o do GoLand pra um atalho que não conflite, tipo Cmd + Shift + ] (Mac) / Ctrl + Shift + ] (Windows/Linux)
4. Deixe Apply completions to Editor (do Copilot) no Tab

Na prática, pra Go eu prefiro a opção A: o Copilot sabe mais sobre o contexto do projeto todo e o Full Line acaba adicionando pouco.

Passo 4: configuração fina do plugin

Vá em Settings > Tools > GitHub Copilot > Completions e ajuste:

Na seção Languages, a minha recomendação pro dia a dia com Go:

• Ativo: Go, Go Module, Go Sum, Go Template, YAML, TOML, Markdown, Dockerfile, SQL, Shell, JSON, Protobuf
• Desativado: arquivos gerados automaticamente (*_gen.go, *.pb.go, mock_*.go): o Copilot só atrapalha aqui

Se você usa muito Bazel ou Buf, ative também os arquivos .bazel, .bzl, buf.yaml.

Passo 5: ativar o Copilot Chat e o Agent Mode

Abra o chat com Ctrl + Shift + C ou pela barra lateral direita, no ícone do Copilot.

Os três modos disponíveis:

• Ask: tira dúvidas, explica código Go, ensina padrões idiomáticos
• Edit: edita arquivos específicos que você apontar
• Agent: resolve tarefas inteiras (ele mesmo escolhe os arquivos e executa)

Para habilitar o Agent Mode:

1. Settings > Tools > GitHub Copilot > Chat
2. Marque Enable Agent Mode
3. Marque Enable Agent Skills (preview, mas vale muito)
4. Escolha o modelo padrão (pra Go eu recomendo Claude Sonnet pela qualidade em refactors e GPT pela velocidade em funções menores)

Passo 6: custom instructions idiomáticas pra Go

Esse é o segredo pra o Copilot parar de sugerir código JavaScript disfarçado de Go. Custom instructions são regras que o Copilot lê antes de cada resposta.

Configurando no projeto

1. Na raiz do projeto, crie a pasta .github/ (se não existir)
2. Dentro dela, crie o arquivo copilot-instructions.md
3. Cole algo como:

# Instruções para o Copilot

Este é um serviço em Go 1.22+ que expõe uma API HTTP.

## Stack
- Go 1.22 (standard library preferida sempre que possível)
- Router: net/http com ServeMux novo (sem frameworks externos)
- Banco: PostgreSQL via pgx/v5 (sem ORM)
- Logging: log/slog estruturado em JSON
- Testes: testing padrão + testify para assertions

## Padrões idiomáticos obrigatórios
- Nunca engola erros: sempre retorne ou logue com contexto
- Use errors.Is / errors.As, nunca compare erros com ==
- Nunca use panic em código de produção, apenas em init ou main
- Receivers pointer só quando precisar mutar ou o struct for grande
- Funções que retornam error devem retornar (T, error), nunca o contrário
- Nunca nomeie variáveis com err genéricos quando há mais de um erro no escopo
- Use context.Context como primeiro parâmetro em qualquer função que toque I/O

## Testes
- Sempre use table-driven tests
- Subtests via t.Run com nomes descritivos
- Use t.Helper() em funções auxiliares de teste
- Use t.Cleanup ao invés de defer quando apropriado
- Mocks apenas para interfaces de I/O externo, nunca para lógica interna

## Concorrência
- Nunca crie goroutines sem um plano claro de término (context ou WaitGroup)
- Channels buferizados só com justificativa clara
- Proteja estado compartilhado com sync.Mutex, não com canais se for lock simples
- Prefira errgroup.Group para fan-out com erro

## O que nunca fazer
- Nunca usar init() para lógica de negócio
- Nunca usar variáveis globais mutáveis
- Nunca retornar nil para slice ou map quando o chamador espera iterar (retorne vazio)
- Nunca ignorar o retorno de Close() em arquivos e conexões

Salve, reinicie o chat e vai sentir a diferença na primeira sugestão.

Configurando globalmente

Pra regras que valem pra todos os projetos Go:

1. Settings > Tools > GitHub Copilot > Customizations
2. Na seção Global Custom Instructions, cole um conjunto menor de regras
3. Aplique

AGENTS.md e CLAUDE.md

A partir da versão 2026.2 o Copilot lê também AGENTS.md e CLAUDE.md aninhados. Se você já usa Claude Code, reaproveita o mesmo arquivo: Settings > Tools > GitHub Copilot > Customizations > Enable nested AGENTS.md and CLAUDE.md.

Atalhos essenciais (os que eu uso todo dia)

Sugestões inline

Importante pra quem usa teclado ABNT2: o padrão oficial do Copilot é Option + ], Option + [ e Option + \, mas no teclado brasileiro essas combinações geram caracteres tipográficos («, », entre outros) e nunca chegam no Copilot. A solução é adicionar Shift na combinação (vira Shift + Option + ...), que é o que deixei na tabela acima. Se você usar teclado US, pode usar o padrão sem o Shift.

Inline chat (o mais poderoso no dia a dia de Go)

Com o inline chat você seleciona uma função, aperta Ctrl + Shift + I, digita “escreve table-driven tests pra essa função” e o Copilot gera direto no arquivo de teste.

Chat completo

Atalhos customizados pra Go

Em Settings > Keymap, busca copilot e você vai ver que o plugin só expõe algumas ações bindáveis (copilot.chat.show, copilot.chat.inline, copilot.openCopilot, copilot.applyInlays, copilot.cycleNextInlays, copilot.cyclePrevInlays e copilot.requestCompletions). As funcionalidades tipo “explain”, “fix”, “generate tests” não são ações do plugin: são slash commands que você digita dentro do chat (veja a próxima seção).

O que eu deixo no meu keymap:

Se algum atalho conflitar, o Keymap avisa. O Cmd + Shift + K por padrão abre o Push… do Git no GoLand: eu prefiro acionar Push pelo menu e libero a tecla pro Copilot. Se você usa Push pelo atalho, escolha outra combinação (tipo Cmd + Alt + K).

Depois que o chat está aberto, os slash commands resolvem o resto:

• /explain explica a função selecionada
• /fix corrige erros apontados pelo gopls
• /tests gera table-driven tests
• /doc gera comentário godoc
• /simplify propõe uma versão mais idiomática

Truques que multiplicam produtividade

Comentários godoc viram prompts completos

Escreva um godoc descritivo acima da função e o Copilot implementa baseado nele:

// FetchActivePosts retorna os posts publicados nos últimos 30 dias,
// ordenados por data de publicação decrescente, limitados a 10.
// Retorna erro se o banco estiver indisponível ou se houver falha
// na query. O contexto é usado para cancelamento.
func (r *PostsRepository) FetchActivePosts(ctx context.Context) ([]Post, error) {
    // o Copilot preenche aqui seguindo o padrão do resto do repositório
}

Quanto mais específico o godoc, melhor a sugestão. Colocar o nome de arquivos relevantes no comentário ajuda ainda mais.

Table-driven tests com um comando

Seleciona a função, aperta Ctrl + Shift + I e digita:

escreve table-driven tests pra essa função, cobrindo caminho feliz, erro de banco, contexto cancelado e slice vazia. Usa testify/require nas assertions.

O Copilot gera o arquivo _test.go completo, já com t.Run e subtests nomeados.

Refactor de erros com Agent Mode

Se o projeto ainda usa fmt.Errorf("%v") e você quer migrar pra %w + errors.Is, abra o chat em Agent Mode e peça:

Refatora todos os wrappers de erro no pacote internal/service pra usar %w e substitua comparações com == por errors.Is. Mantém os testes passando.

Você revisa as mudanças arquivo por arquivo antes de aceitar.

Use # pra contextualizar o chat

No chat, digite #internal/repository/posts.go e #internal/service/posts.go pra carregar os arquivos como contexto. Evita ficar colando código.

Slash commands dentro do chat

• /tests: gera testes pro código selecionado
• /doc: gera comentário godoc
• /fix: corrige erros apontados pelo gopls
• /explain: explica o código selecionado
• /simplify: propõe versão mais idiomática

Pra Go, o /simplify é ouro: ele costuma propor versões que removem loops desnecessários, aproveitam slices da stdlib e enxugam código sem perder legibilidade.

Geração de mocks e stubs

Se você usa interfaces pra I/O, seleciona a interface, abre o inline chat e pede:

gera um mock dessa interface usando testify/mock, no arquivo mocks/mock_repository.go

Ele respeita as custom instructions e gera algo consistente com o resto do projeto.

Integração opcional com gopls via MCP

Se você quer que o Copilot use o gopls do seu projeto como fonte de verdade (go to definition, coverage, go test, go mod tidy), dá pra configurar um servidor MCP como o mcp-gopls. O Copilot passa a consultar o LSP do Go antes de sugerir, o que reduz muito alucinação em projetos grandes. É avançado, mas vale a curva de aprendizado se você trabalha num monorepo Go.

Ajustes finos por tipo de projeto

Microserviços com net/http

• Deixe o custom instructions explicando se você usa o ServeMux novo ou gorilla/chi
• Informe o padrão de middleware (func(http.Handler) http.Handler)
• Avise se tem context key tipado ou string solta

gRPC / Protobuf

• Desative o Copilot em arquivos .pb.go (são gerados, qualquer sugestão quebra o generator)
• Deixe ativo em .proto se for escrever contratos
• Avise no custom instructions qual gerador usa (protoc, buf)

CLI (Cobra / urfave/cli)

• Informe qual biblioteca está usando
• Avise se tem uma convenção de subcomandos
• Deixe o padrão de error handling explícito (normalmente o run retorna error)

Projetos com sqlc ou GORM

• Importante marcar no custom instructions qual abordagem você usa
• Se for sqlc, lista os arquivos onde ficam as queries
• Se for GORM, avise qual versão

Problemas comuns e soluções

O Tab não aceita sugestão

Full Line Code Completion brigando. Volte no Passo 3 e aplique uma das duas soluções.

Sugestões pouco idiomáticas

Provavelmente o custom instructions está vazio ou genérico. Revise o Passo 6 e detalhe os padrões idiomáticos que você usa.

Copilot lento em monorepo

1. Abra só a pasta do serviço que você está tocando, não o monorepo inteiro
2. Em Settings > Tools > GitHub Copilot > Completions, desmarque Show completions automatically e chame sob demanda com Shift + Option + \ (Mac) / Shift + Alt + \ (Windows/Linux)
3. Confira se o gopls não está indexando muita coisa (veja Help > Activity Monitor)

Ícone do Copilot vermelho

1. Clique nele pra ver o erro
2. Not signed in: refaça login
3. Network error: confira proxy em Settings > Appearance & Behavior > System Settings > HTTP Proxy
4. Quota exceeded: você esbarrou no limite mensal

Chat não abre

Instale o plugin GitHub Copilot Chat separadamente (algumas versões ainda vêm separadas).

Copilot sugerindo interface{} ou any demais

Acrescente no custom instructions: “Evite any e interface{} exceto quando realmente não houver tipo conhecido. Prefira tipos concretos ou generics tipados.”

Checklist final

• Plugin GitHub Copilot instalado e atualizado
• Plugin GitHub Copilot Chat instalado
• Logada com a conta correta do GitHub
• Full Line Code Completion desativado (ou remapeado)
• Copilot ativo pras linguagens do seu projeto Go
• Agent Mode habilitado nas Settings
• Arquivo .github/copilot-instructions.md criado com regras idiomáticas
• Atalhos customizados configurados no Keymap
• Ícone verde na barra inferior
• gopls atualizado e rodando sem erro

Com esse setup fechado, o Copilot para de ser um auto-completador genérico e vira um pair programmer que entende Go. Em uma semana de uso você vai estar escrevendo godocs que geram funções inteiras e usando o inline chat pra gerar table-driven tests sem tirar as mãos do teclado.