Video summary

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

Main summary

Key takeaways

Technology

Technological concepts & workflow changes (core message)

  • Shift from “writing code” to “designing systems”: Developers spend less time manually coding end-to-end and more time orchestrating work with AI assistance. The “center of gravity” moves from being 100% hands-on coders to managing systems, constraints, and delegations.
  • AI tools introduce “AI slop” / agent mistake risk: Early AI coding often required heavy rewriting. The focus now is on guardrails so agents don’t run amok and produce incorrect or risky changes.

Proposed workflow: CLI → Editor (control) → Scaling via delegation

  1. Start in the CLI as the entry point

    • You don’t need to open an editor just to manage work items (issues/PRs/status checks).
    • The CLI becomes a way to orchestrate agent actions and handle GitHub-related tasks via tools/commands.

  2. Use the editor less for generation, more for control/fine-tuning

    • The editor is framed as a “control board.”
    • Agents and providers can stream/act based on CLI/editor/repo context, so the editor remains important—but generation can happen elsewhere.

  3. Scale with delegation from both CLI and GitHub UI

    • CLI scaling: use a command like /delegate to generate features/apps and create a draft PR.
    • UI scaling: create issues and assign agents to them so work happens in the background, culminating in draft PRs for review.

Key guardrails and product features (explicit guide-style points)

1) agents.md (bare minimum repo policy)

  • Should exist in each GitHub repo.
  • Contains high-level guidance:
    • Repository intent and architecture
    • Constraints and dos/don’ts
    • Examples like: “never change the architecture unless instructed”
    • Framework/stack descriptions (e.g., React, Tailwind)
  • Includes a demo/project overview idea:
    • Copy/adopt an existing agents.md from another codebase to standardize behavior.

2) Skills (repeatable, constrained agent actions)

  • A skill is described as:
    • A contract invoked by agents (not improvised logic)
    • Repeatable workflows that need to run in a specific order
    • Self-contained (lives in a folder)
    • Intentionally constrained to reduce risk and hallucinations
  • Implementation detail (Copilot-specific, generalizable as a concept):
    • Place skills in /skills (Claude is also referenced as dot Claude slash skills)
    • Each skill includes a skill.md with front matter (name/description) and markdown instructions.

3) Custom agents (when skills aren’t enough)

  • A custom agent is positioned as a higher-level orchestrator:
    • Has a persona/role (e.g., security expert, backend, frontend)
    • Can use multiple skills
    • Can reason/plan more than a skill alone
    • Can interact with tools (and mentions MCP servers in the ecosystem)
  • Copilot-specific placement/calling convention:
    • Custom agents live under .github/agents and must be called as an agent so the system can discover it.
  • Tools-based constraint example:
    • A “researcher” agent is constrained to web/search-like actions rather than writing/editing files.

4) Delegation + “human in the loop” via draft PRs

  • Agents operate in sandboxes and typically cannot directly break out to do uncontrolled changes.
  • Handoff mechanism:
    • Delegation leads to draft PRs
    • Agents ask for human review/approval before merging
  • This is the scaling mechanism: delegate multiple tasks/issues while humans stay in control.

How the talk frames “scaling”

  • Delegation can be done:
    • From CLI: delegate runs work and creates draft PRs in a proper GitHub repo.
    • From GitHub UI: assign agents to issues; drafts are generated with visible progress states; humans review and merge later.
  • Analogy: developers previously used better “tools” (axes → chainsaws). Now agents are like chainsaws—but humans provide the system and approval gates.

Main speakers / sources (as stated in the subtitles)

  • Chris Noring (Microsoft) — primary speaker.
  • Technologies/products referenced within the talk:
    • GitHub Copilot / Copilot CLI
    • Anthropic Claude / Claude Code / Claude Desktop
    • GitHub (GitHub UI, PRs/issues) and MCP concepts
    • Mentions of MCP servers (e.g., Playwright, GitHub’s MCP)

Original video