Fala dataholics! Seguindo a série do ecossistema, hoje é a vez do Copilot que mais gente já usou sem nem perceber que fazia parte dessa família: o GitHub Copilot. Ele nasceu como aquele autocompletar esperto dentro do editor e, sinceramente, virou outra coisa. Hoje ele recebe uma tarefa e trabalha sozinho, então vale entender essa evolução, porque muita gente ainda acha que o GitHub Copilot é só o "tab tab tab" de completar linha.

O que veremos nesse post:

• De onde ele veio: o autocomplete

• O agent mode dentro do IDE

• O coding agent que abre PR sozinho

• Minha leitura de quem usa no dia a dia

---

De onde ele veio

A primeira versão do GitHub Copilot era um autocompletar turbinado. Você começava a escrever uma função e ele sugeria o resto da linha, às vezes o bloco inteiro, em cinza, e você apertava Tab pra aceitar. Já era ganho de produtividade absurdo, principalmente pra cuspir boilerplate, teste repetitivo e aquele código chato que todo mundo escreve no piloto automático. Mas ele só reagia ao que você estava digitando naquele arquivo, não enxergava o projeto inteiro.

---

O agent mode

Aí ele cresceu de verdade. O agent mode, que já está GA no VS Code e no JetBrains, não fica só completando linha: você descreve a tarefa e ele decide quais arquivos mexer, roda comando no terminal, olha o erro que voltou e tenta de novo, iterando até fechar. Ele passou de "sugere o que vem depois do cursor" pra "resolve a tarefa de ponta a ponta dentro do editor", com você acompanhando e aprovando os passos.

---

O coding agent que abre PR sozinho

E tem o nível que mais impressiona: o coding agent. Você atribui uma issue do GitHub pra ele, do jeitinho que atribuiria pra um colega, e ele vai trabalhar em segundo plano, rodando lá no GitHub Actions. Ele cria a branch, escreve o código, roda os testes e abre um pull request com a descrição do que fez e por quê. Você só recebe o PR pra revisar. Se pedir mudança no review, ele volta e empurra commit novo respondendo o comentário.

Junta com o code review agêntico, que já entrou em cena esse ano, e o ciclo quase fecha sozinho: o Copilot revisa o PR, sugere a correção e ainda pode mandar essa correção pro coding agent gerar o fix. É bem mais do que autocompletar.

Reginaldo, então eu jogo a issue pra ele e vou tomar um café enquanto o PR aparece pronto?

Calma. Na tarefa bem delimitada, aquele bug isolado, um CRUD, atualizar dependência, ajustar teste, ele manda muito bem e economiza um tempão. Mas ele erra, viaja no contexto grande e às vezes entrega um PR que parece certo e não é. O PR continua sendo SEU pra revisar, o coding agent adianta o serviço, não assina embaixo por você. Trata como um dev júnior muito rápido que precisa de revisão, não como um sênior autônomo.

---

E pra quem é de dados?

Pode parecer papo só de dev de software, mas quem vive de dados usa isso o tempo todo: escrever aquele notebook, montar o pipeline, gerar o SQL chato, documentar função, criar o teste que a gente sempre empurra com a barriga. O GitHub Copilot é o Copilot mais "mão na massa" do ecossistema e, diferente dos outros da série, o público dele é quem escreve código, não o usuário de negócio nem o maker do Power Platform.

---

RESUMO

• Autocomplete: a origem, completa linha e bloco enquanto você digita.

• Agent mode (GA no VS Code e JetBrains): recebe a tarefa, mexe em vários arquivos, roda terminal e itera dentro do IDE.

• Coding agent: você atribui a issue e ele abre o PR sozinho, rodando no GitHub Actions.

• O PR continua seu pra revisar. Ótimo em tarefa bem delimitada, ainda erra no contexto grande.

• É o Copilot voltado pra quem escreve código, útil demais pro pessoal de dados também.

Esse era o Copilot do lado de quem constrói software. No próximo post eu volto pro nosso terreno de construir agentes e coloco o Foundry Agent Service frente a frente com o Copilot Studio, o pro-code contra o low-code, pra você saber quando vale descer pro código. Comenta aí se você já deixou o coding agent abrir um PR pra você e no que deu.

