Tamas Veiland’s Post

My team-mate has been digging into GitHub Copilot CLI’s new ACP server support, and explains it is a genuinely interesting step toward making coding agents easier to integrate anywhere. ACP stands for Agent Client Protocol, a standard way for a client (an editor, IDE, terminal UI, or even a pipeline runner) to talk to a coding agent (like Copilot CLI). Instead of every tool inventing its own bespoke integration, ACP provides a shared contract for how requests, responses, and agent actions flow. A quick note: ACP support in GitHub Copilot CLI is currently in public preview, so details may evolve. https://msft.it/6049Q5NGc Why this matters: IDE integrations: Bring Copilot style agent workflows into editors or internal dev environments that do not have first class Copilot plugins. CI/CD pipelines: Orchestrate agentic coding tasks in automated workflows, like generating patches, refactoring, or assisting with test updates as part of builds. Custom frontends: Build purpose specific interfaces for your team’s workflow, like a lightweight internal “coding assistant console.” Multi-agent systems: Coordinate Copilot alongside other AI agents with a standard protocol, rather than stitching together fragile adapters. The bigger takeaway for me is that standard protocols are what turn “cool demos” into ecosystems. If you have ever built a custom IDE integration or tried to automate code changes in a pipeline, you know how much time disappears into glue code. ACP aims to reduce that friction. If you are experimenting with agentic workflows, ACP server support in Copilot CLI is worth a look, especially if you want Copilot assistance outside the usual editor plugin path. #GitHubCopilot #DeveloperTools #AIEngineering #DevEx #Automation #CICD #IDEs

My team-mate has been digging into GitHub Copilot CLI’s new ACP server support, and explains it is a genuinely interesting step toward making coding agents easier to integrate anywhere. ACP stands for Agent Client Protocol, a standard way for a client (an editor, IDE, terminal UI, or even a pipeline runner) to talk to a coding agent (like Copilot CLI). Instead of every tool inventing its own bespoke integration, ACP provides a shared contract for how requests, responses, and agent actions flow. A quick note: ACP support in GitHub Copilot CLI is currently in public preview, so details may evolve. Why this matters: IDE integrations: Bring Copilot style agent workflows into editors or internal dev environments that do not have first class Copilot plugins. CI/CD pipelines: Orchestrate agentic coding tasks in automated workflows, like generating patches, refactoring, or assisting with test updates as part of builds. Custom frontends: Build purpose specific interfaces for your team’s workflow, like a lightweight internal “coding assistant console.” Multi-agent systems: Coordinate Copilot alongside other AI agents with a standard protocol, rather than stitching together fragile adapters. The bigger takeaway for me is that standard protocols are what turn “cool demos” into ecosystems. If you have ever built a custom IDE integration or tried to automate code changes in a pipeline, you know how much time disappears into glue code. ACP aims to reduce that friction. If you are experimenting with agentic workflows, ACP server support in Copilot CLI is worth a look, especially if you want Copilot assistance outside the usual editor plugin path. #GitHubCopilot #DeveloperTools #AIEngineering #DevEx #Automation #CICD #IDEs

