Microsoft's Noring Replaces IDE Coding With Multi-Agent CLI Systems

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

AI Engineer

Engineers must shift from manual syntax production to orchestrating background agents behind strict repository guardrails, or risk drowning codebases in unmaintainable AI slop.

AI-assisted summary of From Writing Code to Designing Systems: How the Developer Role is Changing — Chris Noring, Microsoft — original source. Check the original for full context.

Source published:

Key ideas

  • The developer bottleneck has transitioned from keyboard code production to strategic oversight, systems design, and guardrail creation to prevent generative AI tools from creating unconstrained slop. (0:00)
  • Developers are shifting from text editors to the command-line interface as their primary starting point, running parallel terminal sessions to generate MVPs, triage issues, and run agents. (3:15)
  • Repositories require strict constraints via agents.md files, repeatable skill contracts, and scoped custom agents to bound autonomous AI behavior. (6:47)
  • Background delegation through the /delegate CLI command or GitHub issue assignments allows agents to run in sandboxes and produce draft pull requests for human review. (15:00)

Detailed notes

## Background Published by the AI Engineer channel on YouTube on July 11, 2026, this talk features Microsoft's Chris Noring examining how the developer role is fundamentally shifting from manual code production to systems architecture, planning, and agent orchestration. The presentation outlines practical patterns for structuring projects with GitHub Copilot CLI, Copilot Chat, and repository-level 'agents.md' files to ensure architectural consistency and prevent AI-generated fragmentation at scale.

## TL;DR Chris Noring proposes a modernized three-phase developer workflow where the command line serves as the initial staging ground for MVPs, the code editor transforms into an overarching mission control board, and tasks are scaled across autonomous agents. To prevent unguided generative tools from producing architectural 'slop,' he demonstrates how to enforce strict guardrails using baseline `agents.md` repository contracts, deterministic step-by-step skills, and scoped custom agents. Developers can delegate complex jobs asynchronously via the CLI or GitHub issue assignments, leaving agents to run isolated tasks that always culminate in draft pull requests governed by human review.

## Atmosphere & style Speaking to a packed, at-capacity conference hall, Noring brings an upbeat, pragmatic, and collaborative energy that immediately unites users across both GitHub Copilot and Claude ecosystems. His delivery blends relatable engineering humor—comparing unpredictable agent outputs to the behavior of toddlers and framing modern tooling as trading hand axes for chainsaws—with grounded, screen-based demonstrations. The overall feel is deeply reassuring and empowering, transforming anxieties about developer obsolescence into practical excitement for amplified leverage and system-level stewardship.

## Bulletin - [00:00](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=0s) The developer bottleneck has transitioned from keyboard code production to strategic oversight, systems design, and guardrail creation to prevent generative AI tools from creating unconstrained slop. - [03:15](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=195s) Developers are shifting from text editors to the command-line interface as their primary starting point, running parallel terminal sessions to generate MVPs, triage issues, and run agents. - [06:47](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=407s) Repositories require strict constraints via agents.md files, repeatable skill contracts, and scoped custom agents to bound autonomous AI behavior. - [15:00](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=900s) Background delegation through the /delegate CLI command or GitHub issue assignments allows agents to run in sandboxes and produce draft pull requests for human review.

## Key takeaways - [00:00](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=0s) Progress in traditional software development was linear and bottlenecked entirely by individual human typing speed and keyboard capacity. - [00:00](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=0s) Without architectural guardrails, generative AI spews low-quality code that creates more rework and maintenance burden than it saves. - [03:15](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=195s) The CLI is replacing the IDE as the primary entry point for software tasks, serving as the staging ground for MVPs, pull request triaging, and issue management. - [03:15](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=195s) Engineering teams deliver working prototypes and functional demos directly to stakeholders rather than relying on abstract slide decks. - [05:22](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=322s) The code editor evolves from a manual input canvas into a mission control board for monitoring telemetry and concurrent agent outputs. - [06:47](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=407s) Placing an agents.md file in repositories acts as a baseline contract outlining stack specifications, architectural constraints, and operational boundaries. - [06:47](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=407s) Existing codebases can be refactored into architectural compliance by adding an agents.md file and instructing agents to align code against its rules. - [10:00](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=600s) Skills function as deterministic, repeatable recipes constrained within strict Markdown contracts so agents execute processes without creative improvisation. - [10:00](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=600s) Major industry platforms, including GitHub Copilot and Anthropic Claude, have converged on similar directory structures and front matter conventions for defining skills. - [13:00](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=780s) Custom agents operate at a higher architectural tier than individual skills, incorporating explicit personas, reasoning capabilities, and MCP tool access. - [13:00](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=780s) Restricting an agent's available tools, such as granting search access while denying file editing rights, prevents unintended repository modifications. - [15:00](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=900s) The /delegate CLI command sends development tasks to an isolated GitHub sandbox to execute tools and generate draft pull requests. - [20:00](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=1200s) Assigning GitHub issues directly to agents triggers asynchronous background work that developers can inspect through work-in-progress status indicators. - [20:00](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=1200s) Autonomous agent workflows mandate explicit human-in-the-loop approval gates where generated draft PRs are reviewed before merging. - [20:45](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=1245s) AI agent systems act like moving from an axe to a chainsaw, dramatically multiplying developer leverage rather than replacing the human engineer. - [21:28](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=1288s) Achieving 20x developer output requires strict harnesses and agent definitions to ensure high execution velocity does not degrade into 20x more architectural slop.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=0s) The Shift from Writing Code to Systems Architecture

Opening the session slightly ahead of schedule due to a packed, at-capacity room, Chris Noring introduces his day job in AI engineering at Microsoft and asks the audience for a quick show of hands on who is still writing code the traditional way. Observing only a tiny scattering of hands, he notes that most engineers in attendance have already begun pivoting toward a higher-level systems approach. When polling the room on their tool of choice—asking who uses Anthropic's Claude versus GitHub Copilot—he finds the audience roughly split down the middle, perhaps leaning slightly toward Claude. Noring warmly welcomes both camps, highlighting that Microsoft and Anthropic are close partners who frequently co-present at industry conferences.