Referências:

https://docs.github.com/en/copilot/using-github-copilot/using-github-copilot-coding-agent

https://code.visualstudio.com/docs/copilot/chat/chat-agent-mode

Fique bem e até a próxima.

#githubcopilot #agentmode #copilot #ia #agentes #datainaction

Hey dataholics! Continuing the ecosystem series, today it's the turn of the Copilot most people have already used without even realizing it was part of this family: GitHub Copilot. It was born as that smart autocomplete inside the editor and, honestly, it turned into something else. Today it takes a task and works on its own, so it's worth understanding this evolution, because a lot of people still think GitHub Copilot is just the "tab tab tab" of finishing a line.

What we'll cover in this post:

• Where it came from: autocomplete

• The agent mode inside the IDE

• The coding agent that opens a PR on its own

• My take from using it day to day

---

Where it came from

The first version of GitHub Copilot was a turbocharged autocomplete. You'd start writing a function and it suggested the rest of the line, sometimes the whole block, in gray, and you hit Tab to accept. It was already an absurd productivity gain, mostly for spitting out boilerplate, repetitive tests and that boring code everyone writes on autopilot. But it only reacted to what you were typing in that file, it didn't see the whole project.

---

The agent mode

Then it grew up for real. The agent mode, already GA in VS Code and JetBrains, doesn't just complete a line: you describe the task and it decides which files to touch, runs commands in the terminal, looks at the error that came back and tries again, iterating until it's done. It went from "suggests what comes after the cursor" to "solves the task end to end inside the editor", with you following along and approving the steps.

---

The coding agent that opens a PR on its own

And there's the level that impresses the most: the coding agent. You assign it a GitHub issue, just like you'd assign it to a colleague, and it goes to work in the background, running over on GitHub Actions. It creates the branch, writes the code, runs the tests and opens a pull request with a description of what it did and why. You just get the PR to review. If you request a change in the review, it comes back and pushes a new commit answering the comment.

Put that together with the agentic code review that showed up this year and the cycle almost closes itself: Copilot reviews the PR, suggests the fix and can even hand that fix to the coding agent to generate it. It's a lot more than autocomplete.

Reginaldo, so I throw the issue at it and go grab a coffee while the PR shows up finished?

Easy there. On a well-scoped task, that isolated bug, a CRUD, bumping a dependency, fixing a test, it does great and saves you a ton of time. But it makes mistakes, drifts on big context and sometimes hands you a PR that looks right and isn't. The PR is still YOURS to review, the coding agent moves the work forward, it doesn't sign off for you. Treat it like a very fast junior dev that needs review, not an autonomous senior.

---

And for the data folks?

It might sound like software-dev-only talk, but whoever lives on data uses this all the time: writing that notebook, building the pipeline, generating the boring SQL, documenting a function, creating the test we always put off. GitHub Copilot is the most hands-on Copilot in the ecosystem and, unlike the others in the series, its audience is whoever writes code, not the business user nor the Power Platform maker.

---

RECAP

• Autocomplete: the origin, completes line and block while you type.

• Agent mode (GA in VS Code and JetBrains): takes the task, touches several files, runs the terminal and iterates inside the IDE.

• Coding agent: you assign the issue and it opens the PR on its own, running on GitHub Actions.

• The PR is still yours to review. Great on a well-scoped task, still trips on big context.

• It's the Copilot aimed at whoever writes code, super useful for the data crowd too.

That was the Copilot on the software-building side. In the next post I come back to our home turf of building agents and put the Foundry Agent Service head to head with Copilot Studio, pro-code against low-code, so you know when it's worth dropping down to code. Comment below if you've already let the coding agent open a PR for you and how it went.

References:

https://docs.github.com/en/copilot/using-github-copilot/using-github-copilot-coding-agent

https://code.visualstudio.com/docs/copilot/chat/chat-agent-mode

Stay well and see you next time.

#githubcopilot #agentmode #copilot #ai #agents #datainaction