🚀 𝐓𝐡𝐞𝐫𝐞’𝐬 𝐚 𝐩𝐚𝐫𝐭 𝐨𝐟 𝐆𝐢𝐭𝐇𝐮𝐛 𝐂𝐨𝐩𝐢𝐥𝐨𝐭 𝐚𝐥𝐦𝐨𝐬𝐭 𝐧𝐨 𝐨𝐧𝐞 𝐢𝐬 𝐮𝐬𝐢𝐧𝐠… 𝐚𝐧𝐝 𝐢𝐭 𝐜𝐡𝐚𝐧𝐠𝐞𝐬 𝐞𝐯𝐞𝐫𝐲𝐭𝐡𝐢𝐧𝐠. Most people customize GitHub Copilot with prompts or custom instructions. Few realize that 𝐀𝐠𝐞𝐧𝐭 𝐒𝐤𝐢𝐥𝐥𝐬 change the game entirely. 𝐀𝐠𝐞𝐧𝐭 𝐒𝐤𝐢𝐥𝐥𝐬 𝐚𝐫𝐞 𝐧𝐨𝐭 𝐩𝐫𝐨𝐦𝐩𝐭𝐬. They’re reusable, portable capabilities—collections of instructions, scripts, examples, and workflows that Copilot (and other agents) can load only when they’re actually needed. Why this matters 👇 ✅ 𝐒𝐩𝐞𝐜𝐢𝐚𝐥𝐢𝐳𝐞 𝐂𝐨𝐩𝐢𝐥𝐨𝐭 𝐟𝐨𝐫 𝐫𝐞𝐚𝐥 𝐰𝐨𝐫𝐤𝐟𝐥𝐨𝐰𝐬 Testing. Debugging. Deployment. Reviews. Skills let Copilot carry out specialized, repeatable tasks—not just suggest lines of code. ✅ 𝐂𝐫𝐞𝐚𝐭𝐞 𝐨𝐧𝐜𝐞. 𝐑𝐞𝐮𝐬𝐞 𝐞𝐯𝐞𝐫𝐲𝐰𝐡𝐞𝐫𝐞. The same skill can work across: • GitHub Copilot in VS Code • Copilot CLI • Copilot coding agent ✅ 𝐍𝐨 𝐜𝐨𝐧𝐭𝐞𝐱𝐭 𝐨𝐯𝐞𝐫𝐥𝐨𝐚𝐝 Skills load progressively: • Metadata → Instructions → Resources Only what’s needed enters the context window, when it’s needed. ✅ 𝐂𝐨𝐦𝐩𝐨𝐬𝐚𝐛𝐥𝐞, 𝐞𝐧𝐭𝐞𝐫𝐩𝐫𝐢𝐬𝐞‑𝐫𝐞𝐚𝐝𝐲 𝐝𝐞𝐬𝐢𝐠𝐧 Multiple skills can be combined to build complex, repeatable workflows that match how your team actually ships software. And here’s the real shift: 👉 𝐂𝐮𝐬𝐭𝐨𝐦 𝐢𝐧𝐬𝐭𝐫𝐮𝐜𝐭𝐢𝐨𝐧𝐬 define how code should look 👉 𝐀𝐠𝐞𝐧𝐭 𝐒𝐤𝐢𝐥𝐥𝐬 define how work should be done This is a big step toward 𝐢𝐧𝐭𝐞𝐧𝐭‑𝐝𝐫𝐢𝐯𝐞𝐧 𝐀𝐈 𝐝𝐞𝐯𝐞𝐥𝐨𝐩𝐦𝐞𝐧𝐭—where developers describe what they want to achieve, not how to prompt for it. If you’re still thinking of Copilot as “autocomplete for code,” 𝐀𝐠𝐞𝐧𝐭 𝐒𝐤𝐢𝐥𝐥𝐬 𝐚𝐫𝐞 𝐲𝐨𝐮𝐫 𝐢𝐧𝐯𝐢𝐭𝐚𝐭𝐢𝐨𝐧 𝐭𝐨 𝐭𝐡𝐢𝐧𝐤 𝐛𝐢𝐠𝐠𝐞𝐫. #GitHubCopilot #AgentSkills #AIAgents #DeveloperProductivity #AIEnablement #EnterpriseAI 

🚀 GitHub Copilot is no longer just autocomplete — it’s evolving into a full AI development ecosystem. What started as an AI pair programmer is now expanding across IDE, GitHub, Terminal, and CI/CD, helping developers plan, generate, test, review, and ship code faster than ever. In this article, I explore: 🔹 Copilot Workspace Commands and AI-native development 🔹 How Copilot operates across every surface where developers work 🔹 Why the future of coding is shifting from writing code to directing software creation 📖 Part 1 of my GitHub Copilot series: https://lnkd.in/d32hYykQ More deep dives coming next on: ➡️ Copilot in IDEs ➡️ Copilot in GitHub workflows ➡️ Copilot in the terminal and CI/CD pipelines If you're building software in 2026, understanding this shift isn’t optional — it’s a competitive advantage. #GitHubCopilot #AIinDev #DeveloperProductivity #AICoding #SoftwareArchitecture #DevTools #AITransformation