He reflects on how the core software engineering dynamic has fundamentally transformed over the past few years. In the traditional paradigm, progress was strictly linear: individual developers wrote 100% of the code on their keyboards, meaning that human capacity was the sole bottleneck deciding whether a feature was built or abandoned. While developers retain their jobs, the center of gravity has shifted from raw code production to strategic oversight. Engineers still cherish writing code, but they have learned to become exceptionally protective of their time. Early experiences with unfiltered "AI slop"—where generative tools spewed poorly structured code that required exhausting rewrites—taught teams that unconstrained AI generates more work than it saves. Consequently, establishing guardrails has become the defining challenge for developers choosing between platforms like Claude Code, Claude Desktop, the GitHub Copilot CLI, or IDE extensions.

> “You know that your world has changed. You know that in the old days, 100% on keyboard, and you might still be on the keyboard. You just do different things with your own time. But we all knew that we were the limitation, right? We were brilliant engineers. We did 100% of the code, but linear progress, it was just you trying to advance things.” — Chris Noring

---

[03:15](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=195s) A New Mental Model: The CLI as the First Entry Point

To address this evolving paradigm, Noring proposes a three-stage developer workflow centered on shifting away from opening an editor right away. For roughly nineteen and a half of his twenty years in the industry, text editors and IDEs served as his unquestioned home and starting point. However, he now advocates starting projects and day-to-day tasks directly inside a command-line interface (CLI). Rather than being the exclusive domain of shell scripting, Bash, or PowerShell specialists, the CLI has emerged as an ideal staging ground for drafting MVPs, managing GitHub issues, triaging pull requests, and initiating checks without the overhead of spinning up VS Code.

```mermaid flowchart LR accTitle: Three-Stage Developer Workflow accDescr: Flowchart illustrating the transition from CLI drafting to editor oversight and scaling via agent orchestration.

subgraph Entry ["1. Entry Point"] CLI["CLI Tooling\n(Copilot CLI / Claude Code)"] end

subgraph Refine ["2. Control & Guardrails"] IDE["Text Editor / IDE\n(Control Board & Agent Config)"] end

subgraph Scale ["3. Scale & Orchestration"] Agents["Agentic Scale\n(CLI & GitHub UI)"] end

CLI -->|"Draft MVP & manage issues"| IDE IDE -->|"Set guardrails & run agents"| Agents ```

Noring emphasizes that this shift accelerates business turnaround times. Business stakeholders no longer expect engineers to present abstract PowerPoint decks; instead, developers bring back working prototypes and functional demos in fraction of the time. Once the initial draft is conceived in the terminal, the workflow transitions to the editor for structuring, before expanding into the third phase: scaling the workload across autonomous agents through both the CLI and GitHub user interfaces.

> “What my engineers are no longer bringing me PowerPoints, they're bringing me working demos.” — Chris Noring

- **Phase 1 (CLI Entry):** Rapid creation of first drafts, basic MVP generation, triage of GitHub issues, and PR management without launching an IDE. - **Phase 2 (Editor Staging):** Applying architectural guardrails, configuring custom agents, and retaining fine-grained human oversight. - **Phase 3 (Scale):** Delegating tasks across multiple autonomous agents through terminal streams and GitHub UI automation.

---

[05:22](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=322s) Parallel Terminals and the Editor as a Mission Control Board

Describing his day-to-day work environment, Noring illustrates a setup dominated by multiple open terminal windows executing parallel agentic workflows. Instead of writing boilerplate in languages like Java, JavaScript, or Python, modern developer interaction revolves around targeted natural language prompts: "build me an app," "add this new feature," or "fix this issue." Developers can trigger separate autonomous tasks across concurrent terminal sessions and monitor them in the background while sipping coffee or tea.

Despite spending less hands-on time manually writing syntax, Noring insists that the code editor remains essential. Rather than serving as an input canvas where an engineer types line-by-line, the editor evolves into an overarching "control board" or mission control dashboard. Because modern developer tools stream inputs and outputs across CLIs, local editors, and remote GitHub repositories, the IDE acts as the central vantage point where developers maintain situational awareness, monitor agent output, and enforce project integrity.

> “It doesn't make sense anymore for us if we've got 15, 20 agents that do our bidding, that we sit there and, you know, trying to figure out what code to write.” — Chris Noring

- **Prompt-Driven Parallelism:** Managing multiple terminal panes simultaneously targeting bug fixes, feature extensions, and MVP spikes. - **The IDE as Control Board:** Repurposing VS Code or text editors from manual code-generation boxes into telemetry dashboards that ingest streams from GitHub repositories, local agents, and CLI sessions.

---

[06:47](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=407s) Enforcing Architectural Boundaries with `agents.md`

To protect against the chaos of unguided agents generating "AI slop," Noring stresses the absolute necessity of repository-level constraints. Without strict rules, agents will drift off course, hallucinate patterns, or rewrite established architectures without permission. He introduces `agents.md` as the bare minimum guardrail that must be placed in every software repository. This document acts as the high-level contract defining project intent, technology stack specifications (such as React and Tailwind CSS for a finance application), architectural constraints, and explicit lists of do's and don'ts—such as forbidding agents from altering project architecture unless explicitly instructed.

Noring walks through an example repository featuring a "vibe-coded" finance tracker equipped with an extensive `agents.md` file. The document outlines distinct project overviews and delineates agent boundaries. He demonstrates that a developer can query the environment directly about the agent file's contents, or copy an existing `agents.md` into a legacy code base, prompting the agent to refactor and align existing components to match those codified guidelines. While `agents.md` establishes fundamental rules of engagement, Noring notes that agents still struggle with execution accuracy, naturally pointing toward the need for dedicated agent skills.

