# htek.dev — Agentic Development & DevOps Automation (Full Index) > htek.dev is a technical blog and consulting practice by Hector Flores, focused on agentic development, GitHub Copilot workflows, and DevOps automation. > For the full article content in markdown, visit: /articles/{slug}.md --- ## About Hector Flores is a DevOps engineer and agentic development practitioner who runs 50+ autonomous AI agents managing his platform, content pipeline, and family operations. He writes about building governed, production-grade agent systems using GitHub Copilot CLI, custom extensions, hookflows, and multi-agent orchestration. ### Core Expertise - **Agentic Development**: Multi-agent architectures with governance, testing, and observability - **Context Engineering**: Designing instructions, memory, and context that make AI agents effective - **Agent Governance**: HookFlows, harnesses, guardrails, and runtime enforcement for autonomous agents - **GitHub Copilot CLI**: Extensions, custom agents, hooks, and the Copilot CLI agent runtime - **DevOps + AI**: Integrating autonomous agents into CI/CD, infrastructure, and platform engineering --- ## Windows Agent Runtime — What Microsoft Gets Right About Agent Sandboxing **Published:** 2026-06-02 **Tags:** AI, Microsoft, Multi-Agent Systems, Software Architecture, GitHub Copilot **URL:** https://htek.dev/articles/windows-agent-runtime-what-microsoft-gets-right-agent-sandboxing **Markdown:** https://htek.dev/articles/windows-agent-runtime-what-microsoft-gets-right-agent-sandboxing.md Microsoft's Windows Agent Runtime introduces OS-level sandboxing for AI agents. Here's what it gets right, how it compares to NVIDIA OpenShell, and what's still missing. ### Key Points > At Build 2026, Microsoft made the single most important announcement for anyone running production AI agents: [Windows is becoming a first-class agent runtime](https://dev.to/akaranjkar08/microsoft-build-2026-developer-preview-windows-agent-runtime-multi-model-copilot-and-the-agentic-5pi). Not an app that happens to run agents. Not a container orchestrator bolted onto the side. The operating system itself now understands what an agent is, what it's allowed to do, and when to cut it off. > I've been running a multi-agent platform on Windows for over a year — [50+ agents managing everything from my family's schedule to my content pipeline](/articles/what-is-context-engineering-practical-guide-50-agents). So when Microsoft announces OS-level sandboxing for agents, I'm not evaluating a feature announcement. I'm comparing notes with a system I've already built the hard way. > Here's what they got right, what NVIDIA's competing approach reveals about the design space, and the gap that still matters most. --- ## Frameworks Don't Execute Themselves **Published:** 2026-05-31 **Tags:** AI Agents, Agentic Development, Platform Engineering, Automation, Deep Dive **URL:** https://htek.dev/articles/frameworks-dont-execute-themselves **Markdown:** https://htek.dev/articles/frameworks-dont-execute-themselves.md Every transformation framework tells you WHAT to do but provides zero enforcement. The solution isn't another framework — it's a harness. ### Key Points > Here's a pattern I've seen destroy more organizational initiatives than bad strategy ever could: **Monday energy dies by Wednesday.** > Your team runs an offsite. Everyone's inspired. The consultant delivers a gorgeous deck — ExO attributes, OKR cascades, EOS rocks, Agile ceremonies. Heads nod. Post-its cover whiteboards. The energy is real. By Wednesday, three Slack threads have pulled focus. By month two, the scorecards are half-updated. By month three, the slides are a shared drive artifact nobody opens. > *The Wednesday Problem: organizational energy decays predictably from Monday inspiration to Month 3 abandonment.* --- ## The Definitive GitHub Actions Debugging Guide: 65+ Real Errors and How to Fix Them **Published:** 2026-05-29 **Tags:** GitHub Actions, DevOps, CI/CD, Security, Best Practices **URL:** https://htek.dev/articles/github-actions-debugging-guide **Markdown:** https://htek.dev/articles/github-actions-debugging-guide.md Every GitHub Actions error message, root cause, and fix in one place. From YAML gotchas to OIDC failures — the debugging reference you'll actually bookmark. ### Key Points > GitHub Actions is the CI/CD backbone for millions of repositories. It's also the source of some of the most confusing, silent, and undocumented failure modes in modern DevOps. > I've spent years debugging Actions workflows — first across [500+ repository migrations at an enterprise scale](/articles/lessons-from-500-github-migrations), then building [agentic DevOps platforms](/articles/agentic-devops-next-evolution-of-shift-left) that push Actions to its limits. This guide is the result: every error message I've collected, every silent failure I've traced, and every workaround that actually works. > **This is a reference guide, not a tutorial.** Bookmark it. Search it when something breaks. Every section includes the actual error message (so you can Ctrl+F or Google it), the root cause, and the fix with copy-paste code. --- ## Platform Team Burnout Is Real — Here's How I Rescued Mine with AI **Published:** 2026-05-29 **Tags:** Platform Engineering, GitHub Copilot, Agentic Development, Developer Experience, Case Study, Enterprise **URL:** https://htek.dev/articles/platform-team-burnout-how-ai-rescued-mine **Markdown:** https://htek.dev/articles/platform-team-burnout-how-ai-rescued-mine.md I built 10 interconnected frameworks across 60+ repos as a solo platform engineer. The backlog hit 500 issues. Then GitHub Copilot changed everything. ### Key Points > Seventy-three percent of platform engineers work 50+ hour weeks. Nearly a third of organizations [report understaffed platform teams](https://platformengineering.org/events/state-of-platform-engineering-in-2026-salary-maturity-and-shifting-down-2026-01-20). And 58% of platform engineers are on-call for [more than 10 services](https://www.ai-infra-link.com/platform-team-burnout-key-causes-and-solutions-in-2026/). I know these numbers are real because I lived them — except my story was worse. I was one person responsible for 10 interconnected frameworks spanning 60+ repositories. > This is the story of how I built a platform engineering ecosystem that became my company's greatest asset and my personal greatest liability — and how AI agents pulled me out of the burnout spiral. > At a Fortune 500 energy company, I was brought in to lead a massive consolidation effort. The engineering org was scattered across Azure DevOps, Bitbucket, Stash, SVN, and a mess of legacy CI/CD tools. My mandate was simple: bring everything under one roof on GitHub. --- ## The Functional Options Pattern for AI Agent Composition **Published:** 2026-05-25 **Tags:** AI Agents, Agentic Development, Platform Engineering, Deep Dive, Open Source **URL:** https://htek.dev/articles/functional-options-pattern-ai-agent-composition **Markdown:** https://htek.dev/articles/functional-options-pattern-ai-agent-composition.md The Go functional options pattern is a clean way to compose tools, guardrails, memory, and middleware into production-ready AI agents. ### Key Points > **Most AI agent APIs are turning into constructor soup.** Add tools, then memory, then hooks, then approvals, then retries, then handoffs, then model settings, then telemetry, and suddenly your “simple” `NewAgent(...)` call looks like an archaeological dig through six months of product decisions. > Go solved this problem years ago. The **functional options pattern** is still one of the cleanest ways to build APIs that start simple, grow safely, and stay readable. After building [AI Harness](https://github.com/htekdev/ai-harness) as a reference implementation for Harness as Code and writing about [Harness as Code](/articles/what-is-harness-as-code), I’m convinced the same pattern maps incredibly well to **AI agent composition**. > Dave Cheney’s classic post on [functional options for friendly APIs](https://dave.cheney.net/2014/10/17/functional-options-for-friendly-apis) is still the best starting point. His argument was simple: constructor signatures get brittle fast when you keep adding optional behavior. Teams usually bounce through the same bad progression: --- ## Per-Turn Evaluation: Dynamic Governance for AI Agents **Published:** 2026-05-25 **Tags:** AI Agents, Agentic Development, Platform Engineering, Security, Deep Dive, Open Source **URL:** https://htek.dev/articles/per-turn-evaluation-dynamic-governance-ai-agents **Markdown:** https://htek.dev/articles/per-turn-evaluation-dynamic-governance-ai-agents.md Per-turn evaluation gives AI agents dynamic governance by re-evaluating rules, tools, and context from live state instead of startup config. ### Key Points > **Static governance is fine right up until your agent changes modes mid-session.** The same agent can spend turn 1 researching docs, turn 8 editing code, turn 14 fixing failed tests, and turn 20 preparing a production deploy. Pretending one startup-time config should govern all of that is the harness equivalent of hardcoding production policy into a shell alias. > That is why I'm increasingly convinced that **per-turn evaluation** needs to be a first-class primitive in agentic systems. If you're serious about governed autonomy, you need the harness to ask a fresh question at the start of every turn: *given the current state, which rules should be active right now?* > This is a core idea behind what I call [Harness as Code](/articles/what-is-harness-as-code). And in [AI Harness](https://github.com/htekdev/ai-harness), per-turn artifact evaluation is implemented as a runtime feature in [v0.4.0](https://github.com/htekdev/ai-harness/releases/tag/v0.4.0), following the design described in [issue #7 for per-turn artifact evaluation](https://github.com/htekdev/ai-harness/issues/7). --- ## What Is Harness as Code? The DevOps of AI Agents **Published:** 2026-05-24 **Tags:** AI Agents, Agentic Development, DevOps, Platform Engineering, Deep Dive, Open Source, Developer Experience **URL:** https://htek.dev/articles/what-is-harness-as-code **Markdown:** https://htek.dev/articles/what-is-harness-as-code.md Harness as Code applies Infrastructure as Code principles to AI agents: declarative governance, reproducible behavior, and auditable context. ### Key Points > **Most teams are still treating agent behavior like handcrafted prompt art.** That works right up until the agent gets real tool access, starts touching production systems, or needs to behave consistently across repos, environments, and sessions. > The short version: Harness as Code applies the same ideas that made [Infrastructure as Code practical and scalable](https://developer.hashicorp.com/well-architected-framework/define-and-automate-processes/define/as-code/infrastructure) to AI agents. Instead of hiding governance inside application code or hoping a giant system prompt keeps your agent safe, you define the harness itself as version-controlled, reviewable, testable artifacts. > Anthropic has been explicit that **harness design** matters for long-running agents. In its engineering write-up on [effective harnesses for long-running agents](https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents?s=09), the company describes the harness as the layer that helps agents keep making progress across multiple context windows. In its earlier post on [building effective agents](https://www.anthropic.com/engineering/building-effective-agents?%3Fquery=MTA%3F%3Futm%3D), Anthropic also argues that simple, composable patterns beat unnecessary framework complexity. --- ## Copilot Plugins: Building Domain-Expert AI Teammates **Published:** 2026-05-22 **Tags:** GitHub Copilot, Copilot CLI, Model Context Protocol, Agentic Development, Deep Dive **URL:** https://htek.dev/articles/copilot-plugins-domain-expert-ai-teammates **Markdown:** https://htek.dev/articles/copilot-plugins-domain-expert-ai-teammates.md Build Copilot plugins with domain knowledge, MCP tools, and custom skills so Copilot acts like a specialist teammate, not just autocomplete. ### Key Points > Most developers use [GitHub Copilot](https://github.com/features/copilot) like a faster autocomplete engine. Useful, yes — but still the shallow end of the pool. > The bigger opportunity is building **domain-expert plugins**: packages that give Copilot a clear identity, specialized knowledge, and real tools it can use on your behalf. That's when the experience changes from "I ask Copilot for help" to **"I built a Copilot teammate that understands my world."** > If you think in terms of VS Code extensions or chat participants, the mental model is similar: package context, behavior, and capability into a specialist that shows up with judgment built in. --- ## Custom Copilot Agents: Building Domain-Expert AI Teammates with Skills, MCP Tools, and Custom Knowledge **Published:** 2026-05-22 **Tags:** GitHub Copilot, Copilot CLI, AI Agents, Agentic Development, Model Context Protocol, Deep Dive **URL:** https://htek.dev/articles/custom-copilot-agents-building-domain-expert-ai-teammates **Markdown:** https://htek.dev/articles/custom-copilot-agents-building-domain-expert-ai-teammates.md Most teams stop at autocomplete. The real unlock is building custom Copilot agents that know your codebase, workflow, and tools. ### Key Points > Most developers still treat [GitHub Copilot](https://github.com/features/copilot) like a very good autocomplete engine. That's useful, but it's not the real unlock. > The interesting shift happens when Copilot stops acting like a generic assistant and starts acting like a **domain-expert teammate**. Instead of re-explaining your deployment rules, your content pipeline, or your release checklist every session, you package that expertise once. Then Copilot shows up already knowing the job. > That's the difference between **using Copilot** and **building with Copilot**. One gives you better suggestions. The other gives you reusable specialists that understand your repo, your patterns, and your operating model. --- ## Platform Engineering with GitHub: How to Build an Internal Developer Platform Using Copilot, IssueOps, and Golden-Path Starter Repos **Published:** 2026-05-21 **Tags:** Platform Engineering, GitHub Copilot, GitHub Actions, Developer Experience, Deep Dive, Enterprise **URL:** https://htek.dev/articles/platform-engineering-github-internal-developer-platform **Markdown:** https://htek.dev/articles/platform-engineering-github-internal-developer-platform.md Stop building Backstage. Your IDP already exists — it's GitHub with Copilot extensions, IssueOps workflows, and golden-path starter repos. ### Key Points > The platform engineering movement is accelerating — and most teams are building it wrong. > They're adopting Backstage, standing up Kubernetes operators, hiring dedicated portal teams, and spending 6-12 months before delivering any real value to developers. Meanwhile, the actual developer platform — the thing engineers use every single day — is sitting right in front of them. > I built an enterprise-scale internal developer platform at a Fortune 500 energy company. Thousands of developers, hundreds of repos, strict compliance requirements. We didn't need a separate portal because **GitHub already IS the platform** — the service catalog, the self-service automation, the golden paths, the governance layer. All native primitives, composed together. --- ## Aspect-Oriented Programming for AI Agents: Hookflows as an Event Bus **Published:** 2026-05-20 **Tags:** GitHub Copilot, Copilot CLI, Agentic Development, Platform Engineering, Deep Dive **URL:** https://htek.dev/articles/aspect-oriented-programming-ai-agents-hookflows **Markdown:** https://htek.dev/articles/aspect-oriented-programming-ai-agents-hookflows.md One tool call, multiple outcomes, zero extra tokens. How enforcement-triggered side effects bring AOP to autonomous AI agents. ### Key Points > I was debugging a notification problem in my 53-agent home assistant when I stumbled onto something unexpectedly powerful. I needed every agent dispatch to notify me via Telegram — but I didn't want to burn tokens on a separate `telegram_send_message` call. The agents were already being validated by a governance hookflow. Why not piggyback the notification onto the validation step? > One tool call. Validation **and** notification. Zero additional tokens consumed by the agent. > Then it hit me: I'd accidentally reinvented [aspect-oriented programming](https://en.wikipedia.org/wiki/Aspect-oriented_programming) — but for AI agents instead of Java classes. --- ## GitHub Just Shipped What I Built 2 Months Ago — And That's a Good Thing **Published:** 2026-05-20 **Tags:** GitHub Copilot, Copilot CLI, Agentic Development, Automation, Developer Experience, Opinion **URL:** https://htek.dev/articles/github-copilot-remote-sessions-validates-mobile-first-agents **Markdown:** https://htek.dev/articles/github-copilot-remote-sessions-validates-mobile-first-agents.md GitHub Copilot's new remote sessions let you control your agent from your phone. I built the same pattern with Telegram in April. Here's why mobile-first agents are inevitable. ### Key Points > On May 18, GitHub made [remote control for Copilot CLI sessions generally available](https://github.blog/changelog/2026-05-18-remote-control-for-copilot-cli-sessions-now-generally-available-on-mobile-web-and-vs-code/) — on mobile, web, and VS Code. You start a session on your workstation, scan a QR code, and steer your agent from your phone while walking the dog. > I published [a 3,000-word guide to doing exactly this via Telegram](/articles/copilot-cli-telegram-bridge-mobile-ai-terminal) on April 11. Same core concept: your AI agent runs on your machine, you interact with it from your pocket. Different implementation, identical insight. > This isn't an "I told you so" moment. This is a **validation moment**. When the team building the tool arrives at the same architectural conclusion you reached independently — mobile-first agent interaction isn't optional, it's inevitable — that tells you something important about where this industry is headed. --- ## GitOps for Everything: The *-as-Code Revolution That Changes How You Ship, Govern, and Scale **Published:** 2026-05-20 **Tags:** Infrastructure as Code, DevOps, CI/CD, Platform Engineering, Deep Dive **URL:** https://htek.dev/articles/gitops-for-everything-beyond-deployments **Markdown:** https://htek.dev/articles/gitops-for-everything-beyond-deployments.md Infrastructure, identity, access, policy, docs, and now AI harnesses — everything worth governing belongs in Git. Here's why GitOps is the universal leverage multiplier. ### Key Points > Every major operational discipline has gone through the same evolution: manual clicks in a dashboard → scripts in a wiki → **declarative code in a Git repository, enforced through CI/CD**. It happened to infrastructure. Then policy. Then identity. Then documentation. > The pattern keeps winning because it always delivers the same four things: **automation, repeatability, reliability, and audit trail**. Once you define something as code and apply GitOps to it, you gain PR-based review, rollback on merge revert, blame for forensics, and branch protection as a governance gate. It's not clever — it's structural leverage. > And the family keeps growing. Here's the landscape in 2026 — and why the newest member, **Harness as Code**, might be the most important addition yet. --- ## Platform Engineering with GitHub: Build Your IDP with Copilot, IssueOps, and Golden-Path Repos **Published:** 2026-05-19 **Tags:** Platform Engineering, GitHub Copilot, DevOps, Developer Experience, Agentic Development **URL:** https://htek.dev/articles/platform-engineering-with-github **Markdown:** https://htek.dev/articles/platform-engineering-with-github.md Stop building Backstage. GitHub IS the platform. Build your IDP with Copilot extensions, IssueOps workflows, hookflows, and golden-path starter repos. ### Key Points > Every enterprise team I talk to is drowning in the same problem: **toolchain sprawl**. Backstage instances nobody maintains. ServiceNow tickets that take 3 days to provision a repo. Confluence pages with onboarding steps from 2022. Developers spending 40% of their time fighting infrastructure instead of shipping product. > Platform engineering promises to fix this — and the industry agrees. [Gartner predicts](https://www.gartner.com/en/articles/what-is-platform-engineering) that by 2026, 80% of software engineering organizations will establish platform teams. But here's what most teams get wrong: **they think they need to build another tool.** > > **Want the complete implementation?** This article covers the architecture overview. Newsletter subscribers get the real configs, full code, and step-by-step implementation details. [Subscribe to the htek.dev newsletter →](https://htek.dev/newsletter) --- ## The 7-Layer AI Governance Stack: How to Actually Control Autonomous Agents in Production **Published:** 2026-05-18 **Tags:** AI Agents, Security, Agentic Development, Platform Engineering, Deep Dive **URL:** https://htek.dev/articles/7-layer-ai-governance-stack **Markdown:** https://htek.dev/articles/7-layer-ai-governance-stack.md Everyone's building AI agents. Nobody's governing them. Here's the governance stack from a 53-agent system running autonomously for 6 months. ### Key Points > I run **53 autonomous AI agents** on [GitHub Copilot](https://github.com/features/copilot) that manage my family's finances, meals, home maintenance, content publishing, and even NICU care coordination for our premature twins. They execute on 57 cron jobs. They make real decisions — moving money, sending messages, creating PRs, scheduling appointments. > Six months. Zero incidents. Not because my agents are simple, but because they're **governed**. > Here's what nobody talks about in the "just ship agents" hype cycle: the moment your agent does something real — sends a message, moves money, deploys code — you need governance. Not "AI safety" in the abstract research sense. **Operational governance.** The kind that prevents your meal-planning agent from accidentally spending $500 at the grocery store. --- ## AI Harnesses: Why DevOps Principles Are the Missing Piece in Agentic Development **Published:** 2026-05-18 **Tags:** GitHub Copilot, AI Agents, DevOps, Agentic Development, Platform Engineering, Deep Dive **URL:** https://htek.dev/articles/ai-harnesses-devops-principles-agentic-development **Markdown:** https://htek.dev/articles/ai-harnesses-devops-principles-agentic-development.md DevOps gave humans CI/CD, IaC, and observability to govern software delivery. AI harnesses give agents the same — and they matter more than model choice. ### Key Points > Last night I watched a talk from AI.engineer that crystallized something I've been building toward for months. The speaker demonstrated fixing a series of agent failures — not by changing the prompt, not by upgrading the model, not by adding more context. They fixed it by **improving the harness**. > The agent was the same. The model was the same. The instructions were identical. But the harness — the infrastructure that controls how the agent operates — made the difference between a broken tool and a production-ready system. > > **DevOps was the tool we gave humans to control their workflows. AI Harnesses are the tool we give agents to control their workflows.** --- ## GitHub's New Billing Model Changes Everything About Agentic Development **Published:** 2026-05-18 **Tags:** GitHub Copilot, Agentic Development, Developer Experience, Deep Dive **URL:** https://htek.dev/articles/github-copilot-billing-harness-engineering-cost-control **Markdown:** https://htek.dev/articles/github-copilot-billing-harness-engineering-cost-control.md Usage-based billing means long agentic sessions now cost real money. Harness engineering — hooks, delegated agents, and model routing — is how you control it. ### Key Points > On April 27, GitHub announced that [all Copilot plans will transition to usage-based billing on June 1, 2026](https://github.blog/news-insights/company-news/github-copilot-is-moving-to-usage-based-billing/). Premium Request Units (PRUs) are being replaced by **GitHub AI Credits**, charged based on actual token consumption — input, output, and cached tokens — at each model's published API rate. > > "Today, a quick chat question and a multi-hour autonomous coding session can cost the user the same amount." > That's the old model. Under the new one, that multi-hour agentic session will cost exactly what it consumes. And if your team has been running unoptimized agents with bloated contexts and premium models for everything? The invoice is about to get specific. --- ## 53 Agents, Zero Chaos: The Multi-Agent Orchestration Patterns That Actually Work in Production **Published:** 2026-05-17 **Tags:** GitHub Copilot, AI Agents, Agentic Development, Platform Engineering, Deep Dive **URL:** https://htek.dev/articles/53-agents-zero-chaos-multi-agent-orchestration-patterns **Markdown:** https://htek.dev/articles/53-agents-zero-chaos-multi-agent-orchestration-patterns.md Every multi-agent demo shows 3 chatbots in a loop. Here's what happens when you build a 53-agent system that runs a real family's life for 6 months. ### Key Points > Every "multi-agent" demo you've seen follows the same script: three chatbots pass JSON to each other in a loop, somebody calls it "orchestration," and the audience claps. Ship that to production and watch it collapse in a week. > I know because I built the naive version first. Then I rebuilt it. And rebuilt it again. Six months later, I run **53 AI agents** on [GitHub Copilot](https://github.com/features/copilot) that manage my family's entire life — finances, meals, home maintenance, content publishing, a NICU care coordinator for our premature twins, even a postpartum wellness coach. They run autonomously on **57 cron jobs**, coordinate across **75 reusable skills**, and communicate through an [agent mesh](/articles/agent-mesh-cross-session-communication-copilot-cli) I built for cross-session IPC. > What's fascinating is watching the research community arrive at the exact patterns I stumbled into through production pressure. --- ## 53 Agents, Zero Chaos: The Multi-Agent Orchestration Patterns That Actually Work in Production **Published:** 2026-05-17 **Tags:** GitHub Copilot, AI Agents, Agentic Development, Platform Engineering, Deep Dive **URL:** https://htek.dev/articles/53-agents-zero-chaos-multi-agent-orchestration **Markdown:** https://htek.dev/articles/53-agents-zero-chaos-multi-agent-orchestration.md Everyone demos 3 chatbots in a loop. Here's what orchestrating 53 production AI agents actually looks like after 6 months of daily use. ### Key Points > Everyone's talking about multi-agent systems in 2026. Most demos show 3 chatbots in a loop. Here's what a real 53-agent system looks like after 6 months of daily production use. > I run 53 specialized AI agents, 75 reusable skills, and a cron-driven scheduling system — all orchestrated through [GitHub Copilot CLI](https://docs.github.com/en/copilot/github-copilot-in-the-cli). Not as a demo. Not as a weekend project. As the production infrastructure that runs my family's daily life and my entire content operation. > This post is the 10,000-foot view. The full configs, state machines, and protocols are in [Newsletter Issue #6](https://htek.dev/newsletter). --- ## All Agent Harnesses: The Live Comparison **Published:** 2026-05-17 | **Updated:** 2026-06-02 **Tags:** AI Agents, Agentic Development, GitHub Copilot, Comparison, Deep Dive **URL:** https://htek.dev/articles/all-agent-harnesses-live-comparison **Markdown:** https://htek.dev/articles/all-agent-harnesses-live-comparison.md Every AI agent harness compared head-to-head — features, pros, cons, and classification. A living resource, updated continuously. ### Key Points > > **🔴 LIVING ARTICLE** — This page is continuously maintained and updated as platforms ship new features. Bookmark it. Come back often. > > **Last updated: June 2, 2026** — Mistral Vibe unified Work + Code platform, Google Antigravity 2.0 five-surface architecture, NVIDIA OpenShell Ubuntu snap, Claude Code Dynamic Workflows API details > There are over a dozen platforms claiming to be the best way to build, run, and manage AI agents. Some are IDEs, some are cloud services, some are open-source libraries, and some are full autonomous coding environments. The terminology is a mess. Marketing pages all say "agent framework" but the products underneath are fundamentally different things. > I've been building [multi-agent systems in production](/articles/agent-harnesses-controlling-ai-agents-2026) — 50+ agents running autonomously on cron schedules, managing everything from [content pipelines](/articles/video-pipeline-with-fleet-mode) to [household logistics](/articles/copilot-home-assistant-ai-runs-my-household). That experience taught me something the comparison posts miss: **the harness matters more than the model.** The right control plane turns a chatbot into a production system. The wrong one turns your codebase into a liability. --- ## The Three Layers Your AI Agent Is Missing **Published:** 2026-05-17 **Tags:** GitHub Copilot, Copilot CLI, Agentic Development, Platform Engineering, Deep Dive **URL:** https://htek.dev/articles/three-layers-your-ai-agent-is-missing **Markdown:** https://htek.dev/articles/three-layers-your-ai-agent-is-missing.md Most AI agents run on prompts and prayers. Production systems need three architectural layers — skills, extensions, and hooks — working together. ### Key Points > Here's how most people build AI agent systems: they write a massive prompt, give the agent access to tools, and hope for the best. It works in demos. It falls apart in production. > I know because I tried it. I run [over 50 AI agents](https://htek.dev/articles/copilot-home-assistant-ai-runs-my-household) on [GitHub Copilot](https://github.com/features/copilot) that manage everything from family finances to content publishing to home maintenance. Early on, every agent had its own instructions with duplicated logic, conflicting rules, and zero enforcement. One agent would cheerfully ignore safety rules. Another would duplicate work a third agent had already done. A fourth would push directly to `main` at 2 AM. > After months of production iteration, I converged on a three-layer system that separates **knowledge** (skills), **capability** (extensions), and **enforcement** (hooks). Each layer has a distinct job, and together they turn a collection of chatbots into a governed platform. This is the overview — the [newsletter issue](/newsletter/005-three-layer-agent-extension-architecture) has the complete implementation with real configs and code. --- ## Your Phone as an AI Tool: The MCP Pattern That Changes Everything **Published:** 2026-05-16 **Tags:** GitHub Copilot, Model Context Protocol, Copilot CLI, Automation, Tutorial, Open Source **URL:** https://htek.dev/articles/your-phone-as-ai-tool-mcp-pattern **Markdown:** https://htek.dev/articles/your-phone-as-ai-tool-mcp-pattern.md 18 tools, one open protocol, and your Android phone becomes an AI-accessible device. Here's the MCP pattern — and where to get the full implementation. ### Key Points > Here's a question that changed how I think about AI assistants: what if your AI could actually *do things* in the physical world? > Not generate text about doing things. Not suggest what you should do. Actually reach out and interact with hardware — send a text from your real phone number, toggle your flashlight, check your GPS location, take a photo with your camera. > I built exactly that. My Android phone now runs an [MCP server](https://modelcontextprotocol.io/introduction) that exposes 18 hardware tools to any AI client that supports the [Model Context Protocol](https://modelcontextprotocol.io/introduction). When I ask [GitHub Copilot CLI](https://docs.github.com/en/copilot/github-copilot-in-the-cli) to text my wife that I'm running late, it sends a real SMS from my actual phone number. No Twilio. No third-party API. Just my phone, a Node.js server, and an open standard. --- ## Agent Skills: Microsoft Just Shipped What You've Been Building **Published:** 2026-05-15 **Tags:** GitHub Copilot, Visual Studio, AI Agents, Platform Engineering, Deep Dive **URL:** https://htek.dev/articles/agent-skills-microsoft-just-shipped-what-youve-been-building **Markdown:** https://htek.dev/articles/agent-skills-microsoft-just-shipped-what-youve-been-building.md Visual Studio just productized the skills pattern. Here's how I've been running 71 skills across 50 agents since before Microsoft shipped it. ### Key Points > On May 13, 2026, [Microsoft shipped Agent Skills in Visual Studio](https://devblogs.microsoft.com/visualstudio/agent-skills-reusable-capabilities-visual-studio/) — a pattern for giving AI agents reusable, on-demand capabilities instead of cramming everything into prompts. It's the official productization of what builders like me have been doing for months: extracting repeatable procedures out of agent instructions and loading them only when needed. > I've been running **71 skills across 50 production agents** on [GitHub Copilot](https://github.com/features/copilot) since before Microsoft made it official. My family's entire life — finances, meals, content publishing, home maintenance — runs on this pattern. And the moment Microsoft announced Agent Skills, I knew: this is the architecture that scales. > **Want the complete implementation guide with real SKILL.md templates and the Agent vs Skill decision framework?** [**Subscribe to the newsletter**](/newsletter/) **→** Issue #3 has the step-by-step playbook, code samples, and the full 71-skill taxonomy. --- ## What Is Context Engineering? A Practical Guide from Building 50 Production AI Agents **Published:** 2026-05-14 **Tags:** GitHub Copilot, Context Engineering, AI Agents, Agentic Development, Deep Dive **URL:** https://htek.dev/articles/what-is-context-engineering-practical-guide-50-agents **Markdown:** https://htek.dev/articles/what-is-context-engineering-practical-guide-50-agents.md Context engineering is the discipline of designing what AI agents see, remember, and act on. Here's what I learned building a 50-agent, 71-skill platform. ### Key Points > Here's the uncomfortable truth about AI agent context: the model is rarely the bottleneck. The context is. > I've spent the last six months building what I call the "Rocha Family Home OS" — a platform of **50 autonomous AI agents** and **71 reusable skills**, all orchestrated by [GitHub Copilot](https://github.com/features/copilot). These agents manage everything from family finances and meal planning to content publishing and home maintenance. They run on cron schedules, communicate across sessions, and maintain persistent memory. > And the single most important discipline I've developed isn't prompt engineering. It's **context engineering** — the art and science of designing what each agent sees, remembers, and acts on at every moment. --- ## Why Your AI Agents Keep Forgetting Everything (And the Fix) **Published:** 2026-05-14 **Tags:** Context Engineering, Agentic Development, AI Agents, Platform Engineering, Deep Dive **URL:** https://htek.dev/articles/why-your-ai-agents-keep-forgetting-everything **Markdown:** https://htek.dev/articles/why-your-ai-agents-keep-forgetting-everything.md AI agents that lose context between sessions are the #1 failure mode. Here's a preview of the 4-tier memory system I use across 43 production agents. ### Key Points > *This is a preview of what subscribers get every week in the [htek.dev newsletter](https://htek.dev/newsletter). The full implementation — with production configs, real prompts, and working code — is in Issue #2.* > You build an agent. It works brilliantly on Tuesday. By Thursday, it's asking the same questions it already answered. By next week, it's lost every decision, every preference, every lesson it learned. > This isn't a model problem. It isn't a prompt problem. It's a **memory architecture** problem — and it's the single most common reason agentic systems fail in production. --- ## Stop Trusting AI Agents with Git — Start Governing Them **Published:** 2026-05-13 **Tags:** GitHub Copilot, Copilot CLI, Agentic Development, Security, Deep Dive **URL:** https://htek.dev/articles/hookflows-governed-git-for-ai-agents **Markdown:** https://htek.dev/articles/hookflows-governed-git-for-ai-agents.md AI agents make silent git mistakes that compound into real damage. Here's the pattern I use to block raw git and replace it with governed tools. ### Key Points > I run AI agents as my primary development interface — not just for code generation, but for the *entire lifecycle*: branching, committing, pushing, PR creation, deployment. I use [git worktrees](/articles/git-worktree-unlocks-agentic-development) extensively for parallel work streams, which means the surface area for agent mistakes is enormous. > And agents make mistakes. Not maliciously. Not because they're broken. Because they're **non-deterministic**. > You tell an agent to "commit and push this change," and most of the time it does exactly what you'd expect. But often enough to matter? It creates a branch off `HEAD~3` instead of `main`. It pushes to the wrong remote. It runs `git add .` in the repo root instead of the worktree. It stages your `.env` file. It invents a merge strategy you didn't ask for. --- ## I Turned My Android Phone Into an MCP Server — Now My AI Can Text People **Published:** 2026-05-11 **Tags:** GitHub Copilot, Copilot CLI, Model Context Protocol, Automation, Tutorial, Open Source **URL:** https://htek.dev/articles/phone-mcp-server-android-ai-assistant **Markdown:** https://htek.dev/articles/phone-mcp-server-android-ai-assistant.md A Node.js MCP server running on Android via Termux that gives GitHub Copilot CLI control over SMS, contacts, flashlight, camera, and 14 more phone features. ### Key Points > Last week I asked my AI assistant to text my wife that I was running late. It did. From my phone. No Twilio. No third-party API. Just my actual phone number, sending a real SMS, triggered by a natural language request to [GitHub Copilot CLI](https://docs.github.com/en/copilot/github-copilot-in-the-cli). > The trick? I turned my Android phone into an [MCP server](https://modelcontextprotocol.io/introduction). > MCP — the Model Context Protocol — is the open standard that lets AI assistants connect to external tools and data sources. Think of it as USB-C for AI: one standard plug, infinite peripherals. My phone is now one of those peripherals. Copilot CLI connects to it over WiFi, and suddenly my AI can read my messages, look up contacts, control the flashlight, check battery status, take photos, adjust volume, and more — 18 tools in total. --- ## Two Client Sites in 3 Days: Agentive Context Engineering in Action **Published:** 2026-05-10 **Tags:** GitHub Copilot, Context Engineering, Agentic Development, Automation, Case Study **URL:** https://htek.dev/articles/two-client-sites-three-days-agentive-context-engineering **Markdown:** https://htek.dev/articles/two-client-sites-three-days-agentive-context-engineering.md How I shipped two production websites simultaneously using agentive context engineering, custom AI agents, and structured workflows. ### Key Points > **Agentive context engineering** turned what should have been a month-long grind into a three-day sprint. A few weeks ago, two people needed websites at the same time. One was an e-commerce site for a pickleball brand. The other was a service site for a mobile car detailing business. Both needed to be production-ready, custom-designed, and live on their own domains — fast. > I shipped both in roughly three days. Not MVPs. Not templates with swapped logos. Fully custom, client-approved, deployed-to-production websites — built simultaneously while I was going back and forth from the NICU visiting my premature twins, keeping the house running, and managing everything from my phone. > This isn't a flex. It's a case study in what happens when you stop treating AI as an autocomplete engine and start treating it as a **development partner** inside a structured, repeatable workflow. I call the approach **agentive context engineering**, and it changes everything about how client work gets done. --- ## Code Is No Longer the Asset. Workflows Are the New Commodity. **Published:** 2026-05-10 **Tags:** Context Engineering, Agentic Development, Developer Experience, Automation, Opinion **URL:** https://htek.dev/articles/workflows-are-the-new-commodity **Markdown:** https://htek.dev/articles/workflows-are-the-new-commodity.md Why agentic developers who ship fast aren't cutting corners — they've mastered context engineering and process. Here's how to evaluate (and become) one. ### Key Points > Imagine you're hiring a contractor to build your house. You get three bids. Two of them say six months. One says three weeks. > Your gut reaction to the three-week bid? *Something's wrong.* They must be cutting corners. They'll use cheap materials. The foundation will crack. No one builds that fast without sacrificing quality. > But what if you visited their previous builds? What if every house was structurally flawless, beautifully finished, and still standing five years later? What if they'd simply built so many houses, with such refined processes and [context engineering workflows](/articles/context-engineering-key-to-ai-development), that they could execute at a speed that *looks* impossible to someone who hasn't seen their workflow? --- ## The 3 Pillars of Agentic DevOps: From Zero to Hero **Published:** 2026-05-09 **Tags:** GitHub Copilot, Agentic Development, DevOps, Platform Engineering, Deep Dive **URL:** https://htek.dev/articles/three-pillars-agentic-devops-zero-to-hero **Markdown:** https://htek.dev/articles/three-pillars-agentic-devops-zero-to-hero.md Agentic DevOps isn't one tool — it's three continuous feedback loops. Here are the 3 pillars that take you from beginner to fully autonomous. ### Key Points > Today I'm doing a LinkedIn Live session called "Copilot Zero to Hero." The goal is to show how I went from basic Copilot autocomplete to a platform where 45+ agents, 63 skills, and 50 cron jobs autonomously maintain themselves — and how anyone can follow the same path. > But here's what I realized while preparing: the journey from zero to hero isn't about learning more features. It's about building **three continuous feedback loops** that compound on each other. I'm calling them the 3 Pillars of Agentic DevOps. > If you've followed my writing on [the agentic development maturity curve](/articles/agentic-development-maturity-curve), you know the journey isn't linear. The 3 pillars map directly to three maturity levels: **Builder**, **Pro**, and **Hero**. Each pillar unlocks the next. Skip one, and the whole thing wobbles. --- ## CI/CD/...CAI? Continuous AI and the Evolution of DevOps in the Agentic Era **Published:** 2026-05-08 **Tags:** GitHub Copilot, Agentic Development, DevOps, CI/CD, GitHub Actions, Deep Dive **URL:** https://htek.dev/articles/agentic-development-in-devops-complete-guide **Markdown:** https://htek.dev/articles/agentic-development-in-devops-complete-guide.md Continuous AI is the new branch of DevOps. From CI/CD to agentic workflows — how the entire discipline is evolving and why DevOps engineers need to act now. ### Key Points > You know CI. You know CD. Now there's a new acronym muscling its way into the DevOps lexicon: **CAI — Continuous AI**. And if you're a DevOps engineer, SRE, or platform engineer who hasn't started paying attention, you're already behind. > This isn't hype. The [2025 DORA Report](https://dora.dev/dora-report-2025/) — now titled **"State of AI-assisted Software Development"** — surveyed [nearly 5,000 technology professionals](https://cloud.google.com/blog/products/ai-machine-learning/announcing-the-2025-dora-report) and found that [90% already use AI in their development workflow](https://hyperdev.matsuoka.com/p/dora-2025-ai-as-amplifier-not-magic). But only 17% use autonomous agents. That gap is where the opportunity lives — and where the danger hides. Teams with strong DevOps foundations see amplified returns from AI adoption. Teams without them see a [7.2% drop in delivery stability](https://hyperdev.matsuoka.com/p/dora-2025-ai-as-amplifier-not-magic). AI doesn't fix broken processes. It magnifies them. > In February 2026, GitHub launched [Agentic Workflows](https://github.blog/ai-and-ml/automate-repository-tasks-with-github-agentic-workflows/) in technical preview — AI agents running inside GitHub Actions, authored in Markdown instead of YAML. Gartner projects [90% of enterprise software engineers will use AI code assistants by 2028](https://www.buildmvpfast.com/blog/ai-agents-ci-cd-pipeline-devops-automation-2026). The entire DevOps discipline is evolving, and Continuous AI is the branch that's driving that evolution. --- ## The Agentic Development Maturity Curve: Why Experts Return to Simplicity **Published:** 2026-05-06 **Tags:** GitHub Copilot, Agentic Development, Context Engineering, Developer Experience, Opinion **URL:** https://htek.dev/articles/agentic-development-maturity-curve **Markdown:** https://htek.dev/articles/agentic-development-maturity-curve.md Agentic development follows an inverted-U complexity curve. Here's why mastery looks like simplicity — and how to skip the pain of the middle. ### Key Points > There's a pattern I keep seeing in agentic development that almost nobody talks about. It looks like an inverted U: > **Stage 1**: Low maturity, low complexity. You throw one big prompt at an agent. "Build me an app." That's what you think agentic coding is. > **Stage 2**: Mid maturity, HIGH complexity. Multiple agents, hooks, hookflows, governance patterns, test-driven development with agents, skill extraction, orchestration layers. Everything is meticulously organized. --- ## I Taught My AI Agent to Restart Itself **Published:** 2026-05-05 **Tags:** GitHub Copilot, Copilot CLI, AI Agents, Automation, Case Study, Open Source **URL:** https://htek.dev/articles/copilot-cli-self-restart-extension **Markdown:** https://htek.dev/articles/copilot-cli-self-restart-extension.md A Copilot CLI extension that lets agents programmatically kill and respawn their own session — and the Windows process tree trap I had to solve to make it work. ### Key Points > Here's a scenario that will sound familiar if you're building autonomous agents with [GitHub Copilot CLI](https://docs.github.com/en/copilot/github-copilot-in-the-cli): your orchestrator agent creates a brand-new custom agent — writes the `.github/agents/budget-review.agent.md` file, commits it, and then tries to delegate work to it via the `task` tool. Except... it can't. The new agent doesn't exist yet, at least not in the running session's registry. > The `task` tool's `agent_type` list is frozen at session start. Your new agent won't be discoverable until a fresh session begins. And there's no built-in way to restart from within the session. > So you close the terminal. Reopen it. Resume. It works now. But if your agent platform does this ten times a day — creating specialized agents on the fly based on family needs, work context, or content pipelines — that manual restart becomes the single biggest bottleneck in your entire autonomous workflow. --- ## Agent Mesh: How I Made My Copilot CLI Sessions Talk to Each Other **Published:** 2026-05-01 **Tags:** Copilot CLI, AI Agents, Agentic Development, Automation, Tutorial, Open Source **URL:** https://htek.dev/articles/agent-mesh-cross-session-communication-copilot-cli **Markdown:** https://htek.dev/articles/agent-mesh-cross-session-communication-copilot-cli.md A single-file extension that gives GitHub Copilot CLI sessions cross-session communication via SQLite IPC. Zero dependencies, zero config. ### Key Points > If you run [GitHub Copilot CLI](https://docs.github.com/en/copilot/github-copilot-in-the-cli) in multiple terminals — say one for a frontend repo, one for an API, and another for infrastructure — those sessions have no idea the others exist. Each one is completely isolated. No shared context. No way to ask another session a question. No way to delegate work across repos. > I hit this wall the moment my setup grew beyond one terminal. I have a [home assistant system](/articles/copilot-home-assistant-ai-runs-my-household) managing my family's daily life in one repo, a work assistant handling Microsoft sales data in another, and a [video pipeline](/articles/introducing-vidpipe-ai-video-pipeline) processing content in a third. These agents needed to coordinate — my personal calendar needed to block time on my work calendar, my content pipeline needed to notify my home assistant when a video was published, and I needed a single command to ask "who's online?" > So I built [agent-mesh](https://github.com/htekdev/agent-mesh). It's a single-file [Copilot CLI extension](/articles/github-copilot-cli-extensions-complete-guide) that creates a lightweight message bus between sessions using nothing but SQLite. No external dependencies. No config. No server to run. Copy one file and your sessions can talk to each other. --- ## I Automated Work-Life Calendar Sync With Two AI Agents That Talk to Each Other **Published:** 2026-05-01 **Tags:** GitHub Copilot, Copilot CLI, AI Agents, Automation, Case Study **URL:** https://htek.dev/articles/work-life-calendar-sync-agent-mesh **Markdown:** https://htek.dev/articles/work-life-calendar-sync-agent-mesh.md Personal Google Calendar events now auto-sync as Out of Office blocks on my work Outlook — powered by two Copilot CLI agents communicating across an agent mesh. ### Key Points > Every developer with a day job and a personal life has two calendars. My work Outlook has team syncs, 1:1s, and planning meetings. My personal Google Calendar has doctor appointments, NICU visits for [my premature twins](/articles/coding-agent-as-life-assistant-nicu), kid pickups, recording sessions, and the occasional oil change. > The problem isn't having two calendars. The problem is that **nobody at work can see the personal one.** So a coworker schedules a meeting at 10 AM on Tuesday — right on top of my wife's OB appointment. I catch it at 9:45, scramble to decline, and look unprofessional. Or worse, I don't catch it. > The manual fix is tedious: open Google Calendar, find the event, open Outlook, create a matching "Out of Office" block, repeat for every new event, every change, every cancellation. I was doing this three or four times a week. Then I stopped doing it because humans are bad at repetitive cross-system data entry. Then I missed more meetings. --- ## Auto-Maintaining Reference Pages with GitHub Copilot CLI **Published:** 2026-04-27 **Tags:** GitHub Copilot, GitHub Actions, Automation, Developer Experience, Case Study **URL:** https://htek.dev/articles/auto-maintaining-reference-pages-copilot-cli **Markdown:** https://htek.dev/articles/auto-maintaining-reference-pages-copilot-cli.md How I use GitHub Copilot's SWE agent to spin up curated reference sites on GitHub Pages and keep them automatically updated. ### Key Points > Every technology I demo has official documentation. Microsoft Learn, GitHub Docs, MDN — they're comprehensive, authoritative, and... overwhelming. When I'm live in front of a customer showing GitHub Copilot in Visual Studio and someone asks "where can I see what's new?", I don't want to navigate them through five levels of Microsoft Learn. I want one URL that answers the question in three seconds. > That's the gap: official docs optimize for completeness. Demo-ready references optimize for **speed to answer**. I needed curated, opinionated reference pages that surface exactly the information my audience needs — and nothing else. > 1. **One GitHub repo** with a clear, single purpose 2. **Static site** deployed to GitHub Pages (zero infrastructure cost) 3. **Curated content** — I decide what goes in, not an algorithm 4. **Auto-maintenance** — GitHub Copilot's SWE agent keeps it current --- ## I Repurposed a Coding Agent as a Life Assistant. Then My Twins Came 10 Weeks Early. **Published:** 2026-04-21 **Tags:** GitHub Copilot, Copilot CLI, AI Agents, Agentic Development, Case Study **URL:** https://htek.dev/articles/coding-agent-as-life-assistant-nicu **Markdown:** https://htek.dev/articles/coding-agent-as-life-assistant-nicu.md When my premature twins hit the NICU, a repurposed coding agent kept my family running. Here are the six patterns that held. ### Key Points > My twins arrived at 30 weeks. Ten weeks early. About two pounds each. Within minutes they were intubated, lines placed, wheeled to the NICU. My wife was in recovery. My 4-year-old was at home with a babysitter who didn't know what was happening. I was standing in a hallway between two worlds, holding a phone that wouldn't stop buzzing. > Morning briefing. Three calendar events. Two overdue tasks. A pumping schedule reminder for Paula. Content queued to 14 platforms. A bill due Friday. > A **coding agent** — [GitHub Copilot CLI](https://docs.github.com/en/copilot/github-copilot-in-the-cli) running in a terminal on my desktop — was managing my family's life. And in that moment, it was the only thing keeping the gears turning while I couldn't. --- ## I Open-Sourced the AI That Runs My Household **Published:** 2026-04-14 **Tags:** GitHub Copilot, Copilot CLI, AI Agents, Agentic Development, Automation, Case Study, Open Source **URL:** https://htek.dev/articles/copilot-home-assistant-ai-runs-my-household **Markdown:** https://htek.dev/articles/copilot-home-assistant-ai-runs-my-household.md 17 agents, 16 extensions, 15 cron jobs — one family. Here's the Copilot Home Assistant that manages our entire life via Telegram. ### Key Points > Last Tuesday, my phone buzzed at 5:03 AM with a morning briefing: weather, three calendar events, two overdue tasks, a bill due Friday, and a reminder that the HVAC filter was overdue for replacement. I hadn't asked for any of it. By 6:15, I'd knocked out the first task — refill a prescription — and the system automatically served me the next one. > That's not a productivity app. It's not Alexa with extra steps. It's a **multi-agent AI system** running on [GitHub Copilot CLI](https://docs.github.com/en/copilot/github-copilot-in-the-cli), communicating through Telegram, managing everything from groceries to OB appointments to content scheduling — and I just [open-sourced the whole thing](https://github.com/htekdev/copilot-home-assistant). > It started with a [single-file Telegram bridge](/articles/who-needs-openclaw-copilot-cli-extensions) — a few hundred lines of JavaScript that let me chat with Copilot CLI from my phone. Then I added a [cron scheduler and OpenShell sandboxing](/articles/safe-openclaw-cron-iac-openshell). Then meal planning. Then budget tracking. Then a task coach that understood my ADD brain needed tasks served one at a time, not dumped in a list. --- ## Your AI Terminal, In Your Pocket: Connect GitHub Copilot CLI to Telegram **Published:** 2026-04-11 **Tags:** GitHub Copilot, Copilot CLI, Automation, Agentic Development, Tutorial **URL:** https://htek.dev/articles/copilot-cli-telegram-bridge-mobile-ai-terminal **Markdown:** https://htek.dev/articles/copilot-cli-telegram-bridge-mobile-ai-terminal.md Build a Telegram bridge for GitHub Copilot CLI — bidirectional messaging, photo support, voice transcription, and cron-scheduled agents from your phone. ### Key Points > Picture this: you're walking the dog, waiting at the dentist, or three beers deep at a barbecue — and you need to check on a deployment, ask your agent to look something up, or kick off a data pipeline. You pull out your phone, open Telegram, type a message, and your GitHub Copilot CLI session on your desktop responds. The answer comes back right there in the chat. > That's what we're building. A **Telegram bridge extension** that turns your Copilot CLI session into a bidirectional chat — every message you send in Telegram becomes a prompt in the CLI, and every assistant response gets forwarded back. No VPN, no SSH, no remote desktop. Just Telegram. > *Everything your pocket terminal can do — one extension file, five powerful capabilities.* --- ## Safe OpenClaw, Part Two: Cron Jobs, IaC, and the OpenShell Sandbox **Published:** 2026-04-06 **Tags:** GitHub Copilot, Copilot CLI, Terraform, Infrastructure as Code, Case Study **URL:** https://htek.dev/articles/safe-openclaw-cron-iac-openshell **Markdown:** https://htek.dev/articles/safe-openclaw-cron-iac-openshell.md From a Telegram bridge to cron scheduling, Terraform on AWS, and NVIDIA OpenShell sandboxing — how Safe OpenClaw grew into a multi-layer platform. ### Key Points > In [part one](/articles/who-needs-openclaw-copilot-cli-extensions), I built a Telegram bridge to GitHub Copilot CLI in a single `.mjs` file. The pitch was simple: OpenClaw is a full personal AI assistant framework with a gateway daemon, 20+ channel integrations, and thousands of lines of infrastructure. We did the same core thing — chat with your coding agent from your phone — in ~420 lines and zero external dependencies. > That was the proof of concept. What happened next was the natural question: *what does this look like when it's actually running in production?* > 1. **A cron scheduler extension** — so the agent can act on a schedule, not just on demand 2. **Infrastructure as Code** — so deploying the whole thing is `terraform apply` and nothing else 3. **NVIDIA OpenShell sandboxing** — the part that transforms this from a fun hack into something you'd actually trust --- ## Who Needs OpenClaw When You Have GitHub Copilot CLI Extensions? **Published:** 2026-04-03 **Tags:** GitHub Copilot, Copilot CLI, Automation, Agentic Development, Opinion, Open Source **URL:** https://htek.dev/articles/who-needs-openclaw-copilot-cli-extensions **Markdown:** https://htek.dev/articles/who-needs-openclaw-copilot-cli-extensions.md I built a Telegram bridge to GitHub Copilot CLI in one file. ~420 lines. No gateway, no daemon, no framework. Here's how the extension SDK makes full agent frameworks feel like overkill — and what happens when you add NVIDIA OpenShell to the mix. ### Key Points > I was lying in bed last night thinking about [OpenClaw](https://github.com/openclaw/openclaw) — the open-source personal AI assistant framework that connects to 20+ messaging channels (WhatsApp, Telegram, Slack, Discord, Signal, iMessage, Teams, IRC, Matrix...). It's an impressive project. Gateway daemon, WebSocket control plane, custom agent runtime, multi-agent routing, onboarding wizard, companion apps, voice wake words, live canvas. Thousands of lines of infrastructure code. > Then I thought: **what if I could do the core thing — chat with an AI coding agent from my phone — in a single file?** > GitHub Copilot CLI has an extension system. You drop an `.mjs` file in `.github/extensions/`, and it gets forked as a child process with access to the full session via JSON-RPC. The SDK gives you everything: --- ## I Built a CI Monitor That Let Me Walk Away From My Terminal **Published:** 2026-03-31 **Tags:** Copilot CLI, GitHub Actions, CI/CD, Automation, Case Study **URL:** https://htek.dev/articles/ci-monitor-extension-agent-ci-feedback-loop **Markdown:** https://htek.dev/articles/ci-monitor-extension-agent-ci-feedback-loop.md A Copilot CLI extension that closes the loop between agent sessions and CI/CD pipelines. Say what you want, walk away, get notified when it's done. ### Key Points > I was deploying [OpenClaw](https://docs.openclaw.ai/) with [OpenShell sandboxing](https://docs.openclaw.ai/gateway/sandboxing#openshell-backend) to an EC2 instance — Terraform, GitHub Actions, the whole stack. The Copilot CLI agent was doing the heavy lifting: writing Terraform configs, bash scripts, workflow YAML, pushing code. But every time it pushed, the workflow broke. And here was my job: > 1. Watch the agent push 2. Switch to the browser 3. Open the GitHub Actions tab 4. Wait for the workflow to finish 5. Read the logs to figure out what failed 6. Switch back to the terminal 7. Paste the relevant error into the session 8. Watch the agent fix it and push again 9. Go back to step 2 > I did this **fifteen times** in a single session. Seventy-eight turns. I wasn't engineering. I was a human webhook — copying CI output from one screen to another. --- ## Copilot CLI Extensions Cookbook: 16 Production-Ready Examples You Can Copy Today **Published:** 2026-03-26 **Tags:** GitHub Copilot, Copilot CLI, Automation, Testing, Tutorial **URL:** https://htek.dev/articles/copilot-cli-extensions-cookbook-examples **Markdown:** https://htek.dev/articles/copilot-cli-extensions-cookbook-examples.md From security shields to CI status checkers — complete, working Copilot CLI extension examples organized by category. Copy, paste, reload, done. ### Key Points > I've been building Copilot CLI extensions for weeks now, and I keep discovering patterns I wish I'd had from day one. Not theory — actual working code that solves real problems. Every time I cracked a new pattern, I thought "someone should just publish a cookbook." So here it is. > If you want the full architecture breakdown and API reference, check out the [complete guide](/articles/github-copilot-cli-extensions-complete-guide). This article is the companion cookbook — all code, all examples, ready to copy. No hand-waving, no pseudocode. Every snippet here is a complete, working extension you can drop into your project right now. > The setup is the same for every example: create a file at `.github/extensions//extension.mjs` in your repo. The `@github/copilot-sdk` package is auto-resolved by the CLI runtime — no `npm install` needed. After creating or editing an extension, run `extensions_reload` in your session or type `/clear` to activate it. That's it. Let's build. --- ## Research → Plan → Implement — The Anti-Vibe-Coding Workflow **Published:** 2026-03-24 **Tags:** GitHub Copilot, Agentic Development, Context Engineering, Testing, Best Practices **URL:** https://htek.dev/articles/research-plan-implement-anti-vibe-coding-workflow **Markdown:** https://htek.dev/articles/research-plan-implement-anti-vibe-coding-workflow.md Dex Horthy coined the RPI framework to beat hallucinated AI code. Here's how Research, Plan, and Implement phases — with human review gates — transform how you build with AI agents. ### Key Points > A few weeks ago, I assigned a GitHub Copilot coding agent to write and publish an article for this site. I gave it a topic, pointed it at the codebase, and let it run. The agent did exactly what I asked: it wrote an article and opened a PR. > The article was confident, well-structured, and completely hallucinated. It cited things that didn't happen, referenced features that didn't exist, and invented a narrative that had no grounding in reality. [PR #105](https://github.com/htekdev/htek-dev-site/pull/105) stands as the monument to what happens when you skip the research phase. > This is the vibe-coding problem — applied not just to code, but to anything an AI agent produces without first understanding its context. Agents that jump straight to output without grounding themselves in what's actually true produce confident-sounding garbage. The fix isn't a better model. It's a better workflow. --- ## az prototype — Scaffold Enterprise Azure Solutions with Copilot **Published:** 2026-03-23 **Tags:** Azure, Terraform, Bicep, AI Agents, Cloud Architecture, Tool Review **URL:** https://htek.dev/articles/az-prototype-scaffold-enterprise-azure-with-copilot **Markdown:** https://htek.dev/articles/az-prototype-scaffold-enterprise-azure-with-copilot.md az prototype is a new Azure CLI extension that uses a 12-agent AI team to take you from idea to deployed Azure infrastructure in four commands. Here's what it can do and why enterprise teams should pay attention. ### Key Points > I've spent a lot of time writing about [context engineering](/articles/context-engineering-key-to-ai-development), [agentic DevOps](/articles/agentic-devops-next-evolution-of-shift-left), and [multi-agent systems](/articles/agentic-ai-transforming-dev-teams). The pattern I keep coming back to: the teams moving fastest aren't the ones with the best prompts — they're the ones who've wired AI directly into their toolchains so it acts at the right level of abstraction. > `az prototype` is one of the most direct expressions of that idea I've seen come out of Microsoft. It's a new Azure CLI extension — currently in public preview, targeting a stable release in March 2026 — that lets you go from a napkin idea to a deployed Azure prototype in four commands: > That's not a toy demo. Behind those four commands is a 12-agent AI team, support for three AI providers (GitHub Copilot, GitHub Models, Azure OpenAI), enterprise-grade naming conventions, Infrastructure as Code generation in Terraform or Bicep, and policy-enforced security scanning before anything touches your subscription. If you work in enterprise cloud or partner solution delivery, this matters. --- ## Claude Code Channels — Anthropic Just Made AI Agents Event-Driven **Published:** 2026-03-23 **Tags:** AI Agents, Model Context Protocol, Automation, Deep Dive **URL:** https://htek.dev/articles/claude-code-channels-anthropic-event-driven-ai-agents **Markdown:** https://htek.dev/articles/claude-code-channels-anthropic-event-driven-ai-agents.md Anthropic's new Channels feature turns Claude Code into a persistent, event-reactive agent you can control from Telegram or Discord. Here's what changed and why it matters. ### Key Points > Up until last week, every interaction you had with an AI coding agent started the same way: you opened a terminal, typed a prompt, and waited. The agent did its thing. You came back. It was transactional — ask, receive, repeat. That model has served us reasonably well, but it's been holding back a more powerful pattern. > Anthropic just changed that with [Claude Code Channels](https://the-decoder.com/anthropic-turns-claude-code-into-an-always-on-ai-agent-with-new-channels-feature/), a new feature that turns Claude Code from a command-driven assistant into an **event-reactive agent** — one that can wake up when CI fails, respond to a message from your phone at 2am, and notify you when a long-running task finishes. All without you sitting in front of a terminal. > This is the event-driven architecture pattern showing up in AI tooling, and it's a much bigger shift than it sounds. --- ## Copilot CLI --remote: Access Your Agent From Anywhere **Published:** 2026-03-23 **Tags:** GitHub Copilot, Copilot CLI, Developer Experience, Agentic Development, Deep Dive **URL:** https://htek.dev/articles/copilot-cli-remote-access-your-agent-from-anywhere **Markdown:** https://htek.dev/articles/copilot-cli-remote-access-your-agent-from-anywhere.md Copilot CLI 1.0 ships a game-changing remote access model. Your agent now lives across devices, browsers, and SSH sessions — not just your local terminal. ### Key Points > Here's a workflow I used to lose sleep over: I'd spend an hour on my workstation building up a long Copilot CLI session — context-rich, deep into a refactor, 15 turns of conversation that captured exactly what I was trying to accomplish. Then my MacBook's battery dies at a coffee shop, or I need to switch to my work laptop for a call, or I'm SSH'd into a cloud VM and want to continue from my home machine. > This is the fundamental flaw in the "AI assistant as local process" model. The more powerful these agents become, the more painful it is when they're tethered to a single device. A great Copilot CLI session isn't just a terminal window — it's a shared understanding of your codebase, your intent, and the work in progress. Losing that context is expensive. > GitHub is solving this with a suite of features in Copilot CLI 1.0 that I'd loosely call the "remote access model." No single `--remote` flag does everything — it's a collection of capabilities that together let you access your agent from anywhere: different devices, browsers, cloud VMs, and IDE integrations. This is barely covered territory. Let's dig in. --- ## Copilot Coding Agent Gets 50% Faster + Full Session Visibility **Published:** 2026-03-23 **Tags:** GitHub Copilot, GitHub Actions, Agentic Development, Developer Experience, Deep Dive **URL:** https://htek.dev/articles/copilot-coding-agent-50-percent-faster-session-visibility **Markdown:** https://htek.dev/articles/copilot-coding-agent-50-percent-faster-session-visibility.md GitHub shipped two critical upgrades to the Copilot coding agent: 50% faster startup and full session traceability. Here's why both matter for agentic workflows. ### Key Points > When you assign a task to the Copilot coding agent — through an issue, the Agents tab, or a `@copilot` mention on a pull request — there's a moment of invisible work before anything happens. The agent spins up a cloud-based development environment, clones your repo, configures dependencies, and fires up its firewall. Only then does it start reading code, reasoning about the problem, and making changes. > That startup phase wasn't free. It was slow enough to break flow, especially when you're iterating rapidly on a PR and need fast feedback. And once the agent *did* start working, you had limited visibility into what it was actually doing during that setup window. If something went wrong, you were digging through GitHub Actions logs to reconstruct what happened. > GitHub shipped two changelog updates on March 19-20, 2026 that directly address both of those problems. The [Copilot coding agent now starts work 50% faster](https://github.blog/changelog/2026-03-19-copilot-coding-agent-now-starts-work-50-faster/), and you now have [full visibility into agent sessions](https://github.blog/changelog/2026-03-19-more-visibility-into-copilot-coding-agent-sessions/) — including a feature that [traces every agent commit back to its session log](https://github.blog/changelog/2026-03-20-trace-any-copilot-coding-agent-commit-to-its-session-logs/). These aren't glamorous announcements, but they're the kind of improvements that change how much you actually trust and use the tool. --- ## GitHub Spec-Kit: Turn English Into Production-Ready Specs **Published:** 2026-03-23 **Tags:** GitHub Copilot, Context Engineering, Agentic Development, Developer Experience, Tool Review, Open Source **URL:** https://htek.dev/articles/github-spec-kit-english-to-production-specs **Markdown:** https://htek.dev/articles/github-spec-kit-english-to-production-specs.md GitHub's open-source Spec-Kit turns plain English feature descriptions into structured, living specifications that AI agents can execute. Here's why it matters for how teams build software. ### Key Points > I've been watching a pattern repeat across teams adopting AI coding tools: someone opens a blank file, writes a vague comment like `// build a user auth system`, and asks Copilot to fill in the rest. The code that comes back often looks fine. It compiles. It might even pass a few tests. But three days later, you're untangling authentication logic that doesn't match your security requirements, a session model that contradicts your database schema, and edge cases nobody thought through. > This is "vibe coding" at its worst — not the fun kind where you're exploring a prototype, but the kind where production-bound features get built on interpretations of half-formed ideas. The AI isn't to blame. It's filling in the gaps you left with plausible-sounding defaults. > The real problem is that we skipped the spec. And [context engineering](/articles/context-engineering-key-to-ai-development) tells us exactly why that matters: AI output quality is directly proportional to what the model sees before it generates a single token. A blank file tells it nothing. --- ## Karpathy Hasn't Written Code Since December — He Just Directs AI Agents Now **Published:** 2026-03-23 **Tags:** AI Agents, Agentic Development, Context Engineering, Developer Experience, Opinion **URL:** https://htek.dev/articles/karpathy-directs-ai-agents-december-shift **Markdown:** https://htek.dev/articles/karpathy-directs-ai-agents-december-shift.md Andrej Karpathy hasn't typed a line of code since December 2025. He now runs 10–20 AI agents in parallel. Here's what that means for the rest of us. ### Key Points > In mid-March 2026, [Andrej Karpathy](https://x.com/karpathy) said something that stopped the developer internet cold: he hasn't typed a single line of code since December 2025. Not one. Instead, he spends his days directing fleets of AI agents — up to 20 running in parallel — who do the actual coding while he manages intent, context, and direction. > Let that sink in. The person who built [nanoGPT](https://github.com/karpathy/nanoGPT) and helped co-found OpenAI doesn't write code anymore. And he's not doing it as a philosophical statement. He's doing it because **it works better**. > Karpathy described his current state as a ["state of psychosis"](https://economictimes.indiatimes.com/tech/artificial-intelligence/ai-researcher-andrej-karpathy-no-longer-writes-code-spends-hours-directing-ai-agents/articleshow/129716812.cms) — not a crisis, but an obsessive, almost intoxicating immersion in what's now possible when you stop being the person who writes code and start being the person who tells systems what to build. He called it a "phase shift" — an irreversible flip, not a gradual evolution. [Before December, most of his work was still hands-on. Then something flipped and it became essentially 100%](https://www.benzinga.com/markets/tech/26/03/51396403/andrej-karpathy-says-ai-agents-are-rewriting-how-software-gets-built-adds-he-hasnt-typed-a-line-of-code-probably-since-december). --- ## Your Agentic Platform Choice Is Invisible Risk — Until It's Too Late **Published:** 2026-03-23 **Tags:** GitHub Copilot, Agentic Development, Security, Platform Engineering, Opinion, Enterprise **URL:** https://htek.dev/articles/leadership-direction-adopting-agentic-platforms **Markdown:** https://htek.dev/articles/leadership-direction-adopting-agentic-platforms.md Gartner predicts 40% of agentic AI projects will be cancelled by 2027. A leadership playbook for choosing the right platform and avoiding the trap. ### Key Points > Every CEO in tech is saying the same thing right now: "We need to be AI-first." Coinbase has mandated AI coding across their engineering org. Lemonade's CEO declared developers who don't use AI will be left behind. Citi is rolling out GitHub Copilot to 40,000 developers. The pressure to adopt agentic AI platforms is immense — and it's coming from the top. > But here's the number that should be on every leadership slide deck: [Gartner predicts that over 40% of agentic AI projects will be cancelled by the end of 2027](https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027). Of the thousands of vendors claiming agentic AI capabilities, Gartner found only about 130 are "real." The rest? Agent washing — rebranding chatbots and automation scripts as autonomous agents. The question isn't whether your organization should adopt agentic AI. It's whether you'll be in the 60% that survives or the 40% that writes it off as an expensive lesson. > *The initial productivity spike is real — but Stanford's study of 120K developers shows median lift is 10-15%, not the 60% vendors promise.* --- ## The Hidden Complexity of Multi-Service Deployments (And How AI Agents Are Fixing It) **Published:** 2026-03-23 **Tags:** DevOps, CI/CD, AI Agents, Automation, Deep Dive **URL:** https://htek.dev/articles/multi-service-deployments **Markdown:** https://htek.dev/articles/multi-service-deployments.md Deploying microservices looks simple until three services fail in sequence. Here's how AI agents are finally making coordinated deployments manageable. ### Key Points > I've been in that war room. Three services down, engineers pointing at different dashboards, nobody sure which service failed first or whether rolling back Service A will actually fix Services B and C, or just create a different problem. The incident post-mortem always says something like "deployment coordination gap" — which is a polite way of saying the team didn't have a plan for what happens when distributed systems fail together. > Multi-service deployments look deceptively simple on paper. You have several services. You deploy them. What's the problem? The problem is that in production, services aren't independent units — they're a web of contracts, dependencies, and timing assumptions. When you deploy them without a coordination strategy, you're not doing a deployment. You're doing a controlled chaos experiment and hoping for the best. > The good news: modern tooling, container orchestration, and — increasingly — AI agents have made coordinated multi-service deployments genuinely tractable. Here's what the real challenges are and what actually works. --- ## NVIDIA OpenShell — The Sandbox Your AI Agents Should Be Running In **Published:** 2026-03-23 **Tags:** GitHub Copilot, Copilot CLI, Security, AI Agents, Deep Dive, Open Source **URL:** https://htek.dev/articles/nvidia-openshell-sandbox-ai-agents **Markdown:** https://htek.dev/articles/nvidia-openshell-sandbox-ai-agents.md NVIDIA open-sourced OpenShell at GTC 2026 — a policy-driven sandbox for AI agents. I contributed the Copilot CLI provider. Here's what I learned. ### Key Points > I've been running autonomous AI agents in production for months. GitHub Copilot in agent mode, Claude Code, custom multi-agent pipelines — all committed code, triggered workflows, modified infrastructure. The results have been genuinely impressive. > But a few weeks ago, I started staring at a question I'd been avoiding: **what exactly can those agents access?** > The honest answer was uncomfortable. My Copilot CLI agent could write to any directory it had permissions to. It could make network requests to arbitrary endpoints. It could spawn subprocesses I didn't explicitly authorize. I had [instructions, hooks, and gates](/articles/sandboxes-missing-infrastructure-layer-agentic-devops) — three layers of enforcement that made agents structurally better behaved. But all of those layers ran *inside* the agent process. They were policy-as-suggestion, not policy-as-physics. --- ## Git Worktree: The Infrastructure That Unlocks Agentic Development **Published:** 2026-03-19 **Tags:** Git, GitHub Copilot, Agentic Development, Developer Experience, Deep Dive **URL:** https://htek.dev/articles/git-worktree-unlocks-agentic-development **Markdown:** https://htek.dev/articles/git-worktree-unlocks-agentic-development.md Git worktree went from obscure to essential overnight. Here's why every developer using AI agents needs it — and how to set it up. ### Key Points > Here's the scenario: you start a Copilot CLI session to refactor your authentication module. The agent is deep into multi-file edits, running tests, iterating on failures. Fifteen minutes in, Slack pings — production hotfix needed. You stare at your terminal. You can't switch branches. You can't stash the agent's half-finished work. You can't even review a teammate's PR without blowing up the agent's context. > This is the **blocking problem** of agentic development, and every developer using AI coding agents hits it. The traditional workarounds — `git stash`, partial commits, cloning the entire repo again — are fragile, slow, or wasteful. There's a better answer, and it's been hiding in Git since 2015. > **Git worktree** gives you multiple working directories from a single repository. One `.git` database, multiple checkouts, zero duplication of history. And in 2026, it's become the foundational infrastructure that makes parallel agentic development actually work. --- ## NVIDIA OpenShell and the Rise of Agent Sandboxes in Agentic DevOps **Published:** 2026-03-19 **Tags:** Security, DevOps, AI Agents, Agentic Development, Deep Dive, Open Source **URL:** https://htek.dev/articles/sandboxes-missing-infrastructure-layer-agentic-devops **Markdown:** https://htek.dev/articles/sandboxes-missing-infrastructure-layer-agentic-devops.md NVIDIA's OpenShell is the first policy-driven sandbox for AI agents — and why sandboxes are the missing Layer 0 of every agentic DevOps stack. ### Key Points > I've spent months building [layered enforcement architecture](/articles/agent-proof-architecture-agentic-devops) for AI agents — instructions, hooks, gates. Three layers of defense that make agents structurally incapable of shipping untested code. 247 commits, 100% test coverage, zero rollbacks. > But there's a question I kept dodging: **where** are these agents actually running? > GitHub Agentic Workflows gives you a sandboxed runner — a disposable VM that spins up, does work, and disappears. It's excellent. It's also specific to GitHub. The moment your agent needs to hit your staging database, call an internal API, or access credentials to provision infrastructure, that sandbox boundary dissolves. Your agent is operating on real systems with real consequences. --- ## GitHub Copilot CLI Extensions: The Complete Guide **Published:** 2026-03-14 | **Updated:** 2026-05-13 **Tags:** GitHub Copilot, Copilot CLI, Agentic Development, Developer Experience, Deep Dive **URL:** https://htek.dev/articles/github-copilot-cli-extensions-complete-guide **Markdown:** https://htek.dev/articles/github-copilot-cli-extensions-complete-guide.md Create custom tools, intercept agent actions, register slash commands, and customize system prompts — the complete guide to Copilot CLI extensions. ### Key Points > I'm going to say something that sounds absurd: **GitHub Copilot CLI has a full extension system that lets you create custom tools, intercept every agent action, inject context, block dangerous operations, register slash commands, customize the system prompt, and auto-retry errors — and there's essentially zero public documentation about it.** > I'm not talking about [MCP servers](https://docs.github.com/en/copilot/concepts/extensions). I'm not talking about [Copilot Extensions](https://docs.github.com/en/copilot/how-tos/use-copilot-extensions/set-up-copilot-extensions) (the GitHub App kind). I'm talking about `.github/extensions/` — a local extension system baked into the CLI agent harness that runs as a separate Node.js process, communicates over JSON-RPC, and gives you programmatic control over the entire agent lifecycle. > You can literally tell the CLI "create me a tool that does X" and it will scaffold the extension file, hot-reload it, and the tool is available *in the same session*. No restart. No config. No marketplace. Just code. --- ## GitHub Copilot vs. The World: Why the AI Coding War Is Already Over **Published:** 2026-03-12 **Tags:** GitHub Copilot, Copilot CLI, AI-Assisted Development, Developer Experience, Comparison, Enterprise **URL:** https://htek.dev/articles/github-copilot-vs-the-world **Markdown:** https://htek.dev/articles/github-copilot-vs-the-world.md A heated, research-backed breakdown of why GitHub Copilot has already won the AI coding tool war against Claude Code, Cursor, and Windsurf. ### Key Points > Let me save you months of tool-hopping and existential dread: **GitHub Copilot has already won the AI coding tool war.** Not because it was first. Not because it's perfect. But because while everyone else is building fancy editors and CLI tools, GitHub is building a *platform* — and platforms always eat tools for breakfast. > I've watched this space obsessively. I've used Claude Code, Cursor, and Windsurf extensively. I've read every changelog, every acquisition announcement, every "we're the future" blog post from every competitor. And I'm done hedging. Here's the uncomfortable truth the developer community isn't ready to hear. > | Capability | GitHub Copilot | Claude Code | Cursor | Windsurf | |---|---|---|---|---| | **Multi-Model Support** | [GPT-4.1, Claude Sonnet 4, Opus 4.6, Gemini 2.5/3 Pro, Grok](https://docs.github.com/en/copilot/using-github-copilot/ai-models/changing-the-ai-model-for-copilot-chat) | Claude only | OpenAI, Anthropic, Gemini | Limited | | **IDE Coverage** | [VS Code](https://code.visualstudio.com/docs/copilot/overview), [Visual Studio](https://learn.microsoft.com/en-us/visualstudio/ide/visual-studio-github-copilot-install-and-states), [JetBrains](https://plugins.jetbrains.com/plugin/17718-github-copilot), Xcode, Eclipse, Neovim, **[CLI](https://github.blog/changelog/2026-02-25-github-copilot-cli-is-now-generally-available/)** | Terminal only | VS Code fork | Proprietary IDE | | **Terminal Agent** | [Copilot CLI](https://github.com/features/copilot/cli) — sub-agents, `/fleet`, `/plan`, `/resume`, multi-model | Claude Code CLI — deep but single-model | None native | None native | | **Autonomous Agents** | [Coding Agent](https://github.blog/news-insights/product-news/github-copilot-the-agent-awakens/) — assigns to issues, creates PRs | Agentic CLI sessions | Background Agents | Cascade agent | | **Third-Party Agents** | [Claude & Codex agents](https://github.blog/changelog/2026-02-04-third-party-agents-for-copilot-in-public-preview/) in preview | None | None | None | | **Extension Ecosystem** | [Extensions marketplace](https://github.com/features/copilot/extensions), SDK, private extensions | None | Some plugins | Limited | | **MCP Support** | [Full integration](https://github.blog/changelog/2025-04-04-mcp-support-in-copilot/) with governance controls | Creator of MCP, native | MCP support | MCP support | | **Enterprise Controls** | [IP indemnity](https://blogs.microsoft.com/on-the-issues/2023/09/07/copilot-copyright-commitment-ai-legal-concerns/), content exclusions, audit logs, SSO/SAML, SOC 2, ISO 27001 | SOC 2 Type II, HIPAA, limited admin | SSO, SCIM, RBAC | Immature | | **Developer SDK** | [Copilot SDK](https://github.blog/news-insights/product-news/introducing-the-github-copilot-sdk/) — Node.js, Python, Go, .NET | None | None | None | | **Pricing** | Free tier, Pro $10/mo, Pro+ $39/mo, Enterprise $19/user/mo | API usage-based, Max $200/mo | Pro $20/mo, Business $40/user/mo | Pro $15/mo, Teams $35/user/mo | --- ## Stop Pulling Your Agentic Unicorns Off the Field **Published:** 2026-03-12 **Tags:** GitHub Copilot, AI-Assisted Development, Developer Experience, Opinion, Enterprise **URL:** https://htek.dev/articles/stop-pulling-your-agentic-unicorns-off-the-field **Markdown:** https://htek.dev/articles/stop-pulling-your-agentic-unicorns-off-the-field.md Your AI power users deliver 2-6x more output. Pulling them off to train reluctant adopters is the costliest mistake in engineering leadership today. ### Key Points > You finally found one. An engineer on your team who isn't just using Copilot for autocomplete — they're building agents, orchestrating multi-step workflows, shipping automation that replaces entire manual processes. They're your **agentic unicorn**, and they're producing at a level that makes everyone else's output look like a rounding error. > Now someone in leadership wants them to run training sessions. "Scale the knowledge," they say. "Get the rest of the team up to speed." On paper, it sounds reasonable. In practice, it's the most expensive resourcing mistake you can make in 2025. > *The AI productivity gap: research from OpenAI, EY, and GitHub shows the top 5% of users produce outsized results* --- ## I Let an AI Agent Write 275 Tests. Here's What It Was Actually Optimizing For. **Published:** 2026-03-08 **Tags:** GitHub Copilot, Testing, Agentic Development, DevOps, Deep Dive **URL:** https://htek.dev/articles/vibe-testing-when-ai-agents-goodhart-your-test-suite **Markdown:** https://htek.dev/articles/vibe-testing-when-ai-agents-goodhart-your-test-suite.md My AI agent wrote 275 tests and I celebrated. Then an audit found 6 integrity failures. Welcome to vibe testing — Goodhart's Law eating your test suite alive. ### Key Points > My AI agent wrote 275 end-to-end tests in a single session. Forty turns. Thirty-four files. It built a coverage-instrumented binary, a test DSL, an anti-mocking hookflow — genuinely impressive infrastructure. I watched the coverage numbers climb and felt the dopamine hit that every engineer chases. > Then I audited the test suite. Six integrity failures. Weakened assertions. Silently lowered coverage thresholds. Build-tag fakes that routed around the very anti-mocking rules the agent had built earlier in the same session. And the crown jewel: a 160-file refactor triggered by one ambiguous comment I made, which broke the entire lifecycle schema — a regression the agent never questioned. > Everyone's talking about [vibe coding](https://thenewstack.io/vibe-coding-could-cause-catastrophic-explosions-in-2026/) — accepting AI-generated code without understanding it. Nobody's talking about **vibe testing**: when AI agents generate tests that technically pass, inflate your coverage metrics, and give you false confidence that your codebase works. It's Goodhart's Law with a test runner, and it's happening in every codebase that uses AI agents for testing. --- ## Specs = Tests: Why Spec-Driven Terraform Starts With Tests, Not Documents **Published:** 2026-03-06 **Tags:** Terraform, GitHub Copilot, Testing, Infrastructure as Code, Deep Dive **URL:** https://htek.dev/articles/specs-equal-tests-terraform-ai-development **Markdown:** https://htek.dev/articles/specs-equal-tests-terraform-ai-development.md Everyone says start with specs. I say specs ARE tests. Here's why Terraform IaC with AI agents needs test-first thinking, not more documents. ### Key Points > A colleague recently asked me whether spec-driven development applies to Terraform. The question itself reveals a gap in how our industry thinks about specs — and it's a gap that matters a lot more now that AI agents are writing our infrastructure code. > The conventional wisdom goes like this: write a specification document, then write code that implements the spec. Clean. Linear. Professional. And for Terraform Infrastructure as Code, people imagine this means writing architecture documents, naming conventions, and compliance requirements in markdown files, then having GitHub Copilot generate HCL that follows them. > Here's my problem with that: **specs are not deterministically enforceable.** A markdown document that says "all S3 buckets must have encryption enabled" is a suggestion. It's guidance. It's the same category as [agent instructions](/articles/agent-hooks-controlling-ai-codebase) — and I've written extensively about why instructions alone aren't enforcement. An AI agent will read your spec, nod politely, and create an unencrypted bucket anyway because it optimized for something else in its context window. --- ## Agentic-Ops: A Workflow Framework That Brings DevOps to Your AI Agent **Published:** 2026-02-26 **Tags:** Copilot CLI, Agentic Development, DevOps, Shift Left, Tutorial, Open Source **URL:** https://htek.dev/articles/agentic-ops-workflow-framework-for-ai-agents **Markdown:** https://htek.dev/articles/agentic-ops-workflow-framework-for-ai-agents.md Stop blaming AI for messy code. The problem isn't agent velocity — it's that you haven't built the guardrails to match it. ### Key Points > *The difference between fast-and-broken vs fast-and-safe: Agentic-Ops brings DevOps governance to AI agent velocity.* > I watched an AI agent refactor an entire module last week. Seventeen files. Four hundred lines changed. It took about ninety seconds. > The code compiled. The types checked. And it was *completely wrong* — it had imported infrastructure code directly into the domain layer, violating every architectural boundary I'd spent months establishing. --- ## Agent Hooks: The Secret to Controlling AI Agents in Your Codebase **Published:** 2026-02-20 **Tags:** GitHub Copilot, Agentic Development, DevOps, Testing, Deep Dive **URL:** https://htek.dev/articles/agent-hooks-controlling-ai-codebase **Markdown:** https://htek.dev/articles/agent-hooks-controlling-ai-codebase.md Instructions alone aren't enforcement. Here's how I built a hook-based system to make AI agents respect layer boundaries, mock policies, and architecture rules—before code ever hits CI/CD. ### Key Points > Instructions alone are NOT enforcement. That's the hard lesson I learned watching AI agents cheerfully ignore my carefully crafted guidelines and pollute my clean architecture with cross-layer imports. > You can write the most detailed agent instructions in the world. You can create custom agents with specific knowledge. You can even build elaborate context engineering systems. But here's the truth: **what happens when the agent just... doesn't follow them?** > I recently refactored one of my projects into a strict hierarchical layer system—L0 through L7, each with explicit import rules. Without enforcement, it lasted about three commits before an AI agent decided that directly importing infrastructure code into a pure type layer was perfectly reasonable. --- ## Agentic DevOps: Building Agent-Proof Architecture That Lets You Sleep at Night **Published:** 2026-02-20 **Tags:** GitHub Copilot, Agentic Development, DevOps, Testing, CI/CD, Deep Dive **URL:** https://htek.dev/articles/agent-proof-architecture-agentic-devops **Markdown:** https://htek.dev/articles/agent-proof-architecture-agentic-devops.md The agentic AI conversation starts in DevOps. Here's how I built layered enforcement that makes agents structurally incapable of shipping untested code. ### Key Points > I've been running AI agents in production for months now. Not just coding assistants — full autonomous agents that commit code, modify architectures, and push changes. And I sleep fine at night. > Most teams treat agentic AI as a developer productivity problem. They obsess over prompt engineering, context windows, and model selection. Then they wake up to broken builds, untested commits, and agents that cheerfully merged 400 lines of code with zero test coverage. > The real conversation needs to start earlier. You need to bring DevOps thinking into the agentic AI conversation *before* you unleash these things on your codebase. Here's what that actually looks like. --- ## How Agentic AI Is Transforming Development Teams **Published:** 2026-02-20 **Tags:** GitHub Copilot, Agentic Development, Developer Experience, Technical Debt, Opinion, Enterprise **URL:** https://htek.dev/articles/agentic-ai-transforming-dev-teams **Markdown:** https://htek.dev/articles/agentic-ai-transforming-dev-teams.md Development used to be the bottleneck. Now features are easy. The new constraint? Figuring out what to build — and developers are becoming product owners. ### Key Points > I've been watching something shift in the teams I work with, and it's not what most people think when they hear "AI is changing development." > Yes, we're shipping faster. Yes, GitHub Copilot and agentic workflows are accelerating how we write code. But the real transformation isn't about velocity — it's about **who gets to have ideas** and **what becomes the bottleneck**. > For decades, software teams operated in a waterfall hierarchy even when we pretended we were agile: product managers had the ideas, designers made them pretty, and engineers built what they were told. That structure made sense when development was the constraint. When turning an idea into working software took weeks or months, you needed gatekeepers to decide what was worth building. --- ## I Made AI Audit My Entire Codebase for Testability **Published:** 2026-02-20 **Tags:** GitHub Copilot, Copilot CLI, Testing, Refactoring, Code Review, Case Study **URL:** https://htek.dev/articles/ai-audit-codebase-testability **Markdown:** https://htek.dev/articles/ai-audit-codebase-testability.md GitHub Copilot discovered architectural violations I'd been blind to for months. Here's how an AI audit transformed fuzzy test boundaries into a crystal-clear layered architecture. ### Key Points > I thought I knew my codebase. I'd written most of it, reviewed every PR, and could navigate the folder structure in my sleep. But I had a problem I couldn't solve: the line between unit tests, integration tests, and end-to-end tests had become hopelessly blurred. > So I tried something I hadn't done before — I let GitHub Copilot CLI audit my entire codebase for testability. What came back wasn't just helpful. It was a complete X-ray of my architecture that exposed violations I'd been walking past for months. > If you've ever stared at a test suite wondering "is this a unit test or an integration test?", you know the feeling. You mock some things but not others. You're not entirely sure what "layer" you're testing. The tests work, but the strategy is fuzzy. --- ## Building Cryptographic Approval Gates for AI Agents **Published:** 2026-02-20 **Tags:** GitHub Copilot, Copilot CLI, Security, AI Agents, Deep Dive **URL:** https://htek.dev/articles/cryptographic-approval-gates-ai-agents **Markdown:** https://htek.dev/articles/cryptographic-approval-gates-ai-agents.md How I used digital signatures and Copilot hooks to force AI agents to get human approval before writing code — and why instructions alone will never be enough. ### Key Points > Here's the uncomfortable truth about AI agents: no matter how detailed your instructions are, they will eventually write code you didn't want them to write. Not because they're malicious, but because instructions are suggestions, not enforcement mechanisms. > I built a cryptographic approval system using [digital signatures](https://www.w3.org/TR/vc-di-eddsa/), [Copilot agent hooks](https://docs.github.com/en/copilot/reference/hooks-configuration), and an MCP plugin to solve this problem. The system intercepts every write attempt, checks for a valid signature, and only allows it through if the content was explicitly approved by a human. No exceptions, no workarounds. > The best part? GitHub Copilot CLI built the entire plugin from a single prompt — the hook, the CLI, the MCP tool, everything. --- ## The Complete Guide to GitHub Copilot in Visual Studio: Every Feature, Every Shortcut, Every Pattern **Published:** 2026-02-20 **Tags:** GitHub Copilot, Visual Studio, AI-Assisted Development, Developer Experience, Tutorial **URL:** https://htek.dev/articles/github-copilot-visual-studio-guide **Markdown:** https://htek.dev/articles/github-copilot-visual-studio-guide.md From inline completions to agent mode and MCP servers — a hands-on guide to every Copilot feature in Visual Studio with real workflow patterns. ### Key Points > Here's a stat that should bother you: [GitHub reports](https://github.blog/news-insights/research/research-quantifying-github-copilots-impact-on-code-quality/) that developers accept roughly 30% of Copilot's suggestions. That means 70% of the time, the AI is generating something you reject. But here's the thing — acceptance rate isn't the metric that matters. The developers extracting the most value from Copilot aren't just accepting more completions. They're using an entirely different set of features that most people don't even know exist. > Visual Studio's Copilot integration has quietly evolved from a glorified autocomplete into a full agentic coding system. [Agent mode](https://learn.microsoft.com/visualstudio/ide/copilot-agent-mode?view=visualstudio), MCP servers, Next Edit Suggestions, custom instructions, prompt files, code review, model selection — it's a deep toolkit that most developers barely scratch. I use every one of these features daily, and the productivity difference is not incremental. It's a step function. > This guide covers everything. Not a surface-level overview — every feature, every shortcut, every configuration option, and the specific patterns I use to get the most out of each one. Bookmark it. --- ## GitHub Copilot Plan Mode vs Custom AI Agents: A Surprising Discovery **Published:** 2026-02-20 **Tags:** GitHub Copilot, AI Agents, Agentic Development, Developer Experience, Opinion **URL:** https://htek.dev/articles/plan-mode-vs-custom-agents-discovery **Markdown:** https://htek.dev/articles/plan-mode-vs-custom-agents-discovery.md I built a custom article-writing agent, then discovered GitHub Copilot's plan mode was already better. Sometimes the best engineering decision is knowing what NOT to build. ### Key Points > I set out to write an article about recent VS Code updates using my custom article-writing agent. What happened next caught me completely off guard — and taught me an important lesson about when to build custom AI solutions and when to just get out of the way. > The custom agent I'd built was supposed to ask clarifying questions before writing. It had explicit instructions: gather context, understand the audience, clarify the angle. But it only asked me one or two questions before diving into writing. Meanwhile, GitHub Copilot's out-of-the-box plan mode was probing deeper, asking more thoughtful questions, and generally performing *better* than my supposedly specialized tool. > That moment crystallized something I'd been circling around for months: sometimes the best engineering decision is knowing what *not* to build. --- ## Test Enforcement Architecture for AI Agents: When You Make the AI Build Its Own Guardrails **Published:** 2026-02-20 **Tags:** GitHub Copilot, Testing, DevOps, Agentic Development, Automation, Case Study **URL:** https://htek.dev/articles/test-enforcement-architecture-ai-agents **Markdown:** https://htek.dev/articles/test-enforcement-architecture-ai-agents.md I built test coverage enforcement that blocks AI agents from shipping untested code. Then watched the architecture catch an invalid import on the first try. ### Key Points > I shipped a new chat sub-command for ShipClip (the newly-renamed VidPipe) last week. The feature worked perfectly on the **first iteration**. Not "mostly worked." Not "worked after three debugging sessions." It just worked. > This never happens when you vibe code something. You try it, it breaks, you fix it, it breaks differently, you fix that, and eventually it works. But this time I planned it, executed on it, and the agent showed me my scheduled posts exactly as designed. The chat agent manipulated my actual Late.co calendar — swapping posts, rebuilding my entire content week around an "agentic DevOps" theme. > The difference? I didn't just vibe code it. I enforced test coverage at the architectural level, and I made the AI build its own cage. --- ## Tests Are Everything in Agentic AI: Building DevOps Guardrails for AI-Powered Development **Published:** 2026-02-20 **Tags:** GitHub Copilot, Testing, DevOps, Agentic Development, Best Practices **URL:** https://htek.dev/articles/tests-are-everything-agentic-ai **Markdown:** https://htek.dev/articles/tests-are-everything-agentic-ai.md Without comprehensive test coverage, agentic AI will fail. Here's how to build DevOps guardrails that prevent AI from shipping broken code. ### Key Points > I'm going to say something that'll make some people uncomfortable: **if you don't have test coverage in your solution, you're going to fail at using agentic AI.** Not "struggle with it." Not "get mixed results." You will fail. > After months of building [agentic DevOps workflows](/articles/agentic-devops-next-evolution-of-shift-left) and wrestling with AI agents that think they're helpful but actually break things, I've learned this the hard way. AI writes code fast. Really fast. But there's a dark pattern emerging that nobody talks about enough: **AI writes fake tests that pass but test nothing.** > This isn't theoretical. [Research from multiple teams](https://medium.com/@lagarciag/why-ai-generated-tests-prove-less-than-you-think-264bf180c7d6) shows AI-generated tests achieve only 20% mutation scores on real-world code. That means 80% of potential bugs slip right through. The tests compile, they run, they pass — and they validate absolutely nothing. --- ## How I Turned an AI Skeptic and a 13-Year-Old Into Believers **Published:** 2026-02-20 **Tags:** GitHub Copilot, AI-Assisted Development, Developer Experience, Opinion **URL:** https://htek.dev/articles/turning-ai-skeptics-into-believers **Markdown:** https://htek.dev/articles/turning-ai-skeptics-into-believers.md Two conversion stories that prove AI literacy isn't about technical skills—it's about showing people the right use case. ### Key Points > I met a guy at the park last week who only uses AI for one thing: naming his cook-off. That's it. Full stop. > When I asked why, he said he just doesn't see the point. He's not anti-tech—he's just genuinely unconvinced that AI has anything to offer him beyond generating clever names for food events. And here's the uncomfortable truth: there's a whole group of individuals that is completely blind to what's happening in the AI space. Not because they're stupid or resistant to change, but because nobody has shown them *their* use case. > That conversation stuck with me because I'd just spent the previous weekend watching two people discover AI in completely different ways. One was my father-in-law, who needs help operating his phone. The other was my 13-year-old brother-in-law, who'd never written a line of code. By the end of the weekend, one had discovered famous people in his family history through an AI conversation, and the other had shipped working games to GitHub. --- ## Self-Healing Infrastructure with Agentic AI: From Monitoring to Autonomous Resolution **Published:** 2026-02-18 **Tags:** Azure, GitHub Copilot, AI Agents, Automation, DevOps, Deep Dive **URL:** https://htek.dev/articles/self-healing-infrastructure-with-agentic-ai **Markdown:** https://htek.dev/articles/self-healing-infrastructure-with-agentic-ai.md How GitHub Copilot and Claude Code with Azure MCP server are enabling self-healing DevOps environments that detect and fix issues autonomously. ### Key Points > I've been on-call for production systems more times than I can count. You know the pattern: alert fires at 2 AM, you wake up, SSH into a server, run diagnostics, apply a fix, document it, and go back to bed knowing you'll be useless tomorrow. The fix itself? Usually something you've done a dozen times before — restart a service, clear a cache, adjust a configuration value. > Here's what clicked for me recently: **most production incidents aren't novel problems requiring human creativity. They're known failure modes that we've already solved, just manifesting in slightly different ways.** And if that's true, why are humans still the ones resolving them at 2 AM? > Over the past few months, I've been experimenting with something different: agentic AI that monitors infrastructure, detects anomalies, and applies fixes autonomously. Not just alerting me to problems — actually fixing them. Using tools like [GitHub Copilot](https://github.com/features/copilot), [Claude Code](https://claude.ai/), and the [Azure MCP server](https://github.com/microsoft/azure-mcp-server), I've built feedback loops that handle 70% of the incidents that used to wake me up. --- ## Agent Harnesses: Why 2026 Isn't About More Agents — It's About Controlling Them **Published:** 2026-02-16 **Tags:** AI Agents, Agentic Development, Platform Engineering, Security, Deep Dive, Enterprise **URL:** https://htek.dev/articles/agent-harnesses-controlling-ai-agents-2026 **Markdown:** https://htek.dev/articles/agent-harnesses-controlling-ai-agents-2026.md Enterprises average 12 AI agents with only 27% connected. The real engineering challenge isn't building agents — it's the harness that governs them. ### Key Points > Here's a number that should concern every engineering leader: the average enterprise now deploys **12 AI agents**, and that number is projected to hit 20 by 2027. But according to [Salesforce's 2026 Connectivity Benchmark](https://www.ciodive.com/news/it-leaders-grapple-ai-agent-sprawl-integration/811411), only **27% of those agents are connected** to the rest of the stack. The other 73%? Shadow agents — unmonitored, ungoverned, and accumulating technical debt faster than anyone wants to admit. > Microsoft's own telemetry tells a similar story: over 80% of Fortune 500 companies have active AI agents, many built with low-code tools by teams that never coordinated with platform engineering. [Gartner is already calling for AI Agent Management Platforms](https://www.parloa.com/guides-ebooks-and-reports/gartner-ai-agent-sprawl) to contain the sprawl. > We solved "how to build agents" in 2025. The real engineering challenge of 2026 isn't building more agents — it's building the infrastructure that controls them. That infrastructure has a name: the **agent harness**. --- ## Agentic DevOps: The Next Evolution of Shift Left **Published:** 2026-02-16 **Tags:** GitHub Copilot, Agentic Development, DevOps, Shift Left, Deep Dive **URL:** https://htek.dev/articles/agentic-devops-next-evolution-of-shift-left **Markdown:** https://htek.dev/articles/agentic-devops-next-evolution-of-shift-left.md DevOps protected teams from velocity. Agentic AI creates velocity so extreme we need DevOps designed for agents, not humans. ### Key Points > I fell in love with DevOps years ago. After cutting my teeth on software engineering and assembly code, then moving into consulting and cloud-based development, I discovered the real challenge wasn't writing condition statements — it was infrastructure, automation, resilience, and making systems bulletproof. DevOps gave me a framework for all of that. > But over the past year, something clicked. Agentic AI isn't just another tool bolted onto the pipeline. It's fundamentally reshaping what "shift left" means — and it's doing it so aggressively that the DevOps practices I built my career on need to evolve. Not disappear. Evolve. When blockchain and other hyped technologies came along, I saw cool experiments. With AI, I see a cross-sectional revolution — one that touches every industry, every workflow, every team. > Here's what that evolution actually looks like, and why I think **Agentic DevOps** is the concept every engineering team needs to understand right now. --- ## GitHub Agentic Workflows: A Hands-On Guide to AI-Powered CI/CD **Published:** 2026-02-16 **Tags:** GitHub Copilot, GitHub Actions, CI/CD, Automation, Tutorial **URL:** https://htek.dev/articles/github-agentic-workflows-hands-on-guide **Markdown:** https://htek.dev/articles/github-agentic-workflows-hands-on-guide.md I wrote GitHub automation in Markdown instead of YAML. Here's what I learned building 4 AI-powered workflows in 30 minutes. ### Key Points > I just built four production-ready GitHub Actions workflows in 30 minutes. Not YAML templates I copied from Stack Overflow — actual intelligent automation that triages issues, reviews pull requests, and keeps docs in sync. The twist? I wrote them in Markdown. > Full transparency: I built this entire demo using [GitHub Copilot CLI](https://github.com/github/copilot-cli) in agent mode — from scaffolding the API to writing the workflows to debugging the authentication setup. This was a learning exercise for me, a way to explore what's possible with the latest tooling. The [demo repository](https://github.com/htekdev/github-agentic-workflows-demo) is a reference I'll keep building on, but the real value was the hands-on experience of seeing how these pieces fit together. > [GitHub Agentic Workflows](https://github.blog/changelog/2026-02-13-github-agentic-workflows-are-now-in-technical-preview/) entered technical preview on February 13, 2026. The concept is simple: describe what you want your CI/CD to do in natural language, compile it with `gh aw compile`, and it generates GitHub Actions YAML. It's the same shift we saw from assembly to high-level languages, except this time it's for automation. And after spending an afternoon with it, I'm convinced this is where DevOps tooling is headed. --- ## The GitHub Copilot SDK: Agents for Every App **Published:** 2026-02-16 **Tags:** GitHub Copilot, Copilot CLI, TypeScript, AI Agents, Deep Dive, Open Source **URL:** https://htek.dev/articles/github-copilot-sdk-agents-for-every-app **Markdown:** https://htek.dev/articles/github-copilot-sdk-agents-for-every-app.md GitHub's Copilot SDK lets you embed production-grade AI agents in any app with a few lines of code. Here's how it works, with real examples. ### Key Points > GitHub shipped something big on January 22, 2026, and it wasn't another chat feature. The [GitHub Copilot SDK](https://github.com/github/copilot-sdk) takes the exact same agentic engine powering [Copilot CLI](/articles/copilot-cli-biggest-week-yet) — the agent loop that plans, invokes tools, edits files, and manages context — and packages it as a programmable SDK for TypeScript, Python, Go, and .NET. > That's 7,100+ stars in under a month. The repo is seeing multiple commits *per day* from GitHub engineers and community contributors. This isn't a research prototype — it's the production agent runtime, extracted and made embeddable. > In this article, I'll walk through what the SDK actually does, show you code in multiple languages, highlight real apps people are already building, and cover the rapid development pace that makes this worth watching right now. --- ## Top 5 Mistakes When Creating Custom Agents for GitHub Copilot **Published:** 2026-02-16 **Tags:** GitHub Copilot, AI Agents, Agentic Development, Developer Experience, Best Practices **URL:** https://htek.dev/articles/top-5-mistakes-creating-custom-github-copilot-agents **Markdown:** https://htek.dev/articles/top-5-mistakes-creating-custom-github-copilot-agents.md I built a multi-agent system and learned the hard way. Here are the mistakes that'll sink your custom GitHub Copilot agents before they ship. ### Key Points > I recently built a multi-agent article-writing system for this blog: four specialized agents working together — `article-writer`, `fact-extractor`, `link-vetter`, and `synthesizer`. Each one had a clearly defined job. Each one had access to exactly the tools it needed. And each one had detailed instructions explaining how to do its work. > Except one of those agents — the article-writer — had instructions so detailed and verbose that it lost sight of its actual objective. I gave it 15 pages of guidance on formatting, fact-checking, tone matching, source attribution, and audience targeting. The result? Paralysis. The agent got so caught up in the minutiae that it forgot to write compelling articles. That failure taught me something: building effective [custom agents for GitHub Copilot](https://docs.github.com/en/copilot/concepts/agents/coding-agent/about-custom-agents) requires discipline, focus, and brutal editing — not more detail. > Most custom agents fail not because the underlying model is weak, but because developers skip the hard parts: clear scoping, context management, real-world testing, and error handling. Here are the five mistakes I see over and over — mistakes I've made myself. --- ## VS Code's January 2026 Update Turns Your Editor Into an AI Agent Platform **Published:** 2026-02-16 **Tags:** VS Code, GitHub Copilot, AI-Assisted Development, Developer Experience, Deep Dive **URL:** https://htek.dev/articles/vscode-january-2026-copilot-update-roundup **Markdown:** https://htek.dev/articles/vscode-january-2026-copilot-update-roundup.md VS Code 1.109 ships multi-agent workflows, Claude integration, Copilot Memory, and terminal sandboxing. Here's everything that changed. ### Key Points > On February 4, 2026, the [VS Code 1.109 release](https://code.visualstudio.com/updates) quietly shipped one of the most consequential updates in the editor's history. Not because of any single feature — but because of what they add up to. VS Code isn't just an editor with AI bolted on anymore. It's becoming an **agent orchestration platform**. > This release introduces multi-agent workflows, integrates Anthropic's Claude directly alongside Copilot, makes the skills system generally available, and adds terminal command sandboxing. A week later, [VS Code Insiders 1.110](https://code.visualstudio.com/updates/v1_110) pushed the envelope further with language-aware symbol navigation for agents and multimodal Claude support. I've been running Insiders daily, and the pace is staggering. > The biggest story in 1.109 is **agent-driven workflows**. VS Code now supports seamless delegation across local agents, background agents, cloud agents, and [GitHub Copilot](https://github.com/features/copilot) — all within the same session. You can kick off a task with Copilot, hand off subtasks to specialized agents, and get results back in a unified interface. --- ## Agentic Video Editing: A Glimpse into the Future **Published:** 2026-02-14 **Tags:** AI Agents, Agentic Development, Automation, Deep Dive **URL:** https://htek.dev/articles/agentic-video-editing-future **Markdown:** https://htek.dev/articles/agentic-video-editing-future.md AI agents are evolving from single-task tools into autonomous video editors that plan, reason, and execute — here's what that means for creators. ### Key Points > I recently had an AI agent extract audio from a video, generate a transcript, and organize the output — all from a single prompt. It wasn't perfect (the chat history vanished mid-session, which tells you something about the state of persistent memory in agent workflows), but it worked. And it made me think: if an agent can already handle audio extraction and transcription autonomously, what happens when it can do the *entire* edit? > That's not a hypothetical. [Andreessen Horowitz argues](https://a16z.com/its-time-for-agentic-video-editing/) that what Cursor did for coding, video agents will do for production. A [Cambridge research team published a system](https://arxiv.org/abs/2509.16811) that restructures multi-hour narrative video through natural language prompts alone — no timeline scrubbing, no manual cuts. Evaluated across 400+ videos, it scored 4.55/5 on quality from expert raters. We're not talking about toy demos anymore. > The word "agentic" gets thrown around a lot. Here's what it actually means in this context: the AI doesn't just respond to one command — it **plans**, **reasons**, **acts**, and **iterates** through a multi-step workflow with minimal human hand-holding. --- ## AI Fixes Its Own Bugs: The Rise of Self-Healing Software **Published:** 2026-02-14 **Tags:** GitHub Copilot, AI Agents, Automation, Testing, Deep Dive **URL:** https://htek.dev/articles/ai-fixes-its-own-bugs **Markdown:** https://htek.dev/articles/ai-fixes-its-own-bugs.md From Copilot Autofix to SWE-agent, AI systems now detect, diagnose, and repair their own bugs autonomously. Here's how it works and why it matters. ### Key Points > Imagine an AI that fixes its own bugs. That's not science fiction—it's happening now. A developer pushes code, a vulnerability slips through, and before the security team even opens their dashboard, an AI has already generated a patch, validated it against the test suite, and opened a pull request. The human reviewer shows up to find the problem already solved. > I've been watching this space closely, and the shift from _reactive debugging_ to _autonomous repair_ is one of the most consequential changes in how we build software. We're not talking about fancy linting or autocomplete. We're talking about systems that understand code semantically, reason about intent, and generate targeted fixes—sometimes in seconds. > The tools are real, the benchmarks are maturing, and the research is accelerating. Let me walk you through what's actually working today. --- ## Choosing the Right AI SDK: Foundry vs Copilot vs OpenAI **Published:** 2026-02-14 **Tags:** Azure, GitHub Copilot, AI Agents, Cloud Architecture, Comparison **URL:** https://htek.dev/articles/choosing-the-right-ai-sdk **Markdown:** https://htek.dev/articles/choosing-the-right-ai-sdk.md A 3-question decision tree for picking between Azure AI Foundry Agent Service, GitHub Copilot SDK, and OpenAI Agents SDK — with real case studies and rewrite risk. ### Key Points > Every architecture review I've sat in this year eventually hits the same question: "Which AI agent SDK should we use?" And every time, someone wants a single answer. Foundry. Copilot. OpenAI. Pick one. > That's the wrong framing. [BMW achieved 12× faster data analysis](https://www.microsoft.com/en/customers/story/25683-bmw-ag-azure) with Foundry Agent Service. I built an SRE agent with [GitHub Copilot SDK](https://github.blog/news-insights/company-news/build-an-agent-into-any-app-with-the-github-copilot-sdk/) in two hours. [Commerzbank handles 30,000+ monthly agent conversations](https://www.microsoft.com/en/customers/story/25676-commerzbank-ag-azure-ai-foundry-agent-service) in a regulated banking environment. All three SDKs. All three successful. The difference isn't capability — it's constraints. > Give your leadership this instead: the one that matches your constraints TODAY with the least rewrite risk for where you're headed. --- ## Context Engineering: The Key to AI-Assisted Development **Published:** 2026-02-14 **Tags:** GitHub Copilot, Context Engineering, AI-Assisted Development, Prompt Engineering, Deep Dive **URL:** https://htek.dev/articles/context-engineering-key-to-ai-development **Markdown:** https://htek.dev/articles/context-engineering-key-to-ai-development.md Context engineering has replaced prompt engineering as the critical skill for AI-assisted development. Here's how to master it. ### Key Points > Here's a pattern I keep seeing: a developer installs [GitHub Copilot](https://github.com/features/copilot), feeds it a vague prompt, gets mediocre output, and concludes that AI coding tools are overhyped. The problem isn't the model. It's what the model can see. > I've spent months building feedback loops between AI tools and my codebases, and I've landed on a conviction: **context engineering** is the most underrated skill in software development right now. Not prompt engineering — context engineering. The distinction matters more than most developers realize. > When [Andrej Karpathy](https://pureai.com/articles/2025/09/23/karpathy-puts-context-at-the-core-of-ai-coding.aspx) — co-founder of OpenAI — publicly stated "+1 for 'context engineering' over 'prompt engineering'," he wasn't making a semantic quibble. He was pointing at a fundamental shift in how we should think about working with large language models. As he put it, context engineering is "the delicate art and science of filling the context window with just the right information for the next step." --- ## GitHub Copilot CLI's Biggest Week Yet: 7 Releases in 10 Days **Published:** 2026-02-14 **Tags:** GitHub Copilot, Copilot CLI, Model Context Protocol, Developer Experience, Deep Dive **URL:** https://htek.dev/articles/copilot-cli-biggest-week-yet **Markdown:** https://htek.dev/articles/copilot-cli-biggest-week-yet.md Seven releases, alt-screen revolution, VS Code integration, and memory fixes. GitHub Copilot CLI just shipped its biggest week yet—and I wrote this article using the tool itself. ### Key Points > I'm writing this article about [GitHub Copilot CLI](https://github.com/github/copilot-cli) using GitHub Copilot CLI. That's not a gimmick — it's evidence. Between February 5 and February 14, 2026, the Copilot CLI team shipped **seven releases** (v0.0.404 through v0.0.410). Seven. In ten days. That's not iterative improvement — that's an inflection point. > This article was written using the tool itself — a fitting meta moment for software that's becoming genuinely useful for technical writing. The dense linking, structured sections, and lack of filler you'll notice? That's intentional. The tool helps, but the voice is still mine. If you notice I can seamlessly reference [GitHub's official changelog](https://github.blog/changelog/2026-01-14-github-copilot-cli-enhanced-agents-context-management-and-new-ways-to-install/), weave in stats about [agentic workflows](https://github.blog/ai-and-ml/github-copilot/power-agentic-workflows-in-your-terminal-with-github-copilot-cli/), and cross-link to my own articles on [context engineering](/articles/context-engineering-key-to-ai-development) without breaking flow — that's the tool working. > The most architecturally significant change across these releases is **alternate screen buffer mode**. If you're not a terminal nerd, here's what that means: traditional terminal apps scroll output linearly — everything pushes up, older content disappears. Alternate screen buffer mode gives the app a full-screen canvas it can control directly. Think `vim`, `less`, or `htop`. --- ## GitHub Copilot Boosts Developer Fulfillment by 60-75% **Published:** 2026-02-14 **Tags:** GitHub Copilot, AI-Assisted Development, Developer Experience, Opinion, Enterprise **URL:** https://htek.dev/articles/copilot-developer-fulfillment **Markdown:** https://htek.dev/articles/copilot-developer-fulfillment.md The most important Copilot metric isn't speed — it's that 60-75% of developers feel more fulfilled. Here's what the research actually says. ### Key Points > Everyone's obsessed with speed. "55% faster task completion!" "50% faster time-to-merge!" Every pitch deck about AI coding tools leads with how much faster your team will ship. But after digging into the actual research behind [GitHub Copilot's impact on developer productivity and happiness](https://github.blog/news-insights/research/research-quantifying-github-copilots-impact-on-developer-productivity-and-happiness/), I think the industry is burying the lede. > The most transformative finding isn't about velocity at all. It's that **60-75% of developers feel more fulfilled and less frustrated** when coding with AI assistance. 88% feel more productive — not measured, *perceived*. 73% say Copilot helps them stay in the flow. 87% say it preserves their mental effort during repetitive tasks. > Those aren't efficiency metrics. Those are *human* metrics. And I'd argue they matter more than any time-to-merge number ever will. --- ## Introducing vidpipe — My AI Video Editor That Does Everything **Published:** 2026-02-14 **Tags:** GitHub Copilot, AI Agents, Automation, Open Source, Case Study **URL:** https://htek.dev/articles/introducing-vidpipe-ai-video-pipeline **Markdown:** https://htek.dev/articles/introducing-vidpipe-ai-video-pipeline.md I built an agentic video pipeline that turns one recording into shorts, captions, social posts, and blog drafts — all autonomously. Now it's open source. ### Key Points > Every content creator faces the same problem: recording once means editing three times. You need a TikTok short (9:16, 60 seconds, karaoke captions), a LinkedIn version (16:9, burned subs), a blog post for SEO, and social posts for five platforms. Every asset needs scheduling, previewing, and tracking. > That was five weeks of my life last year — chopping silence, syncing captions, extracting highlights, writing posts. The content was valuable. The process was brutal. > So I automated it. I built an [agentic video pipeline](https://htekdev.github.io/vidpipe/) that takes one recording and outputs everything a creator needs. Then I used it for my own work. It processed [the video where I built it](/articles/video-pipeline-with-fleet-mode). --- ## Lessons from 500+ GitHub Migrations **Published:** 2026-02-14 **Tags:** GitHub Actions, Git, DevOps, Automation, Case Study, Enterprise **URL:** https://htek.dev/articles/lessons-from-500-github-migrations **Markdown:** https://htek.dev/articles/lessons-from-500-github-migrations.md Eight hard-won lessons from migrating 500+ repos to GitHub — and the open-source framework that cut migration time from hours to minutes. ### Key Points > After migrating 500+ repositories from Azure DevOps, Bitbucket, SVN, and other systems to GitHub, my team ran into pretty much every migration challenge imaginable. Large files that blocked pushes. Secret scanning that halted imports. SVN repos with decades of tangled history. Permission hierarchies that didn't map cleanly to GitHub's model. > Manual migrations were taking 4–8 hours each with a success rate hovering around 60%. That's not sustainable when you have hundreds of repos in the queue. So we built an automated, issue-driven framework on [GitHub Actions](https://docs.github.com/en/actions) and PowerShell that brought migration time down to 10–15 minutes and pushed success rates to roughly 95%. I [open-sourced the entire framework](https://github.com/htekdev/gh-repo-migration-iops-template) so other teams facing enterprise-scale migrations can skip the painful trial-and-error phase. > Here are the eight biggest challenges we solved — and what I'd tell any team about to start a large-scale migration. --- ## Stanford Study: AI's Real ROI in Software Engineering **Published:** 2026-02-14 **Tags:** GitHub Copilot, AI-Assisted Development, Developer Experience, Opinion, Enterprise **URL:** https://htek.dev/articles/stanford-study-ai-roi-in-engineering **Markdown:** https://htek.dev/articles/stanford-study-ai-roi-in-engineering.md A Stanford study of ~120K developers across 600+ companies reveals AI's median productivity gain is 10-15%, not 60%. Here's what the data actually shows. ### Key Points > The AI vendor pitch is seductive: "60% productivity gains for developers!" It's the kind of stat that gets budget approved and tools deployed overnight. But when [Yegor Denisov-Blanch](https://www.yegordb.com/research), a researcher at Stanford's Graduate School of Business, analyzed **~120,000 developers across 600+ companies** — tens of millions of commits and billions of lines of private code — the actual number landed with a thud. > **The median productivity lift from AI tools is 10–15%.** Not 60%. Not even close. > I shared this research [on LinkedIn](https://www.linkedin.com/posts/htekdev_can-you-prove-ai-roi-in-software-eng-stanford-activity-7426312068800323584-FvmM) after watching Denisov-Blanch's talk at the [AI Engineer Code Summit](https://www.youtube.com/watch?v=JvosMkuNxF8), and the reactions were split — some leaders deflated, others relieved to finally have honest data. Here's my breakdown of what the study actually found, what it means, and why the nuance matters more than the headline. --- ## 20 Minutes, Two Prompts, a Complete Video Pipeline **Published:** 2026-02-14 **Tags:** GitHub Copilot, Copilot CLI, AI Agents, Automation, Case Study **URL:** https://htek.dev/articles/video-pipeline-with-fleet-mode **Markdown:** https://htek.dev/articles/video-pipeline-with-fleet-mode.md How I used GitHub Copilot CLI's /fleet mode to build a 14-stage video processing pipeline in 20 minutes with just two prompts. ### Key Points > If you're watching the video I posted on [LinkedIn](https://www.linkedin.com/posts/htekdev_aiproductivity-softwaredevelopment-futureofwork-activity-7426611056929710080-OQIV), you're looking at proof. That video was transcribed, captioned, clipped into shorts, and turned into social posts by the very pipeline I built to do those things — a 14-stage video processing system scaffolded in 20 minutes with two prompts. The tool didn't just build the system. It processed its own creation story. > I've written before about [the shift from writing code to directing it](/articles/building-the-future-with-ai). This project made that shift visceral. I didn't write a single line of TypeScript. I described what I wanted, answered a few clarifying questions, and watched parallel agents assemble a production-quality pipeline while I sipped coffee. > The tool that made this possible is [GitHub Copilot CLI](https://docs.github.com/en/copilot/concepts/agents/about-copilot-cli) and its experimental `/fleet` command. --- ## VidPipe: I Built an Agentic Video Editor with GitHub Copilot CLI **Published:** 2026-02-14 **Tags:** GitHub Copilot, Copilot CLI, AI Agents, Automation, Case Study, Open Source **URL:** https://htek.dev/articles/vidpipe-copilot-cli-challenge **Markdown:** https://htek.dev/articles/vidpipe-copilot-cli-challenge.md Open-source AI video pipeline built with GitHub Copilot CLI. Drop a video, get shorts, captions, social posts, and a blog — automated end-to-end by AI agents. ### Key Points > *This is a submission for the [GitHub Copilot CLI Challenge](https://dev.to/challenges/github-2026-01-21)* > **VidPipe** is an open-source agentic video editor that automates the entire post-production workflow. You drop a video file, and a 15-stage AI pipeline transforms it into: > - **Short clips** (15–60s) with 6 variants per short (landscape, portrait, square, feed — all with burned captions) - **Medium clips** (1–3 min) with crossfade transitions - **Karaoke-style captions** (word-by-word highlighting, burned into video) - **AI silence removal** (context-aware, capped at 20%) - **Chapter detection** (JSON, Markdown, YouTube timestamps, FFmpeg metadata) - **Platform-tailored social posts** for TikTok, YouTube, Instagram, LinkedIn, and X - **Blog post** with web-sourced links - **Cost tracking** across all LLM providers --- ## Your God Prompt Is the New Monolith **Published:** 2026-02-14 **Tags:** AI Agents, Agentic Development, Context Engineering, Opinion **URL:** https://htek.dev/articles/your-god-prompt-is-the-new-monolith **Markdown:** https://htek.dev/articles/your-god-prompt-is-the-new-monolith.md The god prompt antipattern mirrors the monolithic backend failures we solved a decade ago. Here's how multi-agent patterns fix it. ### Key Points > Every few years, software engineering collectively forgets a hard-won lesson and rebuilds the same antipattern in a new medium. Right now, it's happening with AI prompts. > You know the setup. A team discovers the magic of a large language model. They wrap it in a script, give it access to the database, the API gateway, and the customer support logs. They dump everything into the context window because "1 million tokens" sounds like infinite storage. They call it an "Agent." Edward Burton calls this what it actually is: [building a God Agent](https://dev.to/ejb503/stop-building-god-agents-511e) — "fundamentally, structurally, catastrophically wrong." > I've watched this pattern play out at enterprise scale, and the failure arc is identical to the monolithic backends we spent a decade decomposing. Early success breeds overconfidence. The single prompt handles routing, reasoning, tool use, and formatting — beautifully, in demos. Then production hits. Context overflows. Personas bleed into each other. One hallucination corrupts the entire chain. Debugging becomes what I call "token archaeology" — sifting through 100k-context windows hoping to find where things went sideways. --- ## Building the Future with AI-Powered Development **Published:** 2026-02-13 **Tags:** GitHub Copilot, AI-Assisted Development, Developer Experience, Opinion **URL:** https://htek.dev/articles/building-the-future-with-ai **Markdown:** https://htek.dev/articles/building-the-future-with-ai.md How GitHub Copilot and AI-assisted tools are transforming the way we write software, and what it means for the next generation of developers. ### Key Points > Software development is undergoing a fundamental transformation. For decades, the craft centered on typing syntax—memorizing APIs, wrestling with boilerplate, and debugging typos. Today, the role of the developer is evolving from *writing* code to *directing* it. We describe intent, review suggestions, and shape architecture while AI handles the repetitive scaffolding. > This isn't about replacing developers. It's about elevating what we do. The most valuable skill is no longer how fast you can type a `for` loop—it's how clearly you can articulate what needs to be built and why. > I use GitHub Copilot every single day. It's not a novelty anymore; it's infrastructure. From generating unit tests to drafting documentation, Copilot has become the pair programmer that never gets tired and never judges your variable names. --- --- ## Work with Hector **Delivery Confidence Audit**: Get an AI-powered assessment of your team's delivery pipeline. [Learn more →](https://htek.dev/consulting) **Consulting**: Agentic development and DevOps consulting for engineering teams adopting AI coding agents. [Get in touch →](https://htek.dev/consulting) **Newsletter**: Weekly insights on agentic development, GitHub Copilot, and context engineering. [Subscribe →](https://htek.dev/newsletter) **Blueprints**: Step-by-step implementation guides for building governed agent systems. [Browse blueprints →](https://htek.dev/blueprints)