Software Is Now Instructions + Tools

Microsoft AI Dev Days - Demo-Heavy Talk Outline

Duration: 15-20 minutes (70% demos, 30% narrative) Speaker Perspective: The Practical Demo Builder Core Thesis: The shift from learning tools to creating instructions

---

Talk Flow Overview

[1 min] Hook: Live demo that wows
[2 min] The Paradigm Shift (only slide)
[4 min] Demo 1: Hello World to Hello Agent
[3 min] Demo 2: Piping Intelligence
[4 min] Demo 3: Agent Escalation
[3 min] Demo 4: The Smart Script
[2 min] Demo 5: The Grand Finale (if time)
[1 min] Call to action

---

Opening Hook (1 min)

What to show: Terminal, full screen, large font

Live command:

echo "Explain this error in one sentence" | copilot -s "TypeError: Cannot read property 'map' of undefined"

Script:

"Before I show a single slide, watch this. I just asked GitHub Copilot CLI to explain an error. But here's the thing - I didn't type that command. A markdown file did. Let me show you what I mean..."

---

The Only Slide (2 min)

Title: Software Is Now Instructions + Tools

Visual: Simple diagram

OLD WORLD                    NEW WORLD
---------                    ---------
Developer                    Developer
    |                            |
    v                            v
Learn Tool A                 Write Instructions
Learn Tool B        ->       (markdown files)
Learn Tool C                     |
    |                            v
    v                        Tools execute
Build Software               automatically

Script:

"Software used to be: learn the tool, use the tool. Now it's: write instructions, tools execute. The skill is no longer 'how do I use this CLI?' - it's 'how do I write instructions that any CLI can follow?' Let me prove it."

---

Demo 1: Hello World to Hello Agent (4 min)

Part A: Anatomy of an Agent (1 min)

Create file live:

cat > hello.copilot.md << 'EOF'
---
model: gpt-4.1
silent: true
$1: prompt
---

Say only: "Hello from Copilot!"
EOF

Run it:

ma hello.copilot.md

Talking point:

"Three things happened: 1) ma read the YAML config, 2) it saw .copilot.md and knew to use GitHub Copilot CLI, 3) it translated model: gpt-4.1 into --model gpt-4.1. The filename IS the configuration."

Part B: Same Instructions, Different Tool (1 min)

Create Claude version:

cat > hello.claude.md << 'EOF'
---
model: haiku
p: true
---

Say only: "Hello from Claude!"
EOF

Run both:

ma hello.copilot.md && ma hello.claude.md

Talking point:

"Same instruction. Different tools. The markdown file is the universal interface."

Part C: Dynamic Configuration (2 min)

Create a more complex example:

cat > review.copilot.md << 'EOF'
---
model: gpt-4.1
silent: true
$1: prompt
---

Review this code for bugs, security issues, and performance problems:

@./src/index.ts

Provide a numbered list of issues found.
EOF

Run it:

ma review.copilot.md

Explain the magic:

"That @./src/index.ts just inlined the entire file. The agent doesn't need to know how to read files - the markdown does it. Watch what else we can do..."

Show line range:

cat > review-function.copilot.md << 'EOF'
---
model: gpt-4.1
silent: true
$1: prompt
---

Review only this function:

@./src/index.ts:31-100

Focus on error handling.
EOF

Backup if Demo 1 Fails

Pre-recorded terminal session OR show the raw command:

copilot --model gpt-4.1 --silent --prompt "Say only: Hello from Copilot!"

---

Demo 2: Piping Intelligence (3 min)

Part A: Simple Pipe (1 min)

What to show:

git diff HEAD~1 | ma explain.copilot.md

The explain.copilot.md file:

---
model: gpt-4.1
silent: true
$1: prompt
---

Summarize these git changes in 2-3 bullet points for a commit message.

Talking point:

"UNIX pipes meet AI. The diff flows into the agent, gets summarized, flows out. No API keys in the command. No model selection. Just pipe and go."

Part B: Chain of Agents (2 min)

Create a pipeline:

# First agent extracts code
cat > extract-functions.copilot.md << 'EOF'
---
model: gpt-4.1
silent: true
$1: prompt
---

Extract all function names from this code. Output only the names, one per line.
EOF

# Second agent documents them
cat > document.copilot.md << 'EOF'
---
model: gpt-4.1
silent: true
$1: prompt
---

For each function name in the input, write a one-line description of what it likely does based on its name.
EOF

Run the chain:

cat src/command.ts | ma extract-functions.copilot.md | ma document.copilot.md

Talking point:

"Agent to agent communication via UNIX pipes. Each agent is a single-purpose tool. Compose them like LEGO blocks."

Backup if Demo 2 Fails

Show the concept with echo:

echo "parseCommand, buildArgs, runCommand" | copilot --model gpt-4.1 --silent --prompt "Describe what each function does"

---

Demo 3: Agent Escalation (4 min)

The Big Idea: Cheap model tries first, expensive model rescues failures

Part A: The Triage Agent (2 min)

Create triage.copilot.md:

cat > triage.copilot.md << 'EOF'
---
model: gpt-4.1-mini
silent: true
$1: prompt
---

Analyze this task. Respond with ONLY one word:
- "SIMPLE" if a fast model can handle it
- "COMPLEX" if it needs a powerful model

Task: {{ task }}
EOF

Create the escalation script:

cat > smart-ask.sh << 'EOF'
#!/bin/bash
TASK="$1"

# Triage first
VERDICT=$(ma triage.copilot.md --task "$TASK")

if [[ "$VERDICT" == *"SIMPLE"* ]]; then
  echo "[Using fast model]"
  echo "$TASK" | ma fast.copilot.md
