Browse All Blogs (88)

Rick Strahl walks through an edge-case but practical .NET Framework/WPF tool that packages a static documentation website into a single Windows EXE, then unpacks and renders it offline using WebView2. He covers the packaging approach, ILRepack-based single-file builds, embedding native dependencies, and the SmartScreen/code-signing trade-offs.

Thomas Maurer explains how LAPS for Azure Arc extends Windows LAPS so teams can centrally audit and enforce local admin password rotation across Azure VMs and Arc-enabled servers, with Azure Policy-based compliance reporting that works in hybrid and regulated environments.

John Edward outlines practical ALM and environment strategy guidance for Microsoft Copilot Studio, focusing on how to run copilots like enterprise applications with multi-environment setups, solution-based development, source control, CI/CD pipelines, configuration management, governance, and ongoing monitoring.

Hidde de Smet compares the GitHub Copilot App and the VS Code Agents Window, focusing on how each surface supports agent-first workflows: isolated sessions, worktrees, review/CI loops, and customization via MCP and instruction files. It includes a practical “which one should you use?” decision guide for day-to-day development vs delegated work.

DevClass rounds up Microsoft Build announcements that matter to developers, including new Windows sandboxing for AI agents (MXC), an Arm-based Surface RTX Spark Dev Box, GitHub Enterprise Local for connected or air-gapped environments, Azure Linux updates, and Microsoft-maintained Coreutils for Windows.

John Edward explains how to design multi-agent architectures in Microsoft Copilot Studio, using an orchestrator copilot plus specialized agents (IT, HR, sales, analytics). The article covers communication options (Power Automate, Dataverse, REST APIs), governance and security considerations, and practical scaling guidance like monitoring, shared knowledge sources, and independent versioning.

DevClass reports on .NET Aspire 13.4, highlighting the general availability of the TypeScript AppHost and new integrations that broaden Aspire beyond C#-only workflows. The piece also covers deployment targets (including Azure and Kubernetes), the Aspire dashboard’s OpenTelemetry-based observability, and notable Kubernetes-related improvements.

John Edward walks through creating a first AI agent in Microsoft Copilot Studio, from defining the agent and connecting knowledge sources to enabling generative answers, testing conversations, and publishing to channels like Teams and websites.

Rick Strahl explains why ASP.NET Core cookie-auth logins can “disappear” after IIS app pool recycles: the Data Protection key ring isn’t persisting, so previously issued auth cookies can’t be decrypted/validated. He shows how to fix it by enabling Load User Profile or by explicitly persisting keys to a known location.

John Edward explains where Microsoft Copilot Studio sits in the Power Platform, and how it connects conversational AI to apps, workflows, data, and analytics through tools like Power Apps, Power Automate, Dataverse, and Power BI.

Jesse Houwing shows how to automate GitHub Copilot AI Credits budgeting by assigning per-user budgets based on Microsoft Entra ID group membership, using a GitHub Actions workflow and a PowerShell script that calls the GitHub enterprise billing API via the GitHub CLI.

Hidde de Smet lays out a practical KPI scorecard for teams adopting AI coding agents under usage-based billing, using GitHub Copilot’s AI Credits model as the concrete example. It focuses on measuring speed, quality, reliability, and spend together, with a rollout plan and data sources you can wire into a weekly dashboard.

Randy Pagels explains how to reduce repeated prompting by capturing team conventions in a copilot-instructions.md file so GitHub Copilot can generate code that matches your repo’s standards, architecture expectations, and preferred testing and design patterns.

DevClass reports on a multi-hour GitHub Actions outage that surfaced an incorrect “Your account is suspended” error, why Actions downtime can block CI/CD even when developers can still code locally, and what GitHub’s incident updates said about authentication issues and follow-on data cleanup.

John Edward explains how Declarative Agents and Autonomous Agents differ in Microsoft Copilot Studio, focusing on how each approach handles control, decision-making, and multi-step work. The article maps the trade-offs (predictability vs flexibility), gives practical use cases for each agent type, and offers guidance on choosing the right model for a given workflow.

John Edward explains how Microsoft Copilot Studio structures conversational agents using topics (intent-focused conversation pathways) and nodes (step-by-step actions inside a topic). The article breaks down common node types, shows how topics and nodes fit together in real flows, and shares practical design tips for building maintainable copilots.

Rick Strahl explains how to host an ASP.NET Core app under a virtual subfolder (like /blog) using PathBase, and what you need to change in your app and IIS configuration so routing, static files, and generated URLs keep working.

Jesse Houwing breaks down why common “AI ROI” dashboards (tokens, PR counts, lines of code) don’t actually measure value, and how they can backfire through metric gaming and biased attribution. He proposes outcome-based measurement and post-build validation practices that better reflect real impact.

John Edward outlines common enterprise AI agent architecture patterns you can implement with Microsoft Copilot Studio, including single-agent designs, multi-agent orchestration, RAG, human-in-the-loop workflows, and event-driven automation, with notes on integrations, governance, and compliance considerations.

