From Writing Code to Designing Systems: How the Developer Role is Changing — Chris Noring, Microsoft

This talk introduces a paradigm shift in software development, moving developers from pure code producers to system designers and agent orchestrators. It details a new workflow leveraging GitHub Copilot CLI, custom Copilot agents, and explicit guardrails like `agents.md` and skills. The focus is on how to decompose complex problems, delegate implementation to AI, and encode architectural standards and constraints directly, enabling higher consistency, quality, and accelerated delivery through a "human-in-the-loop" delegation model.

July 11, 2026 5 min read

From Writing Code to Designing Systems: How the Developer Role is Changing — Chris Noring, Microsoft — source: https://www.youtube.com/watch?v=GdvKNwMcfd0

The presentation, “From Writing Code to Designing Systems,” asserts that the traditional developer role, focused on maximizing code output and speed, no longer scales in an AI-first era. Instead, the bottleneck has shifted from syntax and implementation to “clarity of intent, architectural thinking, and the ability to coordinate work across many autonomous contributors.” The challenge now is not just how to write code, but how to ensure a system is built correctly, consistently, and to company standards across numerous moving parts, avoiding fragmentation, inconsistent patterns, and duplicated logic.

The speaker, Chris Noring from Microsoft, introduces a new mental model: the developer as a planner, system designer, and orchestrator of agents. This transformation means developers spend less time on rote coding and more on high-level design and guidance.

A New AI-Driven Development Workflow

A significant shift in the daily workflow is proposed:

CLI-First Approach: The command-line interface (CLI), particularly tools like GitHub Copilot CLI, becomes the primary entry point. Developers can manage GitHub issues, pull requests, and status checks, and even generate initial drafts (MVPs) directly from the terminal without opening an editor. The idea is to quickly prompt for features or fixes.
Editor as Control Board: While the editor remains valuable for fine adjustments and provides a familiar “control board,” less time is spent writing code from scratch. It’s where developers still feel most “in control” for detailed work.
Scaling via CLI and GitHub UI: The core of scaling involves delegating tasks to AI agents. This can happen from the CLI (using commands like /delegate) or directly from the GitHub user interface by assigning issues to agents.

Essential Guardrails for Agent Orchestration

To prevent agents from “running amok” and ensure quality, “guardrails” are paramount. These mechanisms constrain AI agents and encode specific instructions:

agents.md: This is positioned as the “absolute bare minimum” guardrail. Located at the root of a repository, it provides high-level guidance, including repository intent, application architecture, constraints, and “dos and don’ts.” It defines what agents should not do (e.g., “never change the architecture unless told”) and outlines project specifics (e.g., “a finance app using React and Tailwind”).
Skills: For repeatable tasks that require strict adherence to a specific process, “skills” act as a contract for agents. A skill provides a “recipe” that an agent must follow without improvisation, mitigating risk and preventing creative deviations. Skills are self-contained, live in dedicated folders (e.g., .github/skills for Copilot or .claude/skills for Claude), and are defined by a skill.md file with a name, description, and detailed markdown instructions. Skills can be invoked via a /skills command or by a prompt resembling their name/description.
Custom Agents: When a skill’s limitations are reached (e.g., inability to orchestrate with others), custom agents offer the “next level.” An agent has a distinct persona (e.g., “security expert,” “backend developer”), can utilize multiple skills, and possesses the ability to reason and plan. Unlike skills, custom agents are more “orchestrators” with broader scope and higher autonomy. They are defined by an .agent file (e.g., .github/agents/researcher.agent) containing argument hints, instructions, and crucially, tools that explicitly constrain their capabilities (e.g., “read,” “search the web,” “create to-do lists”). An example is a “researcher” agent constrained to web searching, demonstrating how tools define what an agent can or cannot do.

Delegation and Human-in-the-Loop Scaling

The ultimate goal is to scale developer productivity through delegation. Developers can prompt agents (e.g., “Build me an app,” “Add new feature,” “Fix issue”) and then use the /delegate command in the CLI or assign issues to agents in the GitHub UI.

Crucially, agents operate in sandboxes and are designed with a “human in the loop” approach. When an agent completes a task, it typically creates a draft Pull Request (PR), allowing human developers to review, approve, and merge the changes. This ensures quality control and that the final output aligns with architectural and security standards.

The speaker likens this shift to moving from cutting trees with an axe to using a chainsaw – a massive leap in efficiency. The message is clear: AI is not about replacing developers but about scaling them, turning each into a 10x, 20x, or even 100x contributor by leveraging AI to handle implementation details while humans focus on deliberate design and oversight. The “engineering brain” remains essential for setting up the system and its guardrails.