# Realtime multiplayer, automation, and you!

Idan Gazit

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/iQ5xldZ9StU-realtime-multiplayer-automation-you) · [Video](https://www.youtube.com/watch?v=iQ5xldZ9StU)

## Realtime multiplayer, automation, and you

When code becomes cheap, choosing the right work and staying aligned become harder. GitHub Next’s Agentic Workflows and Ace explore automation and collaboration as parts of the same development loop.

Familiarity with Git repositories, pull requests, CI workflows, and dependency upgrades will help you follow the demonstrations.

### What should we build when code becomes cheap?

[0:22](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=22s)

If AI can help us think and make software, and the marginal cost of another line of code keeps falling, what is worth building? That question shapes the work of Idan Gazit’s team at [GitHub Next](https://githubnext.com/), the labs group that created **Copilot** and explored specification-based programming and natural-language-to-app development. Its prototypes scout the tools developers might use a year or two ahead; not every experiment becomes a product. Gazit jokingly calls it the Department of Fool Around and Find Out, but the method is practical: build things to discover what is useful.

Even a developer with effectively unlimited tokens and ten terminals running agents still faces **opportunity cost**. More capacity does not decide where to spend that capacity. With the technology changing every week, this is no longer a problem reserved for a research team. GitHub Next looks for durable themes: needs that will survive the next model release.

![A two-tone slide reads “Research?” above “Prototyping.” with the presenter inset at lower left.](https://ai.engineer/api/talk-essay-media/bfc55f8be8a9f886323dc8d9654cb5c08dfe2730a234bad888bc11d48d84a626)

Research? Prototyping.

### Automation buys time; collaboration protects it

[2:20](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=140s)

AI development tools began with personal productivity: complete what I type, fetch what I need, run several agents so I can pursue several tasks. But multiplying one person’s output is only part of the opportunity. The larger goal is to let groups accomplish more together.

The first route is **automation**. Gazit uses the industrial revolution as an analogy: software has automated many mechanical checks, such as requiring a semicolon, while leaving work that needs judgment to people. Agents make some of that judgment-dependent work automatable. The benefit is time that a team can put into craft, product quality, or features. Hiring more people expands capacity; removing recurring manual work can also free capacity already inside the team.

The second route is **shared understanding**. Geoffrey Litt’s observation that understanding becomes the bottleneck applies to individuals, but shipping within a team requires agreement among people. That agreement cannot wait until the end. When implementation accelerates, a small misunderstanding can produce a large amount of unwanted work before anyone notices—and that waste now includes paid tokens as well as human time. GitHub Next explores these two needs through [Agentic Workflows](https://githubnext.com/projects/agentic-workflows/), for background automation, and Ace, for realtime multiplayer development.

![Slide pairs “Agentic Workflows” with “Secure-by-default automation” and “Ace” with “Realtime multiplayer agentic development.”](https://ai.engineer/api/talk-essay-media/800abb987419c02ac5f3fee0c11a206fedce9a9021a38ea4f146a643ae8198a9)

Agentic Workflows and Ace: automation and multiplayer development.

### From an upgrade request to a Markdown playbook

[4:50](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=290s)

Gazit starts the automation demonstration with his personal website, built with Astro. Frequent framework releases create an upgrade treadmill. Dependabot tells him when dependencies are outdated, but completing an upgrade can require application changes, not just a new version in a manifest. He wants an automation that continually checks dependencies and prepares those code changes too.

To create it, he gives Copilot a skill-like document explaining how to author an Agentic Workflow. The actual request then resembles a message to a junior developer: check daily for new releases, read the changelog and documentation, plan the upgrade, and open a pull request. The documentation links supply the places to investigate.

The result is a **Markdown playbook**. Copilot reads the repository to identify the relevant dependencies, then expands the short request into a sequence of tasks. The body can express the work directly:

```markdown
# Website dependency upgrade

1. Inspect the repository dependencies and check for new releases.
2. Read the changelogs and upgrade guides between the installed
   versions and the proposed target versions.
3. Plan and apply the dependency upgrades and required code changes.
4. Create a pull request describing the upgrade.
```

This is the useful combination of GitHub Actions and Copilot: a recurring workflow supplies the execution setting, while a natural-language procedure describes work that requires reading, interpretation, and judgment.

### The prompt describes the job, not its security boundary

[6:59](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=419s)

At the top of the Markdown document, YAML front matter specifies the agent’s guardrails. An unattended agent needs explicit limits on what it can read, which tools it can use, where it can make network requests, and what it can write. Putting those limits only in the prompt is insufficient: a prompt injection can try to redirect the agent despite an instruction forbidding an action. **The execution environment must enforce the boundary.**

The demonstrated configuration separates several controls:

| Control | Demonstrated boundary |
| --- | --- |
| Repository permissions | `read-all` |
| Tools | Explicitly specified tools |
| Network | Specified defaults, npm, GitHub, and Astro documentation |
| `safe-outputs` | `create-pull-request`, limited to one PR |
| No work needed | Allowed to do nothing |

These settings describe the demonstration, not a complete current configuration recipe. The distinction that matters is between the agent requesting an action and the system permitting that action. A single-PR limit also bounds disruption: Gazit’s example of an injected agent creating 500 pull requests would be a denial of service against the maintainers. Allowing no action is equally deliberate. A fleet of automations should not manufacture work or notifications just to announce that it ran.

### Inspecting the upgrade, not just the version bump

[8:48](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=528s)

The first result comes from Gazit’s actual website automation. Its pull request synthesizes the release notes between the installed and target versions into a description tailored to his project. For the minor-release example, it reports no breaking changes and checks the project by running and building it. A Cloudflare preview deployment then lets Gazit inspect the upgraded website. It appears unchanged, which is the desired result for this maintenance task; any hosting system with preview deployments could provide the same inspection point.

The next example is more demanding. Gazit describes upgrading the site from Astro 5 to [Astro 7](https://astro.build/blog/astro-7/), crossing two major versions. The generated explanation covers changes from both intervening releases. He reports that the workflow repairs affected code, verifies the build, and highlights manual steps still required. He opens the preview again and finds the website still working. The pull request therefore delivers more than a dependency bump: it combines changes, an explanation, build evidence, and a remaining-work handoff. A successful preview does not erase that handoff.

### Markdown is the source; Actions YAML is the artifact

[10:23](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=623s)

Changing the automation means editing the English in its Markdown source and recompiling it into an Actions workflow. The generated YAML is an artifact, rather than the primary surface for iteration. A library of workflows supplies starting points that teams can customize instead of authoring every procedure from scratch.

The examples extend well beyond dependency maintenance:

- **Issue triage and code investigation:** GitHub has experimented internally with an issue triager and workflows that hunt for N+1 queries in its monolith.
- **Repo Assist:** A group of cooperating workflows finds approachable fixes, nudges tickets, and identifies places where maintainers need feedback from issue reporters.
- **CI Doctor:** Broken CI becomes a task to investigate, rather than merely a reason to rerun the same job.
- **Team and repository status:** Recurring summaries make project activity easier to follow.
- **Research and ticket synthesis:** Gathering information from the internet and summarizing related tickets can serve product managers as well as engineers.

Making these procedures accessible to more roles broadens who can create automation—and which recurring work a team can remove.

### Keep secrets outside the agent’s environment

[11:46](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=706s)

Background execution makes security architecture central to the product. Gazit gives four principles:

1. **Use defense in depth.** No single protective layer is enough.
2. **Never expose secrets to the agent.** Treat a secret the agent can read as compromised, because injected instructions may induce disclosure.
3. **Stage and vet writes.** Changes must pass through an inspectable path.
4. **Log everything.** Preserve the evidence needed to audit what happened.

In his jail-and-warden analogy, credentials remain outside the agent’s jail. When the agent needs a credentialed service call, it asks the warden to make the call. The service can be used without placing its secret into the agent’s readable context.

Gazit reports a concrete adoption example from Home Assistant: a workflow examines submitted issues and follows Python stack traces to distinguish bugs in the project’s own code from bugs in third-party code, closing issues outside its responsibility. The accompanying slide describes investigating backtraces, finding root causes, and suggesting ways to address them. This is the sort of contextual triage he sees as newly practical with AI, beyond the heuristic checks teams previously automated.

![Home Assistant slide quotes a workflow that examines issues with Python backtraces originating in its codebase, finds root causes, and suggests ways to address them.](https://ai.engineer/api/talk-essay-media/6e95d17d49bdb6f4fc1e95b7e1aaf2610863ed201984932c96804c4dfc48657f)

Home Assistant describes a workflow for investigating Python backtraces.

At the time of the talk, Agentic Workflows is in public preview. Gazit expects background automation to become a larger category than interactive AI: work that continues while people are away can remove recurring obligations without requiring another conversation each time.

### Bring collaboration inside the build loop

[13:17](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=797s)

The familiar development sequence is to plan together, build alone, and review together. When AI can take substantial implementation steps quickly, that separation becomes less useful. People can instead adjust direction together, let the AI take a step, inspect what happened, and adjust again. Planning and review become recurring parts of building rather than phases on either side of it.

A chat interface helps expose information that is absent from the repository. Slack was designed as an improvement on office email, not specifically as a place to make software, but conversation carries essential constraints: a vice president favors one direction, a stakeholder wants purple, or an Azure infrastructure deal makes another cloud economically unattractive. An agent cannot recover those reasons simply by reading code.

The comparison is collaborative document editing. Instead of emailing Word files back and forth, people now create and collaborate in the same surface. Ace explores what that arrangement could mean for code: teammates, agents, and the work itself share a place.

### A shared session with chat, compute, and preview

[14:52](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=892s)

Ace initially looks like a Slack-style interface, with repository sessions listed on the left. Each session represents a repository branch checked out into a **cloud microVM**. Gazit explains that none of the demonstrated session compute runs on his machine. The shared environment holds both the code under development and the conversation about it.

While chatting with Russ about favorite colors, Gazit installs dependencies and starts the development server with:

```bash
bun dev
```

He then opens a browser preview. Chat and terminal interaction coexist, but they remain different input modes: he accidentally submits a remark about green being calmer as a terminal command, then moves it back into the conversation.

The application is a calmer take on Hacker News. Having discussed its color with a teammate, Gazit does not want to restate that discussion as a separate specification for the agent. Instead, he invokes Ace with “Yo, Ace, do it.” Ace can read the team conversation’s backscroll and use it as context. The live response is delayed, which Gazit attributes to Wi-Fi; he moves on without showing the completed color change.

The intended capability goes beyond extracting the most recent sentence. Engineering conversations contain proposals, edge cases, reversals, and returns to earlier ideas. Gazit expects the agent to infer the final agreed direction from that history, sparing a person the extra job of turning a conversation the agent already saw into a new handoff prompt.

### Edit the plan together, then ask for implementation

[17:06](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1026s)

For a more involved change—adding selectable timeframes—Gazit asks the agent to generate a Markdown plan. That document is not a private answer for one developer. It is a shared editing surface: Russ can add an all-time option while Gazit removes today. Gazit then asks the agent to act on the updated plan. The demonstrated handoff is the jointly revised document; the passage does not show the completed feature.

This suggests a broader development interface. Markdown documents in a `docs` folder can capture intended application behavior, and changing the application can begin by changing those documents. Gazit’s formulation is “make the document true”: ask AI to bring the implementation into agreement with the edited specification. If that becomes a common way to work, shared document editing is a central development capability, not merely a convenience attached to chat.

### Stay aware without joining every session

[18:28](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1108s)

Realtime editing does not by itself keep a team aligned. People also need ambient awareness of work happening elsewhere. Recalling GitHub’s former social coding tagline, Gazit shows a dashboard of actual Ace team activity, including Krzysztof’s work on VM tooling. The displayed Maggie identity has a prototype-specific explanation: Maggie built the dashboard and hard-coded her name. The purpose is to make teammates’ ongoing work visible without requiring everyone to participate in every session.

Background automations could eventually appear in that same surface. A person might talk to an automation, or an agent might ask a person a question when it needs a decision. That leads to an inversion of the usual interaction: better goal descriptions let agents proceed with less continuous supervision, while models that detect underspecified behavior can request clarification or human action. An interface that lets agents follow ongoing activity can also let them initiate contact when necessary. Gazit briefly compares this destination with OpenClaw approaching from another direction, without developing an architectural comparison.

### Help with the work around the code

[20:08](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1208s)

Gazit closes by citing an unnamed longitudinal study of roughly 100 developers over thousands of hours, describing hands-on-keyboard typing as 5% of their time. His slide labels that category Editing and shows Comprehension at 58%, Navigation at 24%, Other at 13%, and Editing at 5%. The study is not identified in the talk, so these figures serve here as his framing of developer work rather than a universal division of the working day.

![Horizontal bar chart lists Comprehension at 58%, Navigation at 24%, Other at 13%, and Editing at 5%, with editing highlighted in teal.](https://ai.engineer/api/talk-essay-media/119ce950f67644a8210a0102e3e43f85a7e415176015d4560e8eadc2ae1f4e2b)

Comprehension 58%, navigation 24%, other 13%, editing 5%.

The remaining work includes finding the system to change, understanding how it behaves now, and learning what other people think should happen next. If an agent can discover facts inside a repository, the development environment still needs to help people and agents handle all the context and coordination around those facts. That is the connection between the two prototypes: automation frees attention from recurring tasks, while a shared workspace helps direct that attention and the resulting implementation.

At the close, Gazit invites discussion and feedback through GitHub Next and the Microsoft booth. Agentic Workflows is already available to try; he hopes Ace will enter technical preview later that month. The invitation is to explore tools that help teams decide, understand, and coordinate—not only type faster.

## Resources

- [Agentic Workflows](https://githubnext.com/projects/agentic-workflows/) — GitHub Next's introduction to natural-language GitHub Actions workflows, including a small workflow example.
- [GitHub Agentic Workflows repository](https://github.com/github/gh-aw) — Installation instructions and current source for compiling Markdown workflows into GitHub Actions.
- [Safe Outputs reference](https://github.github.com/gh-aw/reference/safe-outputs/) — Configure validated write operations, operation limits and no-op reporting for agentic workflows.
- [Astro 7.0 release announcement](https://astro.build/blog/astro-7/) — Official Astro 7 release highlights and upgrade instructions.
- [One Developer, Two Dozen Agents, Zero Alignment](https://githubnext.com/talks/one-developer-two-dozen-agents-zero-alignment/) — Maggie Appleton's companion talk on collaborative AI engineering and the Ace research prototype.
- [Measuring Program Comprehension: A Large-Scale Field Study with Professionals](https://soarsmu.github.io/papers/2018/Xia2018ProgramComprehension.pdf) — A field study of 78 professionals examining comprehension, navigation and editing across desktop applications.

## Slides

### GitHub Next

Idan leads GitHub Next, GitHub’s labs team, which created Copilot and explores future software tools. Much of its work happens in the open.

[0:25](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=25s) [GitHub Next logo above its website and social accounts.](https://assets.ai.engineer/sites/aiecode2025/sha256/0d01333eab12ab7a6240f46b9e9d0c922378779a561a0a0fc9e788925369696c.webp)

githubnext.com

X githubnext
githubnext.com

### Research? Prototyping.

GitHub Next makes things to find out what works. The hard question is choosing which ideas are worth its time, even as AI lowers the cost of making them.

[1:16](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=76s) [Research? Prototyping.](https://assets.ai.engineer/sites/aiecode2025/sha256/1c017700293150e775ab667030dc564721cb4703740ee50e87b3a60a1a6f541c.webp)

Research?
Prototyping.

### Multiply us, not me

AI began with personal productivity; the speaker sees greater value in helping groups of people do more.

[2:18](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=138s) [Multiply us, not me, on a teal background.](https://assets.ai.engineer/sites/aiecode2025/sha256/ad65de4aa444d6e9c03b136f8745137029607115a5cee24ab6b30c6e72f82f32.webp)

multiply us, not me

### Automation and collaboration

Automation can free time for product and craft, while faster development makes team alignment more important: small misalignments can snowball into wasted work.

[2:53](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=173s) [Automation and Collaboration on a dark background.](https://assets.ai.engineer/sites/aiecode2025/sha256/b9dda393e4a6605b2b7d2ae054a4780f2315b1891a0192aa42b1e8e9e2149a17.webp)

Automation
Collaboration

### Agentic Workflows and Ace

GitHub Next is exploring two prototypes: Agentic Workflows for secure-by-default automation, and Ace for real-time multiplayer software development.

[4:38](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=278s) [Agentic Workflows: secure-by-default automation; Ace: realtime multiplayer agentic development.](https://assets.ai.engineer/sites/aiecode2025/sha256/c827e77c56ca9d30146cf64b0e3639a94bba6f5f2d42b7e3c913ef34b67fe796.webp)

Agentic Workflows
Secure-by-default automation

Ace
Realtime multiplayer agentic development

Interface text:
AIE WF 2026
7 / 17

### Personal website

Idan Gazit opens his personal website to set up the Agentic Workflows demo. He says the site is built with Astro and will return to it later.

[4:52](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=292s) [A personal website with an illustrated portrait and biography.](https://assets.ai.engineer/sites/aiecode2025/sha256/db60cc9980948e70ecc02e5fba65d54efc2a2abc2d31bc0e4c912fa80b058d16.webp)

IDAN GAZIT MAKES THINGS FOR PEOPLE WHO MAKE THINGS.

Hello!

I’m a hybrid and a maker; one part developer, one part designer. I’ve spent my career working on creative tools and platforms. I’m a big believer in the web, and I often nerd out about typography, data visualization, and electronics.

I lead GitHub Next: the team which created GitHub Copilot, the first widely-adopted application of generative AI. Mostly, this job is about improving the lives of developers while avoiding buzzwords about innovation.

Pronounced: EE-dahn Gah-ZEET

BLUESKY · MASTODON · GITHUB · LINKEDIN

PREVIOUSLY

As a principal engineer at Heroku, I started the Data UX team, which crafted the human interfaces to Heroku’s data offerings (Postgres, Redis, Kafka, and Cassandra). Prior to that, I led the design of Heroku App Metrics, which visualized app performance while addressing customer complaints about the opacity of Heroku.

I am an alumnus of the Django Project core team, where I was a developer and lead designer for the framework. I delivered the keynote address at Djangocon US 2011, and designed visual identities for various PyCons and DjangoCons.

I was a founding mentor at Google Campus TLV, where I had the opportunity to help hundreds of startups distill

Interface text:
gazit.me
GitHub
AIEWF
Clear
New Tab
Schedule · AI Engineer...
One Developer, Two Do...
Repo Assist: Crunchi...
GitHub Agentic Workflo...
Idan Gazit
Astro
Agents · idan/gazit.me
[WIP] Create workflow f...
chore: upgrade astro to...
chore: upgrade astro to...
githubnext/agentics: A...
Home | GitHub Agentic...
Following — Bluesky
Ace
localhost:5173
New Arc Version Available

### Astro framework

Gazit’s personal site uses Astro. Its frequent releases keep him upgrading, often with code changes, so he wants an automation that can also handle breaking changes.

[5:01](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=301s) [Astro homepage describing its framework for content-driven websites.](https://assets.ai.engineer/sites/aiecode2025/sha256/90517d2ee6b5628e90a3557599f637557f2c131338f3bf1d6b155c9b0041f648.webp)

astro
Documentation  Blog  Resources  Community  Enterprise

Astro 7.0  Available now!

The web framework for content-driven websites

Astro powers the world's fastest marketing sites, blogs, e-commerce websites, and more.

Get Started
npm create astro@latest

Used by the largest companies around the world:
Google  Unilever  VISA  Microsoft  PORSCHE  OpenAI  netlify  NordVPN
CLOUDFLARE  NBC NEWS  The Guardian  MICHELIN  Proton  Webflow

What is Astro?

Interface text:
astro.build
GitHub
AIEWF
Clear
New Tab
Schedule - AI Engineer...
One Developer, Two Do...
Repo Assist: Crunchi...
GitHub Agentic Workflo...
Idan Gazit
Astro
Agents - idan/gazit.me
[WIP] Create workflow f...
chore: upgrade astro to...
chore: upgrade astro to...
githubnext/agentics: A...
Home | GitHub Agentic...
Following — Bluesky
Ace
localhost:5173
New Arc Version Available

### Creating an agentic workflow

A Copilot prompt supplies a workflow-creation document and asks for daily Astro release checks for the user's dependencies. If a release appears, it requests an upgrade plan addressing breaking changes and a PR.

[5:37](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=337s) [A GitHub agent prompt with the workflow-creation instruction highlighted.](https://assets.ai.engineer/sites/aiecode2025/sha256/4c40a64716831495a47ce622b244cc6f087ecb6f468bfa63071160bf5185f960.webp)

Sessions

Create a workflow for GitHub Agentic Workflows using https://raw.githubusercontent.com/github/gh-aw/main/create.md

Every day, check if there's a new release from astro for any of my dependencies. If yes, then look at the changelog as well as the "upgrading astro" docs. Come up with a plan for upgrading astro, including dealing with any breaking changes. And then create a PR with all the changes related to the upgrade.

- Changelog: https://github.com/withastro/astro/blob/main/packages/astro/CHANGELOG.md

Interface text:
refs/gh/queue/maste...  UI: e38a123b002...  github/copilot-mission-control  Feedback
1.9s  13.89KB  SSR  DR
Rails 8.2.0.alpha.343fe92bd2 | Ruby 4.0.5 | React 19.2.7
idan / gazit.me
Type / to search
Code  Issues 2  Pull requests 85  Agents  Actions  Security and quality 51  Insights  Settings
Created by me
Needs attention
All sessions
Auto
Configure
Memories
Customize environment
Give feedback
Get started with agents
Explain repository
Let the agent help you understand the codebase
Improve my workflow
Get tips based on my recent sessions
Create a plan
Plan before making changes to the codebase

### Astro upgrade request

The Copilot prompt asks for daily checks for new releases of Astro dependencies. When one appears, it requests an upgrade plan using the changelog and upgrade guide, followed by a PR.

[5:53](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=353s) [The prompt highlights instructions to check releases, plan upgrades and create a pull request.](https://assets.ai.engineer/sites/aiecode2025/sha256/6774dcb6de865995a4ccc8b95e82a8dc8f85e21a9bfde41e7262e69a292c939f.webp)

Create a workflow for GitHub Agentic Workflows using https://raw.githubusercontent.com/github/gh-aw/main/create.md

Every day, check if there's a new release from astro for any of my dependencies. If yes, then look at the changelog as well as the "upgrading astro" docs. Come up with a plan for upgrading astro, including dealing with any breaking changes. And then create a PR with all the changes related to the upgrade.

- Changelog: https://github.com/withastro/astro/blob/main/packages/astro/CHANGELOG.md
- Upgrading Astro guide: https://docs.astro.build/en/upgrade-astro/

Interface text:
Rails 8.2.0.alpha.343fe92bd2 | Ruby 4.0.5 | React 19.2.7
idan / gazit.me
Type / to search
Code  Issues 2  Pull requests 85  Agents  Actions  Security and quality 51  Insights  Settings
Created by me
Needs attention
All sessions
Auto
Get started with agents
Explain repository
Let the agent help you understand the codebase
Improve my workflow
Get tips based on my recent sessions
Create a plan
Plan before making changes to the codebase
Configure
Memories
Customize environment
Give feedback
is:open author:@me

### Astro upgrade workflow

Copilot produced a Markdown playbook that checks Astro dependencies and calls for an upgrade pull request if newer releases are available. The speaker says it identified those dependencies from the codebase.

[6:19](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=379s) [A pull request diff shows a Markdown workflow for checking Astro package releases.](https://assets.ai.engineer/sites/aiecode2025/sha256/39fb0fc1ddc2e4e921280c41dc861cf926c87cda3c8cf9e31dd48f6fea746a9a.webp)

[partly clipped] # Astro Upgrade Checker

You are an automated assistant that checks for new Astro releases and upgrades this Astro project when a newer version is available.

## Your Task

This repository is a personal website built with Astro. Check if any of the following Astro-related packages in `package.json` have newer releases available, and if so, upgrade them and create a pull request:

- `astro`
- `@astrojs/check`
- `@astrojs/mdx`
- `@astrojs/rss`
- `@astrojs/sitemap`

## Step 1: Check for New Releases

For each package listed above, check the latest published version via web-fetch

Interface text:
#34 [WIP] Create workflow for upgrading Ast...
copilot/check-for-releases-and-upgrade
Submit comments
Groups by Copilot
All files
Astro upgrade workflow
Lockfile merge config
Filter files...
.github/workflows
astro-upgrade.lock.yml
astro-upgrade.md
.gitattributes
All commits
0 / 3 viewed
.github/workflows/astro-upgrade.md
+88
Viewed

### Astro upgrade checker task

The Markdown workflow checks five Astro packages and calls for upgrades and a pull request if newer releases are available. The speaker says Copilot inferred the dependencies from the codebase.

[6:30](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=390s) [GitHub workflow diff describing an automated Astro upgrade checker and its target packages.](https://assets.ai.engineer/sites/aiecode2025/sha256/129312c59a762aba2cf9b730c132db75f000e59efa92c6271317cfecf00edab1.webp)

# Astro Upgrade Checker

You are an automated assistant that checks for new Astro releases and upgrades this Astro project when a newer version is available.

## Your Task

This repository is a personal website built with Astro. Check if any of the following Astro-related packages in `package.json` have newer releases available, and if so, upgrade them and create a pull request:

- `astro`
- `@astrojs/check`
- `@astrojs/mdx`
- `@astrojs/rss`
- `@astrojs/sitemap`

## Step 1: Check for New Releases

Interface text:
#34 [WIP] Create workflow for upgrading Ast...
copilot/check-for-releases-and-upgrade
Submit comments
Groups by Copilot
All files
Astro upgrade workflow
Lockfile merge config
Filter files...
.github/workflows
astro-upgrade.lock.yml
astro-upgrade.md
.gitattributes
All commits
0 / 3 viewed
.github/workflows/astro-upgrade.md
+88
Viewed

### Checking for new releases

Copilot inferred the Astro dependencies to check from the codebase. The workflow queries npm for their latest releases and compares them with the current version constraints.

[6:34](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=394s) [GitHub workflow diff listing npm registry checks for Astro packages.](https://assets.ai.engineer/sites/aiecode2025/sha256/f19d70c0c2eae6f125d9be0c0dfb63b3b95099dc228017aba801d5f2424ed1e2.webp)

## Step 1: Check for New Releases

- `@astrojs/check`
- `@astrojs/mdx`
- `@astrojs/rss`
- `@astrojs/sitemap`

For each package listed above, check the latest published version via web-fetch from the npm registry:
- `https://registry.npmjs.org/astro/latest`
- `https://registry.npmjs.org/@astrojs%2Fcheck/latest`
- `https://registry.npmjs.org/@astrojs%2Fmdx/latest`
- `https://registry.npmjs.org/@astrojs%2Frss/latest`
- `https://registry.npmjs.org/@astrojs%2Fsitemap/latest`

(Use `%2F` to URL-encode the `/` in scoped package names.)

Compare the latest published version of each package against the current version constraint in `package.json`. If the latest version is greater than or equal to the current constraint's minimum version AND represents a new release

Interface text:
#34 [WIP] Create workflow for upgrading Ast...
copilot/check-for-releases-and-upgrade
Submit comments
Groups by Copilot
All files
Astro upgrade workflow
Lockfile merge config
Filter files...
.github/workflows
astro-upgrade.lock.yml
astro-upgrade.md
.gitattributes
All commits
0 / 3 viewed
.github/workflows/astro-upgrade.md
+88
Viewed

### Build and pull request instructions

Copilot expanded a short request into an upgrade playbook: build the project, fix errors, and create a pull request summarizing the upgrade and breaking changes.

[6:48](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=408s) [GitHub workflow diff instructing the agent to build the project and create a pull request.](https://assets.ai.engineer/sites/aiecode2025/sha256/738f51090d7084d61893fe6edf04feb8692324e17cb9f9a41ac0faa94eb010e8.webp)

4. **Run the build** to verify the upgrade works: `pnpm install && pnpm run build`
   - Fix any build errors that arise from breaking changes
   - If there are TypeScript errors, fix them too
5. **Update `pnpm-lock.yaml`** by running `pnpm install` (this happens automatically when you run the command above)

## Step 4: Create a Pull Request

Once all changes are applied and the build succeeds, create a pull request with:
- **Title**: `chore: upgrade astro to vX.Y.Z` (using the new astro version)
- **Body**: Include:
  - A summary of what was upgraded and to which versions
  - Key highlights from the changelog for the new version(s)
  - A list of any breaking changes that were addressed

Interface text:
#34 [WIP] Create workflow for upgrading Ast...
copilot/check-for-releases-and-upgrade
Submit comments
Groups by Copilot
All files
Astro upgrade workflow
Lockfile merge config
Filter files...
.github/workflows
astro-upgrade.lock.yml
astro-upgrade.md
.gitattributes
All commits
0 / 3 viewed
.github/workflows/astro-upgrade.md
+88
Viewed

### Workflow guardrails

The workflow’s YAML front matter sets read permissions, allowed network destinations and safe outputs. It permits at most one pull request or no action, limiting the noise an unattended agent can create.

[7:09](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=429s) [GitHub workflow front matter specifying a weekday schedule, read permissions, allowed tools, safe outputs, and network access.](https://assets.ai.engineer/sites/aiecode2025/sha256/7576ff0219573d528120a77af6deead772750217397360f08067bacc649a4447.webp)

---
on:
  schedule: daily on weekdays
permissions: read-all
tools:
  web-fetch:
safe-outputs:
  create-pull-request:
    max: 1
  noop:
network:
  allowed:
    - defaults
    - node
    - github
    - docs.astro.build
---

# Astro Upgrade Checker

Interface text:
#34 [WIP] Create workflow for upgrading Ast...
copilot/check-for-releases-and-upgrade
Submit comments
Groups by Copilot
All files
Astro upgrade workflow
Lockfile merge config
Filter files...
.github/workflows
astro-upgrade.lock.yml
astro-upgrade.md
.gitattributes
All commits
0 / 3 viewed
.github/workflows/astro-upgrade.md
+88
Viewed

### Astro upgrade pull request

The speaker’s automation produced an Astro upgrade pull request with a tailored summary of changes from 5.10.1 to 5.18.0, including performance, security and bug fixes.

[8:57](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=537s) [GitHub pull request showing package version changes and highlights for an Astro upgrade.](https://assets.ai.engineer/sites/aiecode2025/sha256/d1f8a43e3fcb94bfdfd04816c2fe0807f6af2e661d9ab50596097e60d840c62b.webp)

@astrojs/check  ^0.9.4  ^0.9.6
@astrojs/mdx  ^4.3.0  ^4.3.13
@astrojs/rss  ^4.0.12  ^4.0.15
@astrojs/sitemap  ^3.4.1  ^3.7.0

Highlights (5.10.1 → 5.18.0)

This is a patch/minor upgrade within the 5.x series. Key improvements include:

• Performance: .astro component SSR rendering performance improved by up to 2x (5.18.x)
• Security: Server Islands slots now encrypted before transmission; middleware URL-encoded path normalization to prevent bypass attacks
• Bug fixes: Font flash (FOUT) during ClientRouter navigation fixed; fixes for image handling, i18n fallback, and hydration of framework components in MDX
• Content Layer: New retainBody option for the glob() loader to reduce data store size; async parser() support for the file() loader
• Sharp image service: New kernel config option to select the resize algorithm
• Cookies: New partitioned cookie option for cross-site partitioned cookies
• Google Icons: Added as a built-in font provider in the experimental Fonts API
• Data URIs: Explicit authorization now required for remote image data URIs

Breaking Changes

Interface text:
#38 chore: upgrade astro to v5.18.0
chore/upgrade-astro-5.18.0-629db095ab508f5d
Submit review
No one—assign yourself
Labels
None yet
Projects
None yet
Milestone
No milestone
Development
Successfully merging this pull request may close these issues.
None yet
Notifications
Customize
Unsubscribe
You’re receiving notifications because you’re watching this repository.
0 participants

### Deployment preview

Cloudflare reports a successful preview deployment, while GitHub’s panel says the branch has no deployments. Gazit opens the preview to check that the Astro upgrade hasn't changed his site.

[9:18](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=558s) [A deployment bot reports a successful preview deployment; a separate panel below says the branch has not been deployed.](https://assets.ai.engineer/sites/aiecode2025/sha256/89c2f7a4014a50a632b59b2cf501dcb289a55330b8c77cc12f606e3b7c0d8dee.webp)

Deploying gazit-me with Cloudflare Pages

Latest commit: bc42ee2
Status: ✅ Deploy successful!
Preview URL: https://bfd4e184.gazit-me.pages.dev
Branch Preview URL: https://chore-upgrade-astro-5-18-0-6.gazit-me.pages.dev

View logs

This branch has not been deployed
No deployments

Interface text:
#38 chore: upgrade astro to v5.18.0
chore/upgrade-astro-5.18.0-629db095ab508f5d
Submit review
cloudflare-workers-and-pages Bot commented on Feb 25 · edited

### Website preview

Idan opens the deployment preview after a minor Astro upgrade and checks that his personal site still looks and works as before.

[9:25](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=565s) [A purple personal website with an illustrated portrait and biography.](https://assets.ai.engineer/sites/aiecode2025/sha256/7ecf7532acd68af7604e7d7e12e5fc7d1b51ace8d567abda2e15489a0223e387.webp)

IDAN GAZIT MAKES THINGS FOR PEOPLE WHO MAKE THINGS.

Hello!

I’m a hybrid and a maker; one part developer, one part designer. I’ve spent my career working on creative tools and platforms. I’m a big believer in the web, and I often nerd out about typography, data visualization, and electronics.

I lead GitHub Next: the team which created GitHub Copilot, the first widely-adopted application of generative AI. Mostly, this job is about improving the lives of developers while avoiding buzzwords about innovation.

Pronounced: EE-dahn Gah-ZEET

BLUESKY · MASTODON · GITHUB · LINKEDIN

PREVIOUSLY

As a principal engineer at Heroku, I started the Data UX team, which crafted the human interfaces to Heroku’s data offerings (Postgres, Redis, Kafka, and Cassandra). Prior to that, I led the design of Heroku App Metrics, which visualized app performance while addressing customer complaints about the opacity of Heroku.

I am an alumnus of the Django Project core team, where I was a developer and lead designer for the framework. I delivered the keynote address at Djangocon US 2011, and designed visual identities for various PyCons and DjangoCons.

I was a founding mentor at Google Campus TLV, where I had the opportunity to help hundreds of startups distill

### Astro upgrade pull request

The pull request upgrades Astro from 5.18.0 to 7.0.5, crossing two major versions. The speaker says the automation updated broken code and verified the build.

[9:36](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=576s) [A GitHub pull request describing an Astro upgrade, with a package comparison table.](https://assets.ai.engineer/sites/aiecode2025/sha256/e3af0f0793bb9d38f91d362994df7f3a8d3b56120e1049225dd4ac48895e22b5.webp)

chore: upgrade astro to v7.0.5 #120

Open · github-actions[bot] · main ← chore/upgrade-astro-v7-32e041817df23ae9 · +1,255 -941

github-actions Bot commented 17 hours ago · Contributor

Upgrades Astro and all official Astro integrations to their latest versions.

Packages upgraded
Package | From | To
astro | ^5.18.0 | ^7.0.5

Reviewers
Copilot · Request
Still in progress? Convert to draft

Assignees
No one—assign yourself

Labels

Interface text:
refs/gh/queue/maste… · UI: 01e81ad920b… · github/pull_requests · Feedback · Rails 8.2.0.alpha.343fe92bd2 · 633ms · 97.11KB · SSR · DR
Ruby 4.0.5 | React 19.2.7
idan / gazit.me
Type / to search
Code · Issues 2 · Pull requests 85 · Agents · Actions · Security and quality 51 · Insights · Settings
Submit review
Overview · Conversation 2 · Findings · Commits 1 · Checks 1 · Files changed 4

### Upgrade changelog highlights

The pull request explains the jump from Astro 5 to 7 by listing changes in both major releases, including a new compiler and Markdown processor, and noting their effects on this project.

[9:46](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=586s) [A pull request lists Astro 7 and Astro 6 upgrade highlights.](https://assets.ai.engineer/sites/aiecode2025/sha256/a78a8495effad28108acf0b28de3de468b14f88e9a485d119db76896f586ba44.webp)

@astrojs/rss  ^4.0.15  ^4.0.19
@astrojs/sitemap  ^3.7.0  ^3.7.3

Key highlights from the changelog

Astro v7.0 (major)

• Vite v8: Upgraded internal bundler/dev server to Vite 8
• Rust compiler: The Rust-based compiler is now the default (replaces Go-based compiler) — faster builds and stricter HTML validation
• New default Markdown processor: Sätteri is now the default processor; remark/rehype pipeline is optional via @astrojs/markdown-remark (this project does not use remark plugins, so no action needed)
• compressHTML: 'jsx': Default whitespace compression changed to JSX rules — visually inspect inline elements if needed
• Advanced routing enabled by default: src/fetch.ts is now a reserved file name (this project does not have one)
• Background dev server: astro dev now auto-detects AI agent environments and starts in background mode

Astro v6.0 (skipped major, also required)

• Node 22 required: Dropped Node 18/20 support (CI already uses Node 22)
• Vite v7 (internal)

Interface text:
#120 chore: upgrade astro to v7.0.5
chore/upgrade-astro-v7-32e041817df23ae9
Submit review
Projects
None yet
Milestone
No milestone
Development
Successfully merging this pull request may close these issues.
None yet
Notifications  Customize
Unsubscribe
You’re receiving notifications because you’re watching this repository.
1 participant
Lock conversation

### Content Layer migration

The upgrade moves the content configuration, replaces the legacy collection type with a glob loader, and updates imports. The pull request reports a build with 0 errors and 0 warnings.

[9:53](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=593s) [A pull request shows Content Layer API migration steps, a code diff, and a successful build report.](https://assets.ai.engineer/sites/aiecode2025/sha256/6e32cea01c3dbf12a91d4964be23e4d47515b88e0880a93727e821ce09998765.webp)

Breaking changes addressed

Content Layer API migration (v6 requirement)

The legacy src/content/config.ts with type: 'content' collections is no longer supported in v6+. Migrated to the new Content Layer API:

• Moved src/content/config.ts → src/content.config.ts
• Replaced type: 'content' with loader: glob(...) from astro/loaders
• Updated z import from deprecated astro:content re-export to astro/zod

-import { defineCollection, z } from 'astro:content';
+import { defineCollection } from 'astro:content';
+import { z } from 'astro/zod';
+import { glob } from 'astro/loaders';

 const projects = defineCollection({
-  type: 'content',
+  loader: glob({ pattern: '**/*.{md,mdx}', base: './src/content/projects' }),
   schema: z.object({ ... }),
 });

Build verification

Build passes with pnpm run build (astro check && astro build) — 0 errors, 0 warnings.

Interface text:
#120 chore: upgrade astro to v7.0.5
chore/upgrade-astro-v7-32e041817df23ae9
Submit review

### Build verification and manual steps

The upgrade report shows a passing build with 0 errors and 0 warnings. It asks the owner to inspect inline whitespace after deployment because the compressHTML default changed.

[10:02](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=602s) [A pull request reports a successful build and lists manual site inspection steps.](https://assets.ai.engineer/sites/aiecode2025/sha256/3ca90712cc5e4fc4029db840075e6ead4ef5082ca799098ae91220e796a1e58a.webp)

const projects = defineCollection({
-  type: 'content',
+  loader: glob({ pattern: '**/*.{md,mdx}', base: './src/content/projects' }),
   schema: z.object({ ... }),
});

Build verification

Build passes with pnpm run build (astro check && astro build) — 0 errors, 0 warnings.

Manual steps for the repo owner

• Visually inspect the site after deployment to ensure whitespace between inline elements renders correctly (due to compressHTML: 'jsx' default change). If any spacing looks off, add explicit {" "} between affected inline elements, or set compressHTML: true in astro.config.mjs to restore the old behavior.
• No remark/rehype plugins are used in this project, so the Markdown processor change requires no action.

Generated by Astro Upgrade Checker

Interface text:
#120 chore: upgrade astro to v7.0.5
chore/upgrade-astro-v7-32e041817df23ae9
Submit review

### The Agentics: Maintainer Workflows

The Agentics offers reusable starting points: Issue Triage labels issues and pull requests, Repo Assist handles maintenance tasks, and AI Moderator detects spam and AI-generated content.

[10:19](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=619s) [GitHub README introducing reusable workflows, including Issue Triage, Repo Assist, and AI Moderator.](https://assets.ai.engineer/sites/aiecode2025/sha256/5c2b082408654590f8306e4a665d6d18809455c90ed1fd982e765301d14702d2.webp)

✨ The Agentics

A sample family of reusable GitHub Agentic Workflows.

📁 Available Workflows

Maintainer Workflows

Make software maintenance enjoyable! From basic issue triage to Repo Assist - a powerful triage multi-task backlog burner, issue labeller, bug fixer and general repository assistant. Other workflows help gate your repository.

• 🏷️ Issue Triage - Triage labelling of issues and pull requests and not much more
• 🤖 Repo Assist - A regular, pervasive all-tools repository assistant that triages issues, investigates issues, replies with comments, fixes bugs, proposes engineering improvements, and maintains activity summaries
• 🛡️ AI Moderator - Automatically detect and moderate spam, link spam, and AI-generated content

Fault Analysis Workflows

Interface text:
README
Code of conduct
MIT license
Security
Packages
No packages published
Publish your first package
Contributors 29
+ 15 contributors
Languages
Makefile 100%

### Fault Analysis Workflows

The workflow library includes Repo Assist for maintenance and CI Doctor for investigating failed CI runs. The speaker describes Repo Assist as a group of workflows that work together to find fixes and identify issues needing follow-up.

[10:54](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=654s) [GitHub README listing maintainer workflows and fault analysis tools including CI Doctor, CI Coach, and Cost Tracker.](https://assets.ai.engineer/sites/aiecode2025/sha256/f2570c5f7318d0aee972ee7349eae7e89429818f44fef3111d00ca9acc5f4a1c.webp)

Maintainer Workflows

Make software maintenance enjoyable! From basic issue triage to Repo Assist - a powerful triage multi-task backlog burner, issue labeller, bug fixer and general repository assistant. Other workflows help gate your repository.

• 🏷️ Issue Triage - Triage labelling of issues and pull requests and not much more
• 🤖 Repo Assist - A regular, pervasive all-tools repository assistant that triages issues, investigates issues, replies with comments, fixes bugs, proposes engineering improvements, and maintains activity summaries
• 🛡️ AI Moderator - Automatically detect and moderate spam, link spam, and AI-generated content

Fault Analysis Workflows

Investigate faults proactively and improve CI.

• 🏥 CI Doctor - Monitor CI workflows and investigate failures automatically
• 🚀 CI Coach - Optimize CI workflows for speed and cost efficiency
• 💰 Cost Tracker - Post per-run agent spend summaries on pull requests using token-usage.jsonl from gh-aw's firewall
• 🔍 Log Watcher - Diagnose agent run failures by scanning logs for errors, retry loops, rate limits, and token anomalies, then posting a health report on the associated PR or

Interface text:
README
Code of conduct
MIT license
Security
+ 15 contributors
Languages
Makefile 100%

### Research, Status and Planning Workflows

The README groups repository loops alongside research and daily status workflows. The speaker also describes internet research and ticket summaries as automation for product managers.

[11:25](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=685s) [GitHub README listing loop engineering, research, and repository status workflows.](https://assets.ai.engineer/sites/aiecode2025/sha256/07d1e69d0e292428ecbc1db8a80cfc0bfcad8a6638d63af97bf528e7a2fb582c.webp)

[illegible] conventions, and subtle improvements
• 🔍 Contribution Check - Regularly review batches of open PRs against contribution guidelines and create prioritized reports
• ✅ Contribution Guidelines Checker - Review pull requests for compliance with contribution guidelines

Research, Status & Planning Workflows

Loop Engineering
• 🔄 Autoloop - Loop anything in your repo to continuously research, develop and maintain
• 🎯 Goal - Loop Engineering on top of Agentic Workflows
• 🏗️ Crane - Build and operate repository loops with composable loop infrastructure

Research, Status & Planning
• 📚 Weekly Research - Collect research updates and industry trends
• 📊 Weekly Issue Activity - Weekly issue activity report with trend charts and recommendations
• 👥 Daily Repo Status - Assess repository activity and create status reports
• 👥 Daily Team Status - Create upbeat team activity summaries with productivity insights
• [illegible] Repository Chronicle - Transform repository activity into an engaging [illegible]

Interface text:
README
Code of conduct
MIT license
Security
github.com/githubnext/agentics/blob/main/docs/team-status.md

## Full transcript

[0:00](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=0s) [upbeat music] We're gonna start one minute early, which gives me one extra minute, and then anybody who came on time is, uh, gonna miss the super enthralling introduction.

[0:22](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=22s) Hi, my name's Idan. Nice to meet you all. Uh, I lead GitHub Next, which is the labs team of GitHub. I like to call us the Department of Fool Around and Find Out, but I usually don't say the word fool.

[0:36](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=36s) We're the team that created Copilot, uh, and pioneered a ton of areas since then, right? Uh, spec-based programming, natural language to app, lots more. Not everything, uh, that we do turns into a finished product.

[0:47](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=47s) Our job is to sort of explore the future and scout it out. Um, but our job is to reach for the GitHub that's gonna be next year, maybe not tomorrow's GitHub, but, uh, the tools that we're all going to use to make software a year from now, two years from now.

[1:03](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=63s) That's pretty hard, 'cause my crystal ball barely works into, uh, next week. Uh, and we're really fortunate that we get to do most of our work in the open, so you can check out githubnext.com and our socials, which we occasionally remember to post stuff to.

[1:18](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=78s) And what we do isn't really research, right? Because the only way to know what's gonna be good, uh, is to make stuff. So we make a lot of stuff, and the hard part about being an undirected research team is always the question of, what's worth our time?

[1:34](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=94s) Even if you're a token billionaire, uh, even if you have ten terminals running Fable night and day, then opportunity cost is, is still there. It's everything. Uh, so if in, in a world where the, uh, marginal cost of a line of code is approaching zero, uh, and AI can help us to think and to make, what do

[1:55](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=115s) we make, right? How do we even choose what's important, uh, when the market is super noisy and the tech changes every week? Um, and this isn't even really a Next problem anymore.

[2:06](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=126s) This is an all of us problem now. Uh, we're all labs teams now. Uh, and the way that Next thinks about this stuff is to look for durable themes, things that will be true no matter what, uh, the technology is tomorrow.

[2:20](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=140s) And I think that the theme of this moment, uh, uh, is very much an evergreen one, right? It's AI started with a surge of personal productivity, right? The LLMs completed what I type, and the agents go fetch me the thing that I need.

[2:35](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=155s) And now I have many agents helping me to parallelize myself, but the greatest value doesn't come, uh, from multiplying me into more me. Uh, it comes from enabling groups of people to do more.

[2:47](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=167s) That's always been true. And we're thinking about how to accomplish that through two lenses. Every industrial revolution, uh, came about through automation, right? It's funny to think about our giant software industry as being pre-industrial, but on some level it is, because until now, the only automations that we had were heuristics, like make sure there's a semicolon at

[3:09](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=189s) the end of every line. Um, but now AI can help us to automate things that require some amount of basic judgment and intelligence. And there's no magic trick to making great software, right?

[3:19](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=199s) It costs time. Uh, and we can buy that time by automating away the things that we used to need to do manually. Like, the more we automate, the more time we have to spend on craft or on our product or on making it really good or on features, right?

[3:35](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=215s) Either you hire more people, or you automate away part of what your people are currently doing in order to spend that time. Uh, and at the same time, how are we gonna work together, right?

[3:44](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=224s) How does collaboration look like in the future? Whoops. Oh, well, sorry about that. Um, yesterday, uh, Geoffrey Litt talked about understanding being the bottleneck, and that's very true at a me level.

[3:56](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=236s) Uh, but my personal understanding was never sufficient for shipping code inside a team, right? Our understanding at an us level can only happen at the end of the process.

[4:07](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=247s) Um, sorry, uh, uh, uh, it can't only happen at the end of the process, uh, when the process happens so much faster. So going faster means that a small misalignment, uh, can snowball into a ton of wasted work, uh, and that work costs tokens, and tokens cost real money now, so, uh, on top of the time that

[4:28](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=268s) you're misspending. So today, I'll give you a quick tour of two prototypes that we're working on at GitHub Next in each of these themes. Agentic Workflows is our take...

[4:37](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=277s) Why is that not there? Oh, I had to click again. Uh, Agentic Workflows is our take on how automations should work in an agentic world, and Ace is a prototype that explores what real-time multiplayer software development looks like.

[4:50](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=290s) So I'll start by showing off Agentic Workflows, and it requires me doing this. Okay, cool. Uh, this is my personal website. Not that interesting. I'm showing it to you.

[4:59](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=299s) This is like Chekhov's gun. We're gonna see it again later. Um, and my personal website is built with this framework called Astro. Astro is a great web framework. The greatest part about it is that they release, like, fifty things a month, which means that I'm constantly on the upgrade treadmill.

[5:12](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=312s) And there's a great GitHub product called Dependabot, which notifies me when my stuff is out of date. Um, but the problem is, is that when I do these upgrades, I frequently need to make code changes.

[5:23](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=323s) So what I really want is a kind of super Dependabot that's always there, automatically looking in the background at my dependencies and figuring out how to upgrade me, including the code changes, the breaking changes.

[5:33](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=333s) Um, and because I'm lazy, and I like not doing work, um, I used Copilot, uh, to create an agentic workflow. And there's this magic line up top where I supply effectively a skill, saying like, "Hey, create an agentic workflow.

[5:47](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=347s) Here's a document that tells you everything you need to know about that." Uh, and then what comes below that is something a lot like a Slack message that I'd send to a junior developer on my team.

[5:57](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=357s) Like, "Every day, I want you to check if there's a new release, look at the change log, look at the docs, come up with a plan for the upgrade, uh, and then create a PR with the thing, and here's the links to the docs."

[6:08](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=368s) Right? This is like a message that I would send to somebody on my team. Go write a playbook. And when I, uh, went and created this, it did go and create a playbook.

[6:16](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=376s) In fact, that's what Agentic Workflows kind of look like. They look like Markdown documents. Like, if GitHub Actions and Copilot had a baby together, uh, and it ran on Markdown, this is what it is.

[6:27](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=387s) So what does this, uh, uh, uh, Agentic Workflow look like? Well, you know, it's, uh, an upgrade checker. It's got my tasks. Step one, check for new releases. Again, because it sees my code base, it was able to infer what it even needs to check, and it actually found these specific dependencies.

[6:44](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=404s) Review the change log and the upgrade guide, apply the upgrade, uh, and then create a pull request, right? I didn't ask for any of this that explicitly, but it turns out that Copilot's pretty good at sussing out my little three-line message into a full playbook.

[6:59](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=419s) And then at the top, I've got this special section. This is the, uh, what we're calling... Oop, no, don't collapse it. Oh, man.

[7:08](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=428s) Scrolling is wonky when you zoom in. Uh, this YAML front matter. This is where we stick the guardrails, 'cause if we're gonna be not supervising agents doing things, then we're gonna need much stronger guardrails around what they're allowed to do, what they're allowed to read, what they're allowed to write, uh, and where are we gonna specify that?

[7:26](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=446s) And it's not enough to just prompt the agent and be like, "Listen, bro, I don't want you to buy Bitcoin for me ever." That's not enough, 'cause somebody else can prompt inject the agent and take it in a direction that you don't expect.

[7:37](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=457s) So any of the guardrails, if you're prompting the guardrails at the agent, you're effectively letting the fox loose in the henhouse. It's not actually a guardrail. Um, so here, uh, you can see that I'm specifying deterministically, like, my permissions are read-all, what tools am I allowed to use, uh, what network, uh, requests is it allowed to

[7:59](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=479s) make. It's not allowed to just go to bitcoin.com or whatever. Uh, in fact, it's only allowed to go to some specified set of default websites, the npm ecosystem, 'cause it's gotta check for, like, you know, what's new, GitHub, and of course, the Astro docs, which I specified in my original prompt.

[8:15](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=495s) Um, and I've got this block called safe-outputs, which is basically saying, these are the only things that the agent is allowed to write. And so I'm saying, in this case, the agent is a- allowed to create-pull-request.

[8:26](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=506s) Pull request, single, uh, because I don't want the agent to get prompt injected to create five hundred pull requests. That would be a denial of service. Um, or, and this is the other thing I explicitly said, you're allowed to do nothing, right?

[8:39](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=519s) Which sounds silly, but it actually matters because in a world where I have lots of automations, the last thing I want is noise. I don't want the agent's denial of servicing me.

[8:48](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=528s) So okay, I've created this and I've run it, and this is actually my actual automation on my actual personal website. I didn't ask for any of this, but it did a pretty good job of, like, saying, "Hey, here's the highlights of what you get from going from this version that you're currently on to the version that is

[9:04](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=544s) the target," right? It's read all of the release notes in the middle. This is normally what I would do as a human. Uh, and it's built me, like, you know, sort of like a tailored description.

[9:13](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=553s) It's figured out there's no breaking changes. It's actually verified this by running and building my project. And because I happen to have this deployed to Cloudflare, um, or whatever, anything with preview deploys, I can click that open and see that nothing has changed in my website, which is exactly what I want, right?

[9:28](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=568s) Like, it's done the upgrade, and I see that it still works exactly as it did before. But this was, like, a minor point release. That doesn't really count. Let's look at a major upgrading change.

[9:38](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=578s) And actually, I'm lucky that Astro just released Astro 7, because this is actually jumping two major revisions from 5 to 7. And so now it's saying like, okay, Astro 7 has brought me all of these things, and Astro 6 would've brought me all of that stuff, but I neglected to do the upgrade so I could have a

[9:55](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=595s) cool demo for you all. Uh, and it's found all of the code changes that were broken, and it updated them. Uh, it also, uh, verified that the build runs, and it also highlighted manual steps, uh, that things that I would need to do later.

[10:10](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=610s) Um, uh, and again, you know, if I go down here and I click on this, I can see, hey, still works. So cool. Now, uh, it's just Markdown. It's easy to iterate on that Markdown, right?

[10:23](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=623s) If you don't like the way that the automation works, just edit the English. It gets recompiled into an Actions workflow. Like, the Markdown is the source code. The YAML is like a compiled artifact.

[10:33](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=633s) You never look at it. Um, but we've also given you a whole library of Agentic Workflows for you to use as a starting point to customize. So an issue triager.

[10:43](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=643s) Internally, GitHub has actually used this as the basis for, like, spiking out our own internal issue triager or for, like, hunting down N+1 queries in our, like, monolith or all kinds of things.

[10:53](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=653s) There's a ton of things that are super helpful that way. Repo Assist, this is actually a swarm of, uh, uh, Agentic Workflows that work together to help you maintain your project by finding low-hanging fruit, fixing them, identifying tickets that need nudging or feedback that you need from people who have filed issues, whatever.

[11:12](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=672s) CI Doctor, how many times have you responded to a busted CI run by just running it again? All of us. Anybody who hasn't raised their hand is lying. Uh, uh, a, a million more, like, you know, goals, sure, uh, daily team status and repo status.

[11:28](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=688s) If I want this to go do, like, homework on the internet, I can. So this is not just for engineers. This is also for product managers whose job it is to look at information over here and summarize those tickets over there, right?

[11:39](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=699s) We can start to get everybody involved in automation. That's how you actually get industrial scale.

[11:46](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=706s) Uh, so, uh, that's Agentic Workflows. Um, the security guardrails, we have sort of four principles that we believe, uh, everybody should burn into their brains. Uh, defense in depth, one layer is never enough.

[12:00](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=720s) Uh, that was always true. Never trust agents with secrets. If an agent can know a secret, that secret, you need to treat it as if it's already been compromised, um, because you have no idea whether or not somebody's injected the agent to reveal that secret somewhere else.

[12:14](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=734s) So if an agent can see the secret, um, it's bad. In Agentic Workflows, the secrets are all kept outside of the agent's jail, and when the agent wants to-

[12:23](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=743s) Use the secret to call something, it needs to ask the warden, "Hey, Mother May I? Please go talk to that service." Uh, stage and vet all writes just so that it's auditable, and log everything just so that it's auditable.

[12:35](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=755s) Uh, and when we give this to existing projects like the Home Assistant project, which is a huge open source project, um, the first, uh, agentic workflow they built was something that looks at every submitted issue, walks the Python stack trace to figure out if the bug is in first party code or third party code, closes the issue

[12:53](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=773s) if it's not their issue, right? That's something that was not possible before AI, not possible with heuristics, uh, but is possible now.

[13:01](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=781s) Agentic Workflows is in public preview today. You can go and kick the tires. So go ahead, go wild. Uh, we actually believe that this is gonna be a bigger category than interactive AI because automations that run in the background while you sleep, that's the ball game.

[13:17](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=797s) Okay, so let's talk about the collaboration piece. So this is how we've always built software, right? Because the cost of writing code was so high, uh, but that's not true anymore.

[13:27](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=807s) We would plan and review together, but the building part was done alone. Like, you know, illuminated by the light of my monitor, uh, I would build. But now none of it is alone, right?

[13:35](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=815s) Planning isn't before, and review isn't after. We iterate on the direction together, and AI takes a step, and then we iterate more in the direction. So what's an interface that makes sense for that style of development?

[13:48](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=828s) I'm only slightly trolling, right? Slack was designed to be better, uh, than email for the average office worker. It was never designed for making software or the needs of everyone involved in that.

[14:00](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=840s) But what this is good for is surfacing all the facts that are not in code. Anything that's in code, any fact that's in code, the agents can figure out by reading the code.

[14:08](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=848s) What's left are the things that are not in code, like political considerations. Like, A, if we do it that way, that VP over there is gonna vibe with that direction.

[14:16](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=856s) Or like, we should make it purple because that's their favorite color. Or we get a really sweet deal, uh, on infrastructure from Azure, therefore we should be building on Azure, not on, uh, GCP or AWS.

[14:28](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=868s) Whatever. But the biggest win is the same one that we've already seen over and over, right? I don't email Word documents around anymore. I create and collaborate in the same surface, in the same place.

[14:40](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=880s) This is coming for code a trillion percent, right? So let me show you what we have here. Oop, here we go. I gotta find the tab. All right. Uh, this is Ace.

[14:52](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=892s) Let's switch to the repository. So Ace looks an awful lot like Slack, right? And over here on the left, I've got sessions, and I can create new ones. And, you know, so far this kinda looks like every other conductor-like product out there.

[15:05](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=905s) Um, the difference being is that every one of these is not on my machine. In fact, none of this is running on my machine. It's all microVMs in the cloud.

[15:12](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=912s) So every session is just a branch of my repo checked out to a spot in the cloud. Uh, and I can create them and do stuff in them, and talk with my teammates.

[15:20](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=920s) So like, uh, "Hey, um, uh, what's your favorite color?" Right? Uh, and meanwhile, I'm gonna like install my dependencies, and then when that's done, I'm gonna do like, uh, bun dev.

[15:36](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=936s) I'm gonna run the dev server. Um, and here, like Russ and I are having a discussion like, "Are you sure? Maybe,

[15:46](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=946s) uh, maybe green is calmer." Um, oh, nope, I sent that as a terminal command. Good job, me. Um, I do not want that as a thing. Great. I'll do it like this.

[15:57](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=957s) Uh, and I can open up my preview. Whoops. Give me a preview. I'd like a browser preview. Okay. So, so far, not that different from developing with any sort of like multiplayer tool.

[16:09](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=969s) And here I've got this sort of calm Hacker News thing. I've just had a whole discussion with my teammate. I don't wanna turn around and now like emit those instructions again.

[16:17](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=977s) Instead, I just wanna be like, "Yo, Ace, do it." Uh, and because it sees the entire backscroll of my conversation with my peers, with my team, it's able to act on that, uh, uh, on, on that chat history.

[16:32](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=992s) And if the Wi-Fi was nice, then it would be doing it faster. Um, but you're gonna have to trust me on this because I don't have enough time to wait for this, that it's going to just respond to the fact that we had a discussion about colors.

[16:43](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1003s) And AI is also really good at fishing out that final state. Like very frequently, what do engineering conversations sound like? They sound like, like, "Hey, we should try it this way.

[16:52](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1012s) No, wait, I thought of like an edge case. We should actually do it that way. Let's go back to the first idea," right? But instead of me sort of like figuring, teasing out that final state from that long conversation, I can just let AI do it, and it'll figure it out.

[17:06](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1026s) So I don't need to work for the robots. And sometimes we have things that are a lot more, um, complicated. Like here, I wanted to add selectable timeframes to my app, and so I asked it to make a plan, and that plan comes as a, uh, Markdown document.

[17:21](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1041s) Uh, but this Markdown document is not just for me to look at and edit, it's for us to look at and edit together. So Russ is somewhere, uh, here in this document and like, you know, maybe he thinks that we should add an all time, and I'm gonna get rid of the today, and here I can again

[17:38](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1058s) do like, uh, we've updated the plan. Do it. Um,

[17:45](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1065s) uh, uh, and it'll just respond to the plan that we've edited together. And as we see now, we're moving to this future where, uh, more and more of the work that we're doing with AI results in documents like Markdown documents in a docs folder that capture sort of the truth.

[18:01](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1081s) And maybe more and more in the future we're gonna be editing those documents as the way that we do development. Like in order to change something about my application, I'm gonna edit a document and I'm gonna tell AI, "Hey, make the document true."

[18:16](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1096s) So this shared document editing is not just like, oh, nice to have. Maybe this is actually sort of the, uh, interface that we like to work in. But there's also the, uh, social coding aspect.

[18:28](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1108s) Right? Like, if I'm working with other people on my team. Um, remember when that was a thing that was a tagline under the GitHub logo? Um, so, uh, how can it help me stay up to date with what everybody else on my team is working on?

[18:42](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1122s) Like, it's not just enough to have, like, real-time multiplayer. I also wanna be ambiently aware of what everybody's going, going on about. So Krzysztof is working on VM tooling.

[18:50](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1130s) This is actually work that we're doing on Ace. And Maggie wrote this dashboard and hard-coded her name, and so that's why we're looking at Maggie's name. Um, and David worked on whatever.

[19:00](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1140s) All this stuff to help me stay aligned with my team. And when I look to the future, I'm starting to think about, how do automations surface themselves in this if I wanna talk with my automation?

[19:10](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1150s) Uh, there's lots of things that I wanna do in this kind of interface, like when an agent wants to tap me on the shoulder and ask me a question, um, that I think are very interesting.

[19:21](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1161s) So that's a short Ace demo. We're going through this weird inversion of our relationship with the agents. Like, the better that we get at articulating, uh, our goals to the agents, the less they need us.

[19:33](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1173s) Uh, and as the models get better, they're also good at spotting, like, underspecified behaviors and then asking us to clarify. Uh, and then whenever they need a pair of hands, they can ask us to be the pair of hands.

[19:45](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1185s) But either way, the interfaces now have the ability to support the ability of agents to listen to everything and invoke us when they need it, which is a little funny to think about.

[19:56](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1196s) It's maybe, like, sort of we're coming at it from this side, and, like, OpenClaw's coming at it from this side, but, like, we're landing in sort of a similar spot.

[20:08](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1208s) And I'll close with this thought. Um, for the past few years, AI has helped me to type, but if you look at the science of the matter, it's only about 5% of the job.

[20:17](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1217s) Like, this was a longitudinal study conducted on, like, 100 developers over thousands of hours. Turns out that the hands-on-keyboard typing part is 5% of the time. Now AI has to help me with the other 95%.

[20:30](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1230s) Where is the system that I wanna touch? How does it work today? What do other people think about, like, how we could mutate it or should mutate it? When AI can discover anything in my code base, like, how do we, how do we help scale up all those other things, right?

[20:46](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1246s) Like, not just the 5%, which is what all the tools have been helping us to do so far. So that's Ace, and that's Agentic Workflows. Uh, please, uh, come by and talk to us.

[20:56](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1256s) Uh, we have, uh, a booth down in the Microsoft booth because we're a Microsoft company. Uh, and you can find us on the socials and githubnext.com. So if any of this resonates and you're interested in it and you wanna give it a shot, Ace is gonna be in technical preview hopefully later this month, and Agentic Workflows is

[21:13](https://www.youtube.com/watch?v=iQ5xldZ9StU&t=1273s) already out there for you to kick the tires, and we'd love to hear from you and how you wanna use this. Thank you so much. [audience applauding] [upbeat music]