John Edward outlines practical Microsoft Copilot Studio scenarios teams are using to cut repetitive work, including customer support, HR onboarding, IT help desk triage, internal knowledge search, sales lead qualification, and meeting follow-ups across common Microsoft 365-connected workflows.

DevClass reports on GitHub’s investigation into a poisoned VS Code extension that led to exfiltration of internal repositories, and the downstream risks for credentials, private code exposure, and follow-on access if stolen secrets were present.

DevClass reports on a Shai-Hulud supply-chain attack where a compromised npm account published malware into 314 packages, then hid reports by closing GitHub issues. The piece summarizes the payload’s credential-stealing behavior and practical cleanup steps like rotating secrets and checking for unauthorized repos and services.

Hidde de Smet compares GitHub’s Spec-Kit and Fission AI’s OpenSpec for spec-driven development, focusing on how each tool structures specs, guides agent workflows, and fits greenfield vs brownfield work.

DevClass reports on TanStack’s incident follow-up after a supply-chain attack that abused a GitHub Actions workflow to run untrusted code and poison shared caches, and on the project’s proposed hardening steps—including potentially moving to invitation-only pull requests.

Thomas Maurer shares a conversation with Geoff Ross (Cireson) on using Tikit to bring IT service management practices to Azure operations, with a focus on self-service deployments, standardized service delivery, and governance baked into approval workflows.

Andrew Lock explains the new union types feature in .NET 11 (C# 15), including the `union` keyword syntax, how exhaustive `switch` expressions work, and what the compiler generates behind the scenes. He also shows how to build custom union implementations to avoid boxing in performance-sensitive scenarios.

Emanuele Bartolesi shares a quick fix for the Windows error “Your organization has deleted this device” (error code 700003) on Microsoft Entra-joined devices, avoiding a full disconnect/reconnect of the work account.

Harald Binkle demonstrates a practical BMAD workflow using GitHub Copilot to turn fuzzy requirements into reviewable artifacts: a PRD, project context, epics/stories, architecture decisions, risk-based test design, and traceability. The example focuses on enterprise authentication concerns like MFA, tenant isolation, RBAC, and auditability.

Hidde de Smet breaks down what AI coding agents actually cost once GitHub Copilot switches to usage-based billing, including how credits map to tokens, why model choice changes your bill, and how to budget for agent-heavy teams without surprising finance.

Rob Bos argues that as GitHub Copilot shifts to usage-based billing, teams should stop fixating on token costs in isolation and instead measure what they get back: foundation work, reduced tech debt, and faster MVP delivery. He shares real usage patterns, cost concentration among heavy users, and practical steps to manage spend without throttling engineers.

DevClass reports on Microsoft’s claimed WinUI 3 performance improvements, including a 25% speed-up in File Explorer areas built with WinUI and reductions in memory allocations and function calls, alongside developer concerns about WinUI 3 responsiveness versus WPF and UWP.

Rob Bos introduces the GitHub Copilot App technical preview and shares a practical first look at using it for repository maintenance, including parallel agent sessions, session modes (Interactive/Plan/Autopilot), and the Agent Merge workflow for handling CI failures, merge conflicts, and security-related alerts.

John Edward explains how GitHub Copilot changes team workflows around pull requests, code review expectations, and knowledge sharing. The article focuses on the trade-offs of faster AI-assisted coding, why review discipline matters more, and how teams can add guardrails like testing and security scanning without losing collaboration.

Rick Strahl shows where to read the client IP address in ASP.NET Core, and how to handle reverse proxies by parsing common forwarding headers or enabling the built-in Forwarded Headers Middleware.

Andrew Lock walks through the new .NET 11 `webworker` project template for Blazor WebAssembly, showing how to move CPU-heavy work off the UI thread and how the generated .NET and JavaScript glue code communicates with a browser Web Worker.

Jesse Houwing breaks down why GitHub Copilot is moving from Premium Request Units to token-based, usage-based billing, and what that means for model selection, cost predictability, and newer features like Agent Mode, Cloud Coding Agent, and Copilot Code Review—especially for organizations managing budgets and policies.

John Edward outlines an architecture for a “Daily Stand-Up Agent”: a custom AI copilot that pulls sprint activity from Jira and Azure DevOps, detects blockers, and generates consistent stand-up summaries. The post focuses on connectors, grounding ticket data, conversational reporting, and practical considerations like security and data quality.

Rob Bos shares a real-world GitHub Copilot CLI mishap where an unintended Copilot CLI extension caused repeated prompts to close GitHub deployment-status notifications, and explains how he tracked down the source and removed it.

DevClass reports on the Zed editor reaching version 1.0, covering its Rust-based architecture, GPU-accelerated UI, built-in language server support, and the editor’s growing set of AI features (including agents) alongside an option to disable AI entirely.

John Edward explains how Architecture Decision Records (ADRs) capture the “why” behind technical choices, and how AI tools can generate consistent ADR drafts quickly so teams can focus on review, accuracy, and long-term knowledge sharing.