> “Guardrail number one. This is the absolute bare minimum, right? Agents MD. You should have this in all your GitHub repos or whatever kind of repo structure you have. This is your high level guidance explaining repository intent, application architecture constraints, the do's and don'ts, right?” — Chris Noring

- **Core Contents of `agents.md`:** Repository intent, architectural constraints, approved component libraries and styling systems, and explicit operational rules (e.g., prohibition of spontaneous architectural redesigns). - **Adoption Strategy:** Dropping a battle-tested `agents.md` into legacy or fresh codebases to instruct AI tools to refactor existing code into compliance. - **Next-Level Precision:** Overcoming near-miss agent implementations by layering specialized skills on top of global markdown instructions.

[10:00](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=600s) Constraining Agents with Skills

Chris Noring emphasizes that when dealing with autonomous agents, the goal is not to unleash unconstrained improvisation, but to enforce strict guardrails. He jokes about not singing for the audience, then dives straight into the concept of a skill: it is essentially a repeatable recipe that the agent must invoke consistently every single time, without making things up. Because developers are in the business of mitigating risk, agents must be kept inside a tight harness.

> “So the idea with the skill is to give it a recipe, something that’s repeatable and you want the agent to use this one each time. Do not make things up. We want to constrain the agents as much as humanly possible.”

Noring points out that skills are self-contained, live inside dedicated folders, and act as rigid contracts for repetitive tasks that must happen in a specific order:

> “We know that the agent should have a harness around it and say, don’t do things that I don’t want you to do. Don’t be creative. Don’t do anything. Right?”

Whether using GitHub Copilot or Anthropic's Claude—which Noring notes makes up roughly half the room—the structural pattern remains widely aligned across major tech vendors. In Claude setups, developers typically place folders under `.claude/skills/`, where each skill folder contains a `skill.md` file featuring front matter (`name` and `description`) alongside extended Markdown instructions outlining the exact execution steps. Noring appreciates this cross-industry consensus because developers do not always get to choose the vendor forced upon them. In VS Code or IntelliJ, authoring these instructions can even be outsourced right back to the assistant:

> “And one of my favorite things to do, because I’m really bad at writing these instructions, is simply to ask Copilot, how do you write a better instruction for what I aim to do?”

To trigger skills, developers can either explicitly invoke `/skills` in the interface to configure them, or supply a prompt that closely matches the skill's declared name or description.

[13:00](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=780s) Custom Agents vs. Skills

While a skill is great for deterministic, repeatable workflows, it has strict limits. It cannot orchestrate itself across broader system boundaries or reason through high-level goals. That is where GitHub Copilot custom agents come into play.

```mermaid flowchart TD accTitle: Skill vs Custom Agent Architecture accDescr: Diagram showing how a custom agent with tools, persona, and reasoning orchestrates multiple skills and MCP servers. subgraph AgentScope["Custom Agent (High Autonomy & Orchestration)"] Persona["Persona & Role<br/>(e.g., Security, Backend, Researcher)"] Tools["Tool Declarations<br/>(Read, Search Web, Todo Lists)"] MCP["MCP Servers<br/>(External Integrations)"] Reasoning["Planning & Reasoning Engine"] end

subgraph SkillsExecution["Deterministic Execution"] Skill1["Skill: Recipe A<br/>(Strict Markdown Contract)"] Skill2["Skill: Recipe B<br/>(Repeatable Steps)"] end

Persona --> Reasoning Tools --> Reasoning MCP --> Reasoning Reasoning --> Skill1 Reasoning --> Skill2 ```

> “So what I’m saying is that a skill is limited in what it can do. It can’t really orchestrate itself with others. That’s when you need an agent, right? You need something that’s able to... reason.”

A custom agent operates at a distinctly higher tier than an individual skill: - **Role and persona:** It possesses a distinct identity and scope, such as a specialized security expert, backend architect, frontend engineer, or dedicated web researcher. - **Skill execution:** An individual custom agent can consume and trigger *n* number of skills. - **MCP server integration:** It can plug directly into Model Context Protocol (MCP) servers. - **Planning and autonomy:** Unlike isolated skills, agents carry out multi-step planning, maintain broad situational scope, and coordinate with other agents.

Noring walks through the filesystem conventions in a demo. Custom agents live by default under `.github/agents/`, recognized by the `.agent` naming convention. In the front matter, where a skill would simply declare a name and description, a custom agent defines configuration options like `argument-hints` and explicit `tools`.

> “Tools is an important concept because that’s able to constrain the agent what it can do or not, right? So in this case the agent can read, it can search the web, it can create to-do lists and much more.”

Demonstrating a "researcher" custom agent, Noring illustrates how tool access can intentionally be scoped down. Because this persona is built strictly to gather information—such as looking up details on the Microsoft Agent Framework—it is granted web searching capabilities while being barred from editing or generating local repository files.

[15:00](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=900s) Scaling Development and Delegating to Background Agents

Transitioning to the third chapter of his talk, Noring shifts from local command-line tasks toward massive organizational scale. He jokes about how developers perceive agent behavior:

> “I have heard people refer to them as toddlers. I don’t know if you’ve heard the same. But the idea with agents is that sometimes we think they’re super smart and sometimes they’re just plain dumb. They literally go between genius and ‘Oh my God, I can’t believe you did this.’”

That wild variance between brilliance and catastrophic blunders is precisely why human-imposed harnesses, `AGENTS.md` rules, and custom instructions are mandatory. Once those guardrails are secured, individual developers can achieve extreme leverage, evolving into 10x, 20x, or 100x developers through parallel delegation across two main modalities:

```mermaid flowchart LR accTitle: Agent Delegation Modalities accDescr: Diagram illustrating the two workflows for delegating work to agents via the CLI or GitHub Web UI into a draft PR. subgraph Trigger["Delegation Triggers"] CLI["CLI Command:<br/>/delegate [prompt]"] WebUI["GitHub Issue UI:<br/>Assign issue to Agent"] end

subgraph Platform["GitHub Sandbox & Execution"] GH["GitHub Backend Job"] ToolsRun["MCP Tools Running<br/>(Playwright, GitHub MCP)"] end

subgraph Review["Human-in-the-Loop"] PR["Draft Pull Request (PR)"] Human["Human Reviewer"] end

CLI --> GH WebUI --> GH GH --> ToolsRun ToolsRun --> PR PR --> Human ```

1. **The CLI Modality (`/delegate`):** From a terminal session inside an active Git repository, a developer can run `/delegate` followed by a request, such as asking it to build a finance tracking app using HTML, CSS, and JavaScript. The CLI will refuse to run if the project is not a valid GitHub repository. Once validated, it hands off the session to GitHub, launching a background job in an isolated sandbox. The agent uses external tooling (like Playwright and GitHub MCP servers) and eventually yields a draft pull request. The human remains firmly in the loop to review the output without having given the agent uncontained access to production environments.

2. **The GitHub Web UI Modality (Issue Assignment):** Developers working inside the GitHub web interface can open an issue (for example, "add dark mode to my app"), write a title and description, and set the assignee field directly to the agent.

> “So essentially, if I’m in the user interface for a repo, I can just say, oh, here’s a bunch of issues. Each of these issues are a next feature or a bug fix or whatever. Delegate, delegate, delegate, delegate, and I go have a coffee, right?”

[20:00](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=1200s) Delegating to Background Agents and the Power of Human-in-the-Loop

Chris Noring demonstrates assigning an issue directly to an agent within GitHub. After creating the issue, he clicks to assign the agent, noting that developers can provide additional custom instructions right at that moment if needed. Once assigned, GitHub Copilot picks up the task, marked by an icon signaling that it has been summoned. The agent works asynchronously on the task, surfacing its status as an active work in progress (WIP) that the developer can click into and inspect at any point.

The critical architectural step in this workflow is the draft pull request produced at the end of the run. Rather than merging changes automatically, the agent surfaces a draft PR for review, explicitly prompting: “hey, Chris, what do you think of this? Is this something we can ship?” Because this entire cycle executes entirely in the background, developers are free to context-switch to other high-value engineering challenges without stalling their velocity.

```mermaid flowchart LR accTitle: Issue Delegation to Pull Request Flow accDescr: Flow diagram showing how a GitHub issue is assigned to an agent, executed in the background, and returned as a draft PR with human approval gates. subgraph GitHubWorkflow["GitHub Task Workflow"] A["Create Issue & Assign Agent"] --> B["Agent Starts VIP / WIP Task"] B --> C["Background Execution"] C --> D["Draft PR Generated"] end subgraph HumanReview["Human-in-the-Loop"] D --> E{"Developer Reviews & Merges"} end ```

- Developers retain full visibility into running background tasks via the work-in-progress status interface. - Agents act autonomously during generation but always terminate at an explicit approval gate before code reaches production branches.

[20:45](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=1245s) The Chainsaw Analogy: Scaling Developer Leverage Without Replacement

Reflecting on how software engineering is evolving, Noring frames agentic workflows as an evolution of tool leverage rather than an existential threat to developers. He draws an analogy to historical shifts in labor: “I usually compare this whole age, the strange age we live in to people who used to cut down trees with axes. I see we are now at the point where we're throwing the axis, we're using a chainsaw instead because we are so much faster.” Developers have always adapted to faster, sharper tools, and this shift represents the natural progression of building systems with higher leverage.

Retaining the human in the loop is essential because engineers are the ones designing the operational guardrails. Noring emphasizes, “We are still important because we have built the system, right? We have built the system that instructs the agents to run amok within our harness.” By controlling the instruction harness and establishing mandatory approval gates, the human engineer maintains ultimate authority over what gets approved and merged into the codebase.

[21:28](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=1288s) Guardrails Over Slop: Becoming 20x Developers with agents.md

Summarizing his guidance, Noring urges developers to step outside conventional code editors and embrace multi-terminal setups using the GitHub Copilot CLI and the GitHub UI. While the code editor remains valuable for fine adjustments and targeted polishing, spinning up six or more concurrent CLI terminals allows engineers to build, scaffold, and iterate on projects at unprecedented scale, whether in solo side projects or large enterprise settings.

However, raw speed introduces severe architectural risks if left unconstrained. As Noring warns, “Providing, of course, we provided the right guardrails, right? Because 20 times more code, that could be 20 times more slop, and we don't want that.” To prevent flooding repositories with low-quality code, engineers must institute strict constraints using agent specifications like `agents.md`, defining specialized skills and custom agents to encode architectural intent. Concluding his talk, Noring reassures the audience that these tools exist solely to amplify human judgment: “And all about this is about scaling you now that we have AI, not replacing you. So hopefully I'm landing you with a good message to say, we want the engineering brain. So please stay in this industry, right?”

- The Copilot CLI allows developers to scale their productivity roughly 20x by coordinating tasks across multiple active terminal sessions simultaneously. - Traditional code editors shift from being the primary environment for raw code production to a secondary tool reserved for high-precision edits and fine adjustments. - Frameworks like `agents.md`, custom skills, and tailored agents establish the guardrails necessary to convert rapid generation into clean, maintainable software rather than architectural slop.

## Notable quotes > [21:28](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=1288s) 20 times more code, that could be 20 times more slop, and we don't want that. — Chris Noring

> [05:22](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=322s) It doesn't make sense anymore for us if we've got 15, 20 agents that do our bidding, that we sit there and, you know, trying to figure out what code to write. — Chris Noring

> [20:45](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=1245s) We are still important because we have built the system, right? We have built the system that instructs the agents to run amok within our harness. — Chris Noring

