GitHub Dev Day Key Takeaways

I recently attended a GitHub Copilot Dev days event on the 11th of May that focused on AI-assisted coding. Across three sessions, ranging from hands-on usage of Copilot to repository automation, the common theme was clear: Copilot is no longer just about writing code faster, but about changing how we plan, maintain, and evolve software. Below are my key takeaways from each session, starting with GitHub Copilot in practice.

Session 1: GitHub Copilot in Practice

In the opening session, Chris Noring, Senior Cloud Advocate @ Microsoft, explored how GitHub Copilot is evolving into a fully agentic development partner, and why the way we configure it matters as much as how we prompt it.

One of the biggest takeaways for me was the value of Plan Mode. Instead of jumping straight into code, Copilot can first create a clear markdown-based plan, ask clarifying questions, and align on assumptions. Being able to review and adjust that plan up front gives you much more control and helps reduce hallucinations before anything is implemented.

Customization came up repeatedly. By using files like AGENTS.md you can build a team of specialist agents that use a variety of different tools to act as a different persona which you can define further with custom instructions. Building up these custom files can ensure the generated code aligns with best practices and company guidelines without repeating constraints within your prompts.

Chris highlighted an important mental model:

• Agents combine recipes plus tools and are capable of handling defined tasks with limited independence under configured controls.
• Skills, by contrast, are focused, reusable recipes that teach Copilot how to perform a specific task but don’t act independently. Skills are automatically discovered and applied when relevant, making them ideal for tasks like testing, generating documentations or workflow automation.

Another area that stood out was the GitHub Copilot CLI. It brings agentic workflows directly into the terminal, including plan mode, steering mid-execution, and task delegation — something Chris emphasized we should all start experimenting with.

Finally, we touched on subagents, a newer capability that allows agents to spin up other agents to handle parallel or more focused tasks. It’s an early glimpse of how Copilot can scale its reasoning without overwhelming the main workflow.

Session 2: Agentic Workflows with GitHub Copilot

Session two shifted the focus from individual agents to the repository itself, and how agentic automation is changing the way we maintain and evolve code over time.

Don Syme, Principle Researcher @ GitHub introduced a key concept of Continuous AI, a term that builds on what we already know from CI/CD. Instead of running AI only when prompted, the idea is to apply it continuously across the software lifecycle. Examples included continuous documentation, code improvement, issue triage, summarisation, fault analysis, and quality checks.

One particularly interesting angle was tackling “AI slop” by moving clean-up work out of the developer flow — using agents to review pull requests, enforce guidelines, upgrade dependencies, and tidy things up after changes land, without interrupting day-to-day work.

This naturally leads into proactive AI. Once you start thinking in these terms, it becomes hard not to see opportunities for it everywhere — AI that doesn’t wait to be asked, but instead looks for useful work to do within clear boundaries.

From there, the session dove into GitHub agentic workflows, which feel familiar if you’ve worked with GitHub Actions. Agentic workflows are defined in markdown and include clear sections for triggers, tools, and safe outputs. Safe outputs essentially define what the agent is allowed to do as a result of the workflow, they act as strict guardrails to prevent unintended changes. For example, you might allow a workflow to comment on issues, but not commit directly to main or make destructive changes. These guardrails are essential. Automation is powerful, but only when it’s tightly constrained.

One powerful example was how agentic workflows enable continuous engineering. You can write workflows that regularly analyse performance, suggest improvements, and help the codebase get better over time.

Another standout use case was continuous repository maintenance. A “repo assist” workflow (agentics/docs/repo-assist.md at main · githubnext/agentics) can run on a schedule, daily, weekly, or however often you choose, helping maintainers deal with long issue backlogs. It can investigate bugs, comment with helpful context, suggest fixes, or open pull requests, with minimal manual effort, while still relying on human review and repository guardrails. Importantly, it supports contributors rather than replacing them, and never pushes directly to main.

Don shared an example where this workflow reduced open issues on his project from around 150 to fewer than 10 over three months.

Overall, the session positioned automation as continuous and proactive, with agents quietly improving and maintaining repositories in the background, always with clear guardrails and human oversight. The biggest value this brings to developers is how it reduces context switching, these repetitive, less critical tasks run in the background, allowing developers to focus on more critical and time-consuming work without constantly being pulled away by smaller tasks.

Workshop: Hands-on with GitHub Copilot

The final session was a hands-on workshop, following the Mona Mayhem track from Copilot Dev Days. It was a practical, follow-along session that tied together many of the concepts from the earlier talks.

One thing I learned that I didn’t know before was how differently GitHub Copilot CLI and the VS Code Copilot interface handle context, even when using the same underlying model. The CLI typically uses more tokens because it sends a much richer context payload, including conversation history, tool outputs, and repository information, which can make it feel more conversational and capable on complex tasks.

By contrast, VS Code Copilot operates with tighter, editor-native context control. It generally sends the current file, selected code, and nearby context, which keeps interactions fast and lightweight.

A key takeaway was that same model doesn’t mean same configuration:

• VS Code Copilot is optimised for low latency and a smaller token footprint.
• Copilot CLI feels better suited for correctness and explainability, trading speed for deeper context and clearer reasoning.

Seeing this difference side by side helped explain why Copilot can sometimes feel “smarter” in the terminal than in the editor, it’s not a different model, but a fundamentally different way of providing context and framing the conversation.

Overall, the event showed how Copilot is moving beyond just writing code into something that can plan, guide, and continuously support development. The main takeaway for me is that it’s less about prompting now, and more about how you configure and use it.

Final note

These are my personal takeaways from the event rather than an official Capgemini view. In any enterprise setting, AI should be used to support people, not replace them, and always within clear security, governance, and ethical guardrails. Human oversight remains essential, particularly where code quality, compliance, and operational risk are concerned.

If you want to learn more about the Microsoft Team here at Capgemini, take a look at our open roles and consider joining the team!

GitHub Dev Day Key Takeaways was originally published in Capgemini Microsoft Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

Original Post https://medium.com/capgemini-microsoft-team/github-dev-day-key-takeaways-0794402137c8?source=rss—-333ebfdadb74—4