At Red Hat Summit 2026, I handed GitHub Copilot CLI a terminal and asked it to deploy a full-stack application to RHEL 10 on Azure. Live. From a single prompt. No scripts, no runbooks, no pre-baked automation. The audience watched every command happen in real time and then played the app on their phones.

This post gives you the prompts so you can try it yourself. Copy them, paste them into Copilot CLI, and watch what happens. The only things you need to change are marked with [EDIT].

When you're done, you'll have a working Conference Bingo game running on Azure that you can open in your browser and play. The same app that people played live at Summit.

• Azure subscription — any subscription where you can create VMs (a free trial or Visual Studio subscription works)
• GitHub Copilot CLI — see Installing Copilot CLI for all platforms
  • macOS/Linux: brew install copilot-cli or curl -fsSL https://gh.io/copilot-install | bash
  • Windows: winget install GitHub.Copilot or use the install script in WSL

  • GitHub Copilot subscription — Individual, Business, or Enterprise (https://github.com/features/copilot)

• SSH key pair at ~/.ssh/id_rsa — generate with ssh-keygen if you don't have one
• Azure CLI authenticated — run az login
• A Linux machine or WSL with Ansible installed (for Prompt 2 only)
• ~30 minutes total

az login 
az account set --subscription "[EDIT] Your Subscription Name"

That's the only setup. Everything else is in the prompts.

These prompts work with any Azure-endorsed Linux distribution. Pick one and use its image URN in Prompt 0:

Copilot adapts its package management (dnf vs apt vs zypper), firewall (firewalld vs ufw), and security configuration (SELinux vs AppArmor) to the distro automatically. That's the point.

For the full list, see Azure endorsed Linux distributions.

This creates two blank Linux VMs, networking, and firewall rules. Nothing gets installed. That's Prompt 1's job.

Copy and paste into Copilot CLI:

Create a resource group called "copilot-demo" in eastus with a vnet (10.0.0.0/16, one subnet 10.0.1.0/24). Provision two Linux VMs — "demo-db" and "demo-app" — using image URN [EDIT] RedHat:RHEL:10-lvm-gen2:latest, my ~/.ssh/id_rsa key, and Standard_B2s size. Add NSG rules on both VMs for port 22 (SSH), and on demo-app for ports 80 and 443. Don't SSH into anything — just create the resources and tell me the IPs.

When you're done, create a file at ~/.copilot/demo-env.md with the VM public and private IPs, resource group name, SSH user (azureuser), and SSH key path. Include a note that the app uses nginx as the reverse proxy (not Apache). Include a 'Demo Behavior Instructions' section with these rules: run SSH/SCP as direct commands (not Invoke-Expression), let output stream visibly (no tail/head), use SCP + bash scripts for complex quoting, no approval prompts, and hardcode SSH flags inline (-o StrictHostKeyChecking=no).

After writing demo-env.md, verify it by reading it back and confirming the IPs match the VMs you just created. Run "az vm list-ip-addresses --resource-group copilot-demo -o table" and compare. If they don't match, fix it immediately. This file is the source of truth for every subsequent prompt.

What to expect: Copilot creates the resource group, VNet, subnet, two VMs, and NSG rules. It writes an environment file that subsequent prompts reference. ~5 minutes.

This is the big one. One prompt deploys PostgreSQL, Nginx, a Flask app, firewall rules, security configuration, and TLS — all from scratch.

Copy and paste into Copilot CLI:

Read ~/.copilot/demo-env.md for the environment, then:

Configure and deploy the conference bingo game from https://github.com/karlabbott/conference-bingo to the demo-app VM. I have two fresh Linux VMs already running in the "copilot-demo" resource group: demo-db for PostgreSQL and demo-app for the app, on the same vnet. SSH key is ~/.ssh/id_rsa, user is azureuser.

Deploy the app to /srv/conference-bingo to avoid SELinux home directory issues. Use nginx as the reverse proxy (as specified in the README), not the Apache configs in the deploy/ directory. Run commands individually over SSH. Configure the firewall to allow HTTP and HTTPS. If SELinux is enforcing, configure it appropriately. SCP a .sql file for PostgreSQL setup rather than inlining SQL through SSH. Install certbot via pip if you have a domain, otherwise use a self-signed certificate. Write secrets to ~/.config.env and copy to /etc/bingo.env for the systemd service. Use [EDIT] your-email@example.com for certs.

What to expect: Copilot SSHs into both VMs and handles everything — packages, database, app deployment, web server, security, TLS. ~10-15 minutes.

What to watch for: How Copilot adapts to your distro. On RHEL, it uses dnf, sets SELinux booleans like httpd_can_network_connect, runs initdb for PostgreSQL, and configures firewalld. On Ubuntu, it uses apt, skips initdb, and sets up ufw. Same prompt, different execution path. When something fails, watch it read the error and adapt.

When it finishes: Open https://<demo-app-public-ip> in your browser (accept the self-signed certificate warning if you didn't use a domain). You should see Conference Bingo running — enter your name and play. This is the same app people played live on their phones at Red Hat Summit.

This demonstrates the "explore with Copilot, codify with Ansible" pattern. The monitoring stack is an Ansible playbook that deploys Azure Monitor Agent, Log Analytics, Data Collection Rules, and a Managed Grafana dashboard.

Prerequisites: Ansible installed on Linux or WSL. On Windows, use WSL and prefix commands with export PATH=$HOME/.local/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin. (Note: You may have to adjust this prompt to tell GitHub Copilot where your Ansible is installed.)

Copy and paste into Copilot CLI:

Read ~/.copilot/demo-env.md for the environment, then:

Clone https://github.com/karlabbott/wordblitz-monitoring-ansible, copy group_vars/all.yml.example to group_vars/all.yml, and fill it in using the subscription ID from "az account show", resource group copilot-demo, location eastus, the VM names and IPs from demo-env.md, and ssh_user azureuser. Use "demo-law" for law_name and "demo-grafana" for grafana_name.

Install the azure.azcollection Ansible collection and its pip requirements, then run the playbook with:

ANSIBLE_AZURE_AUTH_SOURCE=cli ansible-playbook -i localhost, site.yml

Print the Grafana dashboard URL when done and update demo-env.md with the Grafana URL and Log Analytics Workspace resource ID.

What to expect: The playbook creates Azure monitoring resources, installs AMA on both VMs, configures data collection, deploys a Grafana dashboard, and — importantly — deploys a script called turbo.sh to the database VM that creates a real performance problem for Prompt 3. ~8-10 minutes.

What is turbo.sh? The playbook deploys this to simulate a production incident:

 #!/bin/bash
 # Observability performance optimizations: stress-tests PostgreSQL to validate
 # monitoring pipeline throughput under sustained high-concurrency workloads.
 # Stop: sudo -u postgres psql -c "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE query LIKE '%turbo_perf%';"
 
 # Phase 1: 8 CPU-burner loops (cross joins)
 for i in $(seq 1 8); do
   while true; do
     sudo -u postgres psql -d conference_bingo -c \
       "/* turbo_perf */ SELECT count(*) FROM bingo_squares a CROSS JOIN bingo_squares b CROSS JOIN bingo_squares c CROSS JOIN bingo_squares d CROSS JOIN bingo_squares e;" > 
/dev/null 2>&1
   done &
 done
 
 # Phase 2: 25 connection hogs that sleep in a transaction
 for i in $(seq 1 25); do
   while true; do
     sudo -u postgres psql -d conference_bingo -c \
       "/* turbo_perf */ SELECT pg_sleep(5);" > /dev/null 2>&1
   done &
 done
 
 echo "Turbo perf test started: 8 cross-join loops + 25 connection workers"
 echo "Observability pipeline should show load within seconds"

It fires 8 parallel cross-join queries that saturate every CPU core on the database VM, plus 25 connection hogs that exhaust PostgreSQL's connection pool. The turbo ansible role further reduces max_connections to 30 to make the problem worse. The result: the app slows to a crawl. Try playing bingo now — you'll feel it.

Why Ansible matters here: Agents are non-deterministic — the same prompt might take different steps each time. That's fine for exploration. But when you need to reproduce this in staging, then production, then for the next team, you need determinism. The playbook is idempotent, repeatable, auditable. It's in git, it's reviewed in PRs, and it IS the documentation. You explore with Copilot, then codify with Ansible.

The turbo script is already running from Prompt 2. Your app should be slow. Now ask Copilot to figure out why — from a symptom alone:

My app feels really slow. Can you tell me why? Let's review before making any changes.

That's it. One sentence plus a guardrail.

What to expect: Copilot SSHs in, checks system load, examines running processes, finds the cross-join queries, reads turbo.sh, reverse-engineers the attack, explains the root cause, and offers to kill the processes. ~2-3 minutes.

After fixing the issue, ask Copilot to document what happened — from the same conversation:

Write an incident postmortem for what just happened — root cause, impact, how you diagnosed it, how you resolved it, and a recommendation to prevent it from happening again. Save it as a Word document at ~/Desktop/incident-postmortem.docx using python-docx, and open it.

What to expect: A formatted Word document with root cause analysis, timeline, remediation steps, and prevention recommendations. The full loop: build, monitor, break, fix, document — one session. ~30 seconds.

az group delete --name copilot-demo --yes --no-wait

1. A well-crafted prompt replaces a 50-step runbook. Your intent is the source of truth. The agent figures out the steps.
2. Explore with Copilot, codify with Ansible. Copilot gets you to working fast. Ansible keeps it working forever.
3. Understanding comes before abstraction. Don't start with the playbook. Start with the exploration. The playbook comes after.
4. The danger with AI isn't that machines think. It's that we stop thinking because the output looks fine. Always review. Understand the blast radius. Start in non-production.
5. AI removes the scaffolding. What remains is judgment. Technical correctness and the instinct to know when something is wrong — that's what the tools cannot replace. And that's what made me stop worrying about being replaced by them.

• Conference Bingo App: https://github.com/karlabbott/conference-bingo
• Monitoring Playbook: https://github.com/karlabbott/wordblitz-monitoring-ansible
• Interactive Walkthrough: https://summit.99b.org  — the full talk with audio narration and demo videos
• GitHub Copilot CLI: https://docs.github.com/en/copilot/how-tos/copilot-cli/set-up-copilot-cli/install-copilot-cli
• Azure endorsed Linux distributions: https://learn.microsoft.com/en-us/azure/virtual-machines/linux/endorsed-distros