> [10:00](https://www.youtube.com/watch?v=GdvKNwMcfd0&t=600s) The idea with the skill is to give it a recipe, something that’s repeatable and you want the agent to use this one each time. Do not make things up. We want to constrain the agents as much as humanly possible. — Chris Noring

## Mentioned Chris Noring, Microsoft, GitHub Copilot, GitHub Copilot CLI, Copilot Chat, Anthropic, Claude, Claude Code, Claude Desktop, VS Code, IntelliJ, Playwright, Model Context Protocol (MCP), Microsoft Agent Framework, React, Tailwind CSS, Bash, PowerShell, Java, JavaScript, Python, HTML, CSS, GitHub

## Video description For decades, developers have been valued primarily for how much code they could write and how quickly they could write it. That model no longer scales. As AI becomes a first-class collaborator, the bottleneck is no longer syntax or implementation speed—it’s clarity of intent, architectural thinking, and the ability to coordinate work across many autonomous contributors.

Today’s challenge is not "How do I write this code?" but "How do I ensure this system is built correctly, consistently, and to company standards—across dozens of moving parts?" Without structure, AI-assisted development risks fragmentation: inconsistent patterns, duplicated logic, and solutions that technically work but fail architectural, security, or organizational expectations.

This talk introduces a new mental model for modern development: the developer as planner, system designer, and orchestrator of agents. Using GitHub Copilot, GitHub Copilot CLI, and custom Copilot agents driven by agents.md, we’ll explore how developers can decompose large problems, delegate implementation to specialized AI agents, and encode standards, constraints, and intent directly into the workflow. Instead of prompting ad-hoc, we define explicit instructions per layer—frontend, backend, infrastructure, testing—so every agent builds the right thing in the right way.

The result is not less control, but more leverage: faster delivery, higher consistency, and systems that reflect deliberate design rather than accidental outcomes.

What you’ll learn:

How the developer role is shifting from code producer to system designer, planner, and agent orchestrator

How to structure projects for agent-driven development, using GitHub Copilot CLI, Copilot Chat, and agents.md to encode standards and intent

How to ensure architectural consistency and quality at scale by giving agents clear responsibilities, constraints, and ownership boundaries

---

Watch along with the corrected transcript, summary, timestamps and resources on this talk's official AIE page: https://ai.engineer/talks/GdvKNwMcfd0-from-writing-code-to-designing-systems-how-the-developer-role-is-changing-chris-noring-microsoft

Join our upcoming AI Engineer conferences (see https://ai.engineer landing page):

- AIEi Shanghai, November 5–6 — the first for meeting top Chinese labs and engineers - AIE CODE in SF, November 10–12 — the top AI Coding conference returns - AIEi Sydney, December 7–8 — the first AIEi run alongside NeurIPS 2026 in Sydney

---

[Source](https://www.youtube.com/watch?v=GdvKNwMcfd0)

Reading summary

Chris Noring argues that software engineering is shifting from keyboard-bound code production to system architecture and agent supervision. In this emerging paradigm, developers delegate execution across terminal-based agents while relying on strict repository guardrails to turn generative speed into maintainable software rather than low-quality code sprawl. Re-Architecting the Workflow Around the Terminal and Dashboard (3:15) Noring proposes moving away from opening text editors or IDEs as the default starting point for development. Instead, he outlines a three-stage workflow that establishes the command-line interface (CLI) as the primary entry point for drafting minimum viable products (MVPs), managing GitHub issues, and triaging pull requests without the overhead of launching an editor. This terminal-first approach accelerates prototyping, allowing engineers to present working software demonstrations to business stakeholders rather than abstract slide decks. Under this model, the traditional code editor transitions into a mission control dashboard. Rather than acting as a canvas for line-by-line manual syntax entry, the IDE serves as a telemetry hub. Developers run parallel CLI terminal sessions handling separate tasks—such as feature additions and bug fixes—while using the editor to monitor background streams, inspect agent activity, and safeguard architectural integrity. Codifying Constraints Through agents.md and Deterministic Skills (6:47) To counter the risks of generative tools producing poorly structured "AI slop" that demands extensive rewrites, Noring advocates establishing baseline repository boundaries. He identifies an `agents.md` file as the minimum requirement for every codebase. This document acts as an operational contract, detailing application architecture, tech stack requirements (such as React and Tailwind CSS), and explicit rules, including prohibitions against unauthorized architectural alterations. To ensure consistent execution, Noring highlights "skills" as rigid, repeatable recipes that strip away agent improvisation. Structured in markdown files (such as `skill.md` within `.claude/skills/`), skills dictate ordered steps for routine tasks. Because engineers operate to reduce operational risk, skills explicitly constrain autonomous assistants, preventing them from introducing unvetted patterns or deviating from established workflows. Orchestrating Reasoning with Scoped Custom Agents (13:00) While deterministic skills follow narrow instructions, broader architectural challenges require GitHub Copilot custom agents capable of multi-step reasoning and coordination. Stored under `.github/agents/`, custom agents carry defined personas—such as security specialists, backend architects, or researchers—and can orchestrate multiple individual skills alongside Model Context Protocol (MCP) server integrations. Noring stresses that custom agents must be strictly constrained through explicit tool definitions. By declaring specific permissions in an agent's configuration, developers limit its operational scope. For example, a dedicated researcher agent can be granted permissions to browse the web and organize task lists while being denied access to write or modify repository code, ensuring autonomous behaviors remain confined to their intended role. Scaling Parallel Delegation Behind Human Approval Gates (15:00) Noring describes expanding individual capacity by delegating tasks to autonomous background jobs across two primary interfaces: running the `/delegate` command inside the terminal or assigning GitHub repository issues directly to an agent. Both paths transfer execution to an isolated backend sandbox running external tools like Playwright and GitHub MCP servers. Crucially, this delegated background execution terminates in a draft pull request rather than a direct merge to production. This workflow maintains the human in the loop, establishing an mandatory approval gate where engineers review status updates, verify code quality, and decide whether changes are ready to ship. Noring concludes that modern agentic tooling acts like a chainsaw compared to historical axes, offering massive leverage rather than replacing engineers. However, scaling developer velocity up to twentyfold carries the risk of producing twenty times more architectural defects if left unguided. The engineer's fundamental role remains designing the harnesses, specifications, and guardrails that keep autonomous systems aligned.

Source quotes

[21:28] Chris Noring: 20 times more code, that could be 20 times more slop, and we don't want that. [5:22] Chris Noring: It doesn't make sense anymore for us if we've got 15, 20 agents that do our bidding, that we sit there and, you know, trying to figure out what code to write. [20:45] Chris Noring: We are still important because we have built the system, right? We have built the system that instructs the agents to run amok within our harness. [10:00] Chris Noring: The idea with the skill is to give it a recipe, something that’s repeatable and you want the agent to use this one each time. Do not make things up. We want to constrain the agents as much as humanly possible.

Original transcript

[0:00] Thank you. Hey folks, we are starting a little bit early as we are at capacity so thank you all for showing up. My name is Chris Nooring. My daytime job is at Microsoft where I work a lot with AI engineering. Right, so this session is called from writing code to designing systems. So show of hands, how many of you are coding like you normally do? Thank you. Not many hands, right? So most of you, I think, have shifted into more of a systems approach, right? So maybe I'm talking to people who have already done the shift. That's not always the case, by the way. So sometimes when you go out at conferences, people are like, I'm hacking away. I've tried Claude. I've tried Copilot. Interesting. How many are using Claude, by the way? No judgement. How many are using Copilot? Okay, half and half, maybe more Claude, that's fine. We are very good friends of Claude, I should say that. We are even showing up at events together, so Antropic. Good stuff. So, what I mean to tell you today is maybe tell you a story that you already know. You know that your world has changed. You know that in the old days, 100% on keyboard, and you might still be on the keyboard. You just do different things with your own time. But we all knew that we were the limitation, right? We were brilliant engineers. We did 100% of the code, but... linear progress, it was just you trying to advance things. It was up to you whether a feature was being built or not. And sometimes you had to choose a scenario where, well, I don't have time to build this feature because I'm doing this over here. That's no longer a limitation. So what's happening? I think most of you still have a job, right? So you know that your job didn't disappear. you know that your center of gravity has moved. So you are no longer 100% developers, but you are now in a different position, which some people might argue, I mean, many of us I think have chosen our profession because we love coding, right? Right? I think so. So to some extent, we're still writing code. We just are very, very, very precious with our time what we write, right? Because we now have so many helpers, but... Many of you have heard the term AI slope. right? I see nodes here. So you understand in the early days of these AI tools, you were like, oh my God, I can't believe it produced this kind of code. It gives me more work than before. I had to rewrite all that code. But now we're coming into a place where guardrails is a big thing of our existence. So you are stuck with an AI tool, there's no longer an option not to use one, but of course you are thinking which AI tool am I using, right? If you're using Claude like many of you were using, you might use Claude Code or Claude Desktop. If you're using Copilot, you might know that we have a CLI, we got the GitHub UI, we have the editor and so on and so forth. So you're like, I'm trying to fit all of this into my world, right? Because my world was editors. Right? Text editors, IDs. So, Thank you. I'm proposing a new workflow and some of you might already be using this workflow, but this is where I am at. And you might tell me, hey, Chris, you're wrong. And that's completely fine. This is an idea of mine. So I think that many of us are probably here today where we start with a CLI. And that's just a weird idea, right? Because as developers, like editor used to be our first entry point. Why should I be in a CLI? That's weird. Like, I'm not a bash person, right? I mean, many of us are just building features or nothing wrong with bash or PowerShell, but that used to be other people, right? They used to manage other things. But as developers, the CLI could be a good entry point because I don't start my editor anymore, because I don't need to. So I can just sit there and I start in my CLI, that's what I propose, and then I go to the editor, because here is where I'm used to working, right? I've spent 20 years in the industry, 20 of those years or at least 19 and a half, I've spent in an editor because that's my home. So I'm saying that's the second point here. And the third point is where scaling come in today. And I think many of you are already using agents to scale. But here's where I'm saying the CLI could be your point of scale. And also the GitHub UI could be your point of scale. Thank you. So here's where we start. Here's where I think we could start. And again, I don't know if you've got eggs or not, whether you like this idea. I have something to hide behind. So what I'm saying is GitHub Copilot CLI or any kind of CLI for that matter, if you're using Claude, is where your new starting point could be. And as you know, when you code today, you create your first draft, maybe. Maybe it's a new MVP. I've heard some business where they say, hey, do you know, [5:00] What my engineers are no longer bringing me PowerPoints, they're bringing me working demos. Right? That is a big shift. Like, I don't need to ask a crowd full of developers if you like PowerPoint or not, because I know you won't, right? You'd rather bring them a working demo. Is this what you mean? Right? So I create my first draft, I set up my guardrails, right? So without the guardrails, it's mayhem, it's chaos. But of course, and this is maybe where My first thought was a few months ago, a CLI. Okay, fair enough. I'll start a CLI because I can manage my issues, my GitHub issues, my PRs. So maybe this is a good place to be, right? Because I don't need to pop open VS Code if I can just close 15 issues without even seeing the user interface. So that's definitely a use case I want to use. Issues, PRs, you know, status checks, - But of course, you've noticed as we start using agentic tools is that we don't write in Java or JavaScript or Python so much anymore. It's prompts. And we say stuff like build me an app, add this new feature or fix this. How many recognize yourselves here? How many have this? Bunch of terminals open, building, build me an app, that, right? That's our next MVP. That's how my company is going to make a lot of money. Or maybe me, maybe that's my side project. Fix an issue, right? That's another use case. And here we have add a new feature and build another cool app. And meanwhile, I'm sipping my... a cup of coffee or tea or whatever my favorite beverage is while it's kicking away. Right? Thank you. So this is literally my world today. And if it's not your world, I would have a think and say, could it be my world? And of course the editor might be one place out of many where it could also be in there. When we continue on now from the CLI to the editor, what we're trying to do, just like the CLI, by the way, is that we need to set up guardrails. We need to set up custom agents. And let me also explain what custom agents are. And then here's where I propose that we spend less and less time with the editor. Because it doesn't make sense anymore for us if we've got 15, 20 agents that do our bidding, that we sit there and, you know, trying to figure out what code to write. But-- I still love the editor, right? As I said, 19 and a half years, I spent out of 20 with an editor, so I feel more in control. I feel more used to it. So I'm not going to let go of it. And the good news is that regardless of what AI editor you're using or AI provider, you probably have something that listens to your CLI streams, your streams from the editor, maybe your streams that happens over in the GitHub repos. So I kind of like it as the control board if you will, right? That's how I kind of see the editor. Thank you. And you know this, right? I mentioned AI slot before and I see some nods and then I saw some pain, right? Like we know this pain. Without rules, agents run amok. So what do we do? We add guardrails. Guardrail number one. This is the absolute bare minimum, right? Agents MD. should have this in all your GitHub repos or whatever kind of repo structure you have. This is your high level guidance explaining repository intent, application architecture constrains the do's and don'ts, right? There are things in here, for example, we could explain... what the agents should not do. For example, you should never change the architecture unless I tell you or here in the high level, we say, well, this project is this and that this may be some finance app that uses react, maybe it's using Tailwind and so on, so forth. There are many things that go into an agent's MD, but I kind of see it as a high level thing. Thank you. Thank you. And just very, very high level here. You see a demo here, you see a repo, built a little finance tracker, vibe coded, right? I have a little agents MD. You can see how I have this project overview, agent responsibilities, and so on and so forth. Quite a long file. Thank you. Just to take you through it And I can query here in the bottom right and say what does this agents MD do? And of course, if I am in a fresh project, I might have an Agents MD from another project, so I can just copy it in and say... use this one, adopt my maybe old code base or my present code base, into adhering to AgentsMD. Right? So agents MD is one of those things that's a bare minimum thing to do. Another problem I have is that agents don't do things correctly. I think you've noticed this as you work with agents, is that it's almost the same, right? Or sometimes it just goes in this direction, it's definitely not correct. So for situations like that we need to use skills. How many are using skills? That's a good show of hands. So I'm preaching to the choir, as they say, right? [10:00] I'm not going to sing, I promise. So the idea with the skill is to give it a recipe, something that's repeatable and you want the agent to use this one each time. Do not make things up. We want to constrain the agents as much as humanly possible. So a skill, as maybe a majority of the room already know, is a contract, right? Something that the agent can invoke. So instead of improvising logic, because we know as developers, we want to mitigate risk, right? We know that the agent should have a harness around it and say, don't do things that I don't want you to do. Don't be creative. Don't do anything. Right? So now we can also say these are tools that you should use. And yeah, so we should definitely be using skills for these projects. for these tasks that are repeatable, that we do often, that needs to happen in a certain order. So a skill is called by an agent, it has a strict contract, it's self-contained because it just lives in a folder. And it's intentionally constrained because we don't want agents to do things, right? We want it to be as much as a human developer as possible while being fast. Thank you. And about creating skills, if you haven't done that before, and this is how it works within GitHub Copilot. But if you're on Claude, which half the audience is, You usually have dot cloud slash skills. That's usually where you place the skills. You have folders, one folder for each skill, and then you have a skill dot MD. And it comes with some front matter with name and description, what it does, and then a long markdown instruction. What should happen? So, skills are a great thing. I think it's great that we are all in agreement, all the big vendors, whether you are Antropic or Microsoft or anyone else, because ultimately, As developers, we don't always decide what vendor that we use. So, Creating a skill is therefore pretty straightforward and yeah this might be VS Code specific but I'm sure in Claude this is equally simple. So we're just here, we have a folder already, we have a skill, skill.md, and we can just, and one of my favorite things to do, because I'm really bad at writing these instructions, is simply to ask Copilot, how do you write a better instruction for what I aim to do? Thank you. And I can definitely bring up a user interface to add a new skill. And I think whether you use VS Code or IntelliJ, it's pretty much the same thing. Thank you. And here I'm invoking the skills, by the way, and there are different ways of doing that. So either I'm calling /skills, in which case it allows me to configure the skills, or I'm just typing a prompt that resembles the name or description of the skill, in which case it will be invoked. Okay. Another problem I have is that sometimes I need more than skills. How many are using agents MD and skills and then nothing more? Okay, so you probably are using something more. You're probably using agents and you might not know what I'm after, but we have this thing in GitHub Copilot called the custom agent. That's when we feel like the skill isn't enough. When we need the next level. So what I'm saying is that a skill is limited in what it can do. It can't really orchestrate itself with others. That's when you need an agent, right? You need something that's able to... recent. So here with a custom agent you have a persona, right? And an agent can use n number of skills. So it has a distinct role and purpose. So think security expert, backend, frontender. Think also that is able to use MCP servers. So you can see at this point, an agent becomes a higher level concept than a skill. Thank you. Thank you. So just to... Compare and contrast, we see that the agent is more of an orchestrator, it's more broad in its scope, it has a personality, it's able to plan, it's able to reason. Thank you. And we also see that it's... Thank you. Yeah, it's different on the autonomy level and you see that the skill is great. The skill might be great in many times, but it simply doesn't have all these other higher level functioning. And of course, just like a skill though, a custom agent has a front matter, it has instructions, and now the question is where do we place it? So let's go into another demo. So how many of you were using Copal? It's like half the room, right? Thank you. Right. So If you started using custom agents already, you would know that you have .github/agents, even though you can, I think, choose where to place it. The important part is that you call it dot agent. That's what makes it find it, right? But this is the custom place where it should live. But if we compare that a second to the skill, we see that the skill had name and description up here, whereas here we have argument hints and we have tools. Tools is an important question. [15:00] concept because that's able to constrain the agent what it can do or not right so in this case the agent can read, it can search the web, it can create to-do lists and much more. I'm sure a similar concept exists in Claude, by the way. So what I'm trying to say here is that this is much more than a skill, as you can see, right? Because it's able to go off and do things and maybe play well with other agents. In this case, it's a researcher. That's why we constrain it to work on the web and maybe not necessarily be able to create files or edit files or do things like that. So a good use case I want to find out something, right? So were I to use it, I would go into... my chat here and ask it questions maybe about the, yeah, for example, Microsoft agent framework or whatever I'm interested in. So here I have a prompt and I should get some kind of prompt response. And then I've also selected the researcher down here. So that's an important part. And this is very, of course, Copilot specific, but if you look at the idea, I think you see that this is more than the skill, right? It's a thing that has tools, it has reasoning and so on and so forth. Thank you. Okay. Right, so now we are kind of approaching our a final chapter out of three because we're starting in the CLI. We started with saying, hey, maybe I have six different terminals that does things for me, everything from adding features to working on the latest MCP to fixing things to the scale part. And here's where it gets interesting, right? Hopefully most of you still have a bunch of colleagues, but here's a lot of other colleagues and you need to keep track of them. You've noticed that And I'm going to use an interesting word for agents here. I have heard people refer to them as toddlers. I don't know if you've heard the same. But the idea with agents is that sometimes we think they're super smart and sometimes they're just plain dumb. They literally go between genius and "Oh my God, I can't believe you did this." So you understand the harness, you understand the need for a harness. So what I'm trying to say here is that yes to all scaling, yes to all delegation, but you saw the need for adding guardrails. So now that we feel good about this, now that we feel good about AgentsMD, custom agents, custom instructions, we've laid the groundwork. Now we come to the interesting part of scaling ourselves, because that's ultimately what it means, right? Each of us could be the 10-time developer, the 20-time developer, or even 100-time developer. So, we can scale in one of two different ways if you use Copilot, right? We can either scale directly from the CLI or we can scale from the UI when we are looking at our GitHub repository. So we're in here, And what we're doing here to scale is to call /delegate. So here we simply say, create a finance app that tracks my spending use HTML, CSS and JavaScript. So here we're telling it. to go build us an app. And this is just one of many terminal windows that we have open. So by calling delegate, and I should mention that this needs to be a proper GitHub repo or it's going to complain. Because if it's not, it's going to be like, "Hey, Chris, I can't do this. I'm not a GitHub repo yet. Make me one." So here it just says, "Send this session to GitHub." And it does. So now it's going to create a bunch of things is tried to, it starts a job, it creates a draft PR and this is important. Most of our agents work in sandboxes or all of them, right? So they can't really break out of the sandbox and do a bunch of weird stuff, but they can create a PR. And that brings us in as humans, as humans in the loop. Okay. And of course this can happen from GitHub also if you have GitHub Enterprise. I don't know how many it does but So this is, by the way, what it looks like in GitHub. I just wanted to show you this. So had I clicked the link from the CLI, I would have ended up here. it would have said, "Hey, Chris, I'm working on your task. I'm trying to build you that finance app. So here is me using MCP servers like Playwright, GitHub MCP, so on and so forth." So, That's the beauty, right? So imagine now that I had all these terminals open, I delegate this, I delegate that, and suddenly we worked on the entire product backlog. Here's the other modality and this is pretty much the same thing. We're just doing it from the GitHub user interface instead. So here we are simply saying, I have created an issue. The issue usually has more description than this, but I'm just showing you the principle. So here I'm saying add dark mode to my app. I have a title, I have a description, and I have this thing over here. So here I can assign to agent. So essentially, if I'm in the user interface for a repo, I can just say, oh, here's a bunch of issues. Each of these issues are a next feature or a bug fix or whatever. delegate, delegate, delegate, delegate, and I go have a coffee, right? Okay. So, oh. So if we kick [20:00] off. You can just see me here having created this issue. and then I click assign agent and I can give it further instructions if I need That kicks things off. The first thing that's going to happen is I'm going to see this one. I'm going to see this little icon here that says, ooh, copilot. You called my name, right? So now Copilot is giving it a few seconds and you can see how it works on this VIP, this work in progress. You can click it, you can see exactly where it is. And this is where the human in the loop comes in, right? Because once it's done, it's giving you a draft PR and say, hey, Chris, what do you think of this? Is this something we can ship? So after a while it's going to come back to me and but the good part is this happens in the background and I can keep working on other things. Thank you. So this is really the power of delegation, right? This is how we scale ourselves to utilize our minds better. I usually compare this whole age, the strange age we live in to people who used to cut down trees with axes. I see we are now at the point where we're throwing the axis, we're using a chainsaw instead because we are so much faster. This is not something that's new to us as developers, right? We are used to better tools. And that's why I'm saying human in the loop. We are still important because we have built the system, right? We have built the system that instructs the agents to run amok within our harness. We have approval gates ourselves and we can probably add more approval gates And the agent is literally asking us for a review before and we can still be the ones that merge. So So in summary, If you haven't used any kind of CLI product before for agents, See what I showed you six different terminals or more and you can get so much stuff done, whether it's your side project at home, whether you're working at a big enterprise company, You can build new apps from the CLI if you dare venture out from the editor. In your editor, I tend to use that less and less, but more like fine adjustments, because sometimes an editor experience is just better, you know. And yeah, the CLI or the GitHub UI can scale, it can delegate, and we are 20 times the developer we used to be. Thank you. Providing, of course, we provided the right guardrails, right? Because 20 times more code, that could be 20 times more slop, and we don't want that. And yeah, the guardrails I'm introducing today, which I think many of you might know about, is AgentsMD.com. skills, custom agents, and so on and so forth. And all about this is about scaling you now that we have AI, not replacing you. So hopefully I'm landing you with a good message to say, we want the engineering brain. So please stay in this industry, right? So thank you so much, folks. Music.