else
  echo "[Escalating to powerful model]"
  echo "$TASK" | ma powerful.copilot.md
fi
EOF
chmod +x smart-ask.sh

Create the worker agents:

cat > fast.copilot.md << 'EOF'
---
model: gpt-4.1-mini
silent: true
$1: prompt
---

Answer concisely:
EOF

cat > powerful.copilot.md << 'EOF'
---
model: gpt-4.1
silent: true
$1: prompt
---

Think step by step and answer thoroughly:
EOF

Part B: Live Test (2 min)

Simple task:

./smart-ask.sh "What is 2+2?"

Complex task:

./smart-ask.sh "Explain the trade-offs between microservices and monolithic architecture for a startup with 5 engineers"

Talking point:

"The script doesn't know AI. It just reads the word SIMPLE or COMPLEX and picks a file. The intelligence is in the instructions, not the script."

Backup if Demo 3 Fails

Show the files and explain the concept with pre-computed outputs

---

Demo 4: The Smart Script (3 min)

The Pattern: A script that knows when it needs AI help

Create self-healing.sh:

cat > self-healing.sh << 'EOF'
#!/bin/bash
# A script that asks for help when it fails

run_with_help() {
  local CMD="$1"

  # Try the command
  OUTPUT=$(eval "$CMD" 2>&1)
  EXIT_CODE=$?

  if [[ $EXIT_CODE -ne 0 ]]; then
    echo "Command failed. Asking AI for help..."

    # Ask Copilot for a fix
    FIX=$(echo "Command: $CMD
Error: $OUTPUT

Suggest a fix. Output ONLY the corrected command, nothing else." | ma fix.copilot.md)

    echo "AI suggests: $FIX"
    read -p "Run suggested fix? (y/n) " -n 1 -r
    echo
    if [[ $REPLY =~ ^[Yy]$ ]]; then
      eval "$FIX"
    fi
  else
    echo "$OUTPUT"
  fi
}

# Example usage
run_with_help "$1"
EOF
chmod +x self-healing.sh

Create fix.copilot.md:

cat > fix.copilot.md << 'EOF'
---
model: gpt-4.1
silent: true
$1: prompt
---

You are a bash expert. Given a failed command and its error, suggest the corrected command.
Output ONLY the command, no explanation.
EOF

Demo it:

# This will fail
./self-healing.sh "ls /nonexistent/path"

# This might suggest: ls /tmp or similar

Talking point:

"The script handles success itself. It only calls AI when something goes wrong. This is the future - intelligent fallbacks baked into every script."

Backup if Demo 4 Fails

Show the concept with a simpler example:

echo "Command: npm instal
Error: Unknown command instal

Suggest fix:" | copilot --model gpt-4.1 --silent --prompt "Output only the corrected command"

---

Demo 5: The Grand Finale - If Time (2 min)

Multi-agent code review:

cat > review-council.sh << 'EOF'
#!/bin/bash
FILE="$1"

echo "=== Security Review ==="
cat "$FILE" | ma security-review.copilot.md

echo ""
echo "=== Performance Review ==="
cat "$FILE" | ma perf-review.copilot.md

echo ""
echo "=== Best Practices Review ==="
cat "$FILE" | ma practices-review.copilot.md
EOF

Run it:

./review-council.sh src/index.ts

Talking point:

"Three specialists. Three perspectives. One file. Parallel reviews in one command. This used to require three different tools. Now it's three markdown files."

---

Closing (1 min)

No slide - just terminal

Final commands to show:

# Show all the agents created during the talk
ls *.copilot.md *.claude.md 2>/dev/null

# Show they're just markdown
wc -l *.copilot.md

Script:

"We created 10+ AI agents in 15 minutes. Each one is under 20 lines of markdown. The future isn't about mastering AI tools - it's about writing instructions that tools can follow.

The code is at github.com/johnlindquist/agents. The CLI is called ma. Go make your scripts smarter."

---

Preparation Checklist

Before the Talk

• Font size: 24pt minimum in terminal
• Create all markdown files in advance (but delete them for live demo)
• Test copilot CLI is authenticated: copilot --version
• Test ma is installed: ma --help
• Have backup commands ready in a notes app
• Pre-record a terminal session as final backup

Environment Setup

# Set up demo directory
mkdir -p ~/demo-ai-dev-days
cd ~/demo-ai-dev-days

# Verify tools
which copilot && which ma && which claude

# Set nice prompt
export PS1='\n$ '

Backup Files Location

Keep pre-created versions of all files in ~/demo-backup/ in case you need to copy them quickly.

---

Recovery Scripts

If copilot is slow:

# Switch to showing the raw command
copilot --help
echo "Here's what ma generates for you..."

If ma fails:

# Run copilot directly
copilot --model gpt-4.1 --silent --prompt "Your prompt here"

If everything fails:

# Show the concept with cat
cat example.copilot.md
echo "This YAML becomes these flags..."
echo "copilot --model gpt-4.1 --silent"

---

Key Talking Points to Remember

1. "The filename IS the configuration" - .copilot.md means use copilot
2. "Instructions, not integration" - markdown files work with any CLI
3. "Compose like LEGO" - UNIX pipes chain agents together
4. "Intelligence as fallback" - Scripts call AI only when needed
5. "20 lines of markdown" - Agents are simple, readable, shareable

---

Post-Talk Resources

Share these in chat:

• Repository: https://github.com/johnlindquist/agents
• Install: npm install -g markdown-agent
• Copilot CLI: https://docs.github.com/en/copilot/github-copilot-in-the-cli