Realtime multiplayer, automation, and you! — Idan Gazit, GitHub

Idan Gazit, who leads GitHub Next (the team behind Copilot), explores the future of software development through the lens of AI, emphasizing a shift from individual productivity to enabling groups and automating tasks requiring judgment. He introduces two key prototypes: Agentic Workflows and ACE.

The Vision: Automating Judgment and Enhancing Collaboration

Gazit posits that while AI initially boosted personal productivity (LLMs completing text, agents fetching information), its true value lies in enabling groups. The software industry, though vast, is “pre-industrial” in its automation, having mostly relied on heuristics. AI now allows for automating tasks requiring “basic judgment and intelligence,” freeing up developers to focus on craft and product innovation. This also reshapes collaboration, making understanding a critical bottleneck, especially as processes accelerate.

Agentic Workflows: Automating Code Maintenance with Strong Guardrails

Agentic Workflows is presented as GitHub Next’s solution for robust, autonomous automation in an AI-driven world.

The Problem and Solution

Gazit uses his personal website, built with Astro, as an example. Astro’s frequent releases mean constant upgrades. While Dependabot notifies of updates, manual code changes are often required. He envisioned a “super Dependabot” that could handle these breaking changes automatically.

How It Works

1. Natural Language Prompting: A simple, plain-English request (like a Slack message to a junior developer) is given to Copilot, detailing the desired workflow (e.g., “check for new releases, review changelog, apply upgrade, create PR”).
2. Playbook Generation: Copilot expands this into a full playbook, presented as a Markdown document. Gazit describes this as “If GitHub Actions and Copilot had a baby together, and it ran on Markdown.” The Markdown document is the source code; the YAML actions file is a compiled artifact.
3. Example: Astro Upgrade: The system successfully upgraded his Astro site from version 5 to 7, identifying and fixing broken code, verifying the build, and highlighting manual steps. It even summarized release notes.

Crucial Guardrails for Agentic Workflows

A core focus is on security and control, as prompting an agent is not a sufficient guardrail due to prompt injection risks. Instead, guardrails are declared deterministically in YAML front matter:

• Permissions: Explicitly define what the agent can read and write (e.g., “read all”).
• Allowed Tools: Specify which tools the agent can use.
• Network Destinations: Whitelist specific network endpoints (e.g., NPM ecosystem, GitHub, Astro docs) to prevent unauthorized access (e.g., bitcoin.com).
• Safe Outputs: Control the agent’s actions (e.g., “create pull request single” to prevent denial-of-service by creating 500 PRs, or explicitly allowing it to “do nothing” to avoid unnecessary noise).
• Security Principles:
  • Defense in depth: Multiple layers of security.
  • Never trust agents with secrets: Secrets are kept outside the agent’s “jail,” requiring the agent to ask a “warden” (secure service) to use them.
  • Stage and vet all rights: All actions are auditable.
  • Log everything: For full auditability.

Applications and Availability

Agentic Workflows can be used for tasks like issue triaging (e.g., Home Assistant project using it to classify bugs), hunting N+1 queries, repo assistance, and CI issue diagnosis. It’s in public preview, with the belief that “automations that run in the background while you sleep, that’s the ballgame.”

ACE: Real-time Multiplayer Software Development

ACE is GitHub Next’s prototype exploring future collaboration in software development, designed to move beyond traditional isolated coding.

The Need for New Interfaces

Gazit argues that current collaboration tools like Slack weren’t designed for software development. The goal is to surface information not explicitly in code—“political considerations,” infrastructure deals, or shared plans.

How ACE Works

1. Chat-like Interface: ACE deliberately resembles a chat application, providing a shared surface for teams.
2. Cloud MicroVMs: Every session runs in a cloud microVM, isolating work and enabling real-time collaboration without local machine dependencies. Each session is effectively a branch of a repo checked out in the cloud.
3. AI-driven Context: The AI in ACE acts on the entire chat history and shared documents. This allows it to understand collective decisions, even if they evolve through multiple revisions or debates, saving developers from manually extracting the final consensus.
4. Shared Document Editing: Teams can collectively edit Markdown documents (e.g., a plan for a new feature). The AI then “makes the document true” by executing the plan, suggesting a future where development involves editing documents that the AI interprets and implements.
5. Ambient Awareness: ACE provides visibility into what team members are working on, fostering continuous alignment.
6. Agent-Human Interaction: Agents can listen to discussions, ask clarifying questions, or tap humans on the shoulder when a manual intervention or decision is needed.

Beyond Typing: The 95% of Development Work

Gazit highlights a study showing that “hands-on keyboard typing” constitutes only about 5% of a developer’s work. The remaining 95% involves understanding systems, exploring changes, and collaborating. ACE aims to address this larger portion of the development process, leveraging AI to discover, analyze, and facilitate these broader activities.

ACE is expected to enter technical preview soon, aiming to transform how teams collaborate and automate in the evolving landscape of AI-assisted software development.

• Tags:
• Software Development
• Devops
• Feature
• LLM Security
• AI Automation
• Agentic Workflows
• Guardrails
• Copilot
• Team Collaboration
• MicroVMs
• ACE
• GitHub Next
• Astro