Most enterprises adopt GitHub Copilot the same way.! 𝗟𝗲𝗮𝗱𝗲𝗿𝘀𝗵𝗶𝗽 𝗮𝗽𝗽𝗿𝗼𝘃𝗲𝘀 𝗶𝘁. 𝗜𝗧 𝗱𝗲𝗽𝗹𝗼𝘆𝘀 𝗶𝘁. 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀 𝗹𝗼𝘃𝗲 𝗶𝘁. 𝗗𝗼𝗻𝗲. What nobody does — and I mean almost nobody — is look at token usage before the first big invoice. 𝗪𝗲 𝘄𝗲𝗿𝗲 𝘁𝗵𝗲 𝘀𝗮𝗺𝗲.! Once Co-pilot was available as an extension to popular IDE's like Visual Studio Code and the various JetBrains IDEs (including IntelliJ IDEA, PyCharm) usage was sky-rocketed. The tool is genuinely brilliant and helping developers in most cases. But this burst of lavish usage turns out to have a hidden cost — 𝘁𝗵𝗲 𝘄𝗮𝘆 𝗺𝗼𝘀𝘁 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀 𝗻𝗮𝘁𝘂𝗿𝗮𝗹𝗹𝘆 𝘂𝘀𝗲 𝗖𝗼𝗽𝗶𝗹𝗼𝘁 𝗶𝘀 𝗮𝗹𝘀𝗼 𝘁𝗵𝗲 𝗺𝗼𝘀𝘁 𝗲𝘅𝗽𝗲𝗻𝘀𝗶𝘃𝗲 𝘄𝗮𝘆 𝘁𝗼 𝘂𝘀𝗲 𝗶𝘁. Here's what was silently burning tokens for most of us: ❌ 10+ tabs open at all times in VS Code — Copilot reads all of them as context, whether you're using them or not ❌ Broad Copilot Chat prompts like "review this codebase" instead of "refactor this one function" ❌ Long chat threads on github.com that re-send the full conversation history with every single message ❌ Massive 600-line files that flood the context window before Copilot even gets to the useful part Nobody was doing anything wrong. We just didn't know these things mattered. What we actually changed — and it wasn't complicated: ✅ Close tabs not relevant to your current task. Sounds obvious. Almost nobody does it. ✅ Start fresh chat threads when switching topics. Don't carry a 40-message auth thread into your dev work. ✅ Write specific prompts and comments. "Validate email format, return boolean" beats "handle the email thing" — for output quality and cost. ✅ Scope your Copilot Chat with #file: or highlight a selection first. Give it less to think about, not more. ✅ Break large files into smaller modules. Good engineering practice that also happens to be significantly cheaper. If you're rolling out Copilot at scale right now — build these habits early. The tool ROI is real, but so is the cost of undisciplined usage across a large team. 𝗦𝗺𝗮𝗹𝗹 𝗵𝗮𝗯𝗶𝘁𝘀. 𝗖𝗼𝗺𝗽𝗼𝘂𝗻𝗱𝗶𝗻𝗴 𝗶𝗺𝗽𝗮𝗰𝘁. What's your experience been with Copilot usage at scale? Would love to hear what others have found. 👇 #GitHubCopilot #EnterpriseAI #DeveloperProductivity #SoftwareEngineering #AITools

I've been using GitHub Copilot CLI daily, and these 5 slash commands have fundamentally changed how I work in the terminal. Here's what every developer should know: /mcp → Manage Model Context Protocol integrations. Connect to external tools and data sources without leaving your workflow. /skills → List and add skills to your solution. Extend Copilot's capabilities with custom functionality. /agent → Browse available agents or create new ones tailored to your needs. /diff → Review file changes with the ability to leave inline comments. Just press 'C' to comment on any change. /terminal setup → A one-time command that enables shift+enter support for better terminal interaction. But here's what surprised me most: The /pr create and /pr fix commands are absolute game-changers. I used to just prompt "create a PR" but /pr create handles everything — ensuring branches are up to date, proper formatting, the works. And /pr fix? It checks all CI failures in your PR, fixes issues, and even handles merge conflicts automatically. With 90% of Fortune 100 companies now deploying Copilot and developers reporting 55% faster task completion, these aren't just nice-to-haves — they're essential productivity multipliers. Full command reference: https://lnkd.in/gc9vMsE6 What Copilot CLI commands have transformed your workflow? #GitHubCopilot #DeveloperProductivity #AIinDevelopment

Your PR review just got a co-pilot with a choice of engines. GitHub Copilot now lets you pick your AI model directly inside a Pull Request comment — just mention @copilot, and a model picker appears right in the comment box. This means your team can now choose the right model for the right task, right where the work happens. This is model-agnostic agentic code review becoming a reality inside your existing Git workflow. Think about what this actually enables: → Use a reasoning-heavy model for complex architectural PRs → Use a faster, leaner model for routine bug fixes or formatting changes For enterprise engineering leaders, this is a meaningful signal: the PR is becoming an agentic interface, not just a review artifact. AI is no longer a "plugin"—it's a core component of the SDLC. Architect accordingly. #GitHub #Copilot #AIEngineering #PullRequest #AgenticAI #EnterpriseArchitecture #DevOps #SoftwareEngineering #AIGovernance #SolutionArchitect

GitHub Copilot is one of the pages we would open first inside Developer copilots for workflow-heavy teams. Why it matters: GitHub Copilot is most useful when you need integrated coding assistant inside developer copilots for workflow-heavy teams and want a faster shortlist decision. The page breaks down fit, trade-offs, and what to compare next. Read the page: https://lnkd.in/e6RMHxK4

This article provides a practical guide to leveraging GitHub Copilot CLI for seamless transition from idea to reviewable changes. I found it interesting that the workflow integrates smoothly into your IDE and GitHub, enhancing productivity. What stood out to me was the potential for this tool to streamline collaboration among developers. How have you integrated AI tools into your coding workflow?

GitHub Copilot is no longer just an autocomplete tool , it’s becoming an agentic coding partner. With repository, aware context, custom instructions, and structured prompt files, Copilot can understand architecture patterns, enforce versioning strategies, generate unit tests that match project standards, and follow enterprise logging and error-handling conventions. It doesn’t just suggest lines of code , it reasons across files, applies domain rules, and adapts to the way your system is designed. When configured properly with clear instructions and reusable prompts, Copilot moves from reactive code suggestions to proactive, standards-driven development.