The Unix Philosopher's Guide to AI Agents

Microsoft AI Dev Days 2025

Duration: 15-20 minutes + demos

---

The Hook (1 minute)

"In 1978, Doug McIlroy described Unix philosophy in a sentence: Write programs that do one thing and do it well. Write programs to work together. Write programs to handle text streams."

"Forty-seven years later, that sentence describes the most powerful AI architecture we've built."

Opening visual: Side-by-side comparison

1978: cat file.txt | grep error | wc -l
2025: cat task.md | ma | gh issue create

---

Section 1: The Shift (3 minutes)

Key Point: Software is Now Instructions + Tools

The Old Model:

• Learn the tool's interface
• Adapt your thinking to the tool
• Master arcane flags and options

The New Model:

• Describe what you want in text
• The AI adapts to your intent
• Configuration as prose, not syntax

Why This Matters

# The old way: Learn fd's syntax
fd -e ts -x grep -l "TODO"

# The new way: Describe intent
echo "Find TypeScript files with TODOs" | copilot -p

Key insight: We didn't abandon Unix philosophy - we completed it. Text was always the universal interface. Now we have programs that understand text.

---

Section 2: Small Tools, Big Composition (4 minutes)

The markdown-agent Philosophy

ma does ONE thing: turns markdown into CLI commands.

.md file -> parse -> template -> spawn -> output

That's it. No orchestration frameworks. No complex state machines. Just:

• Read markdown
• Extract frontmatter
• Build CLI args
• Run command
• Return stdout

Demo 1: The Simplest Agent

File: hello.copilot.md

---
model: gpt-4.1
---
Say "Hello from the Unix philosophy"

ma hello.copilot.md

Why this matters: The filename IS the configuration. hello.copilot.md infers the command from the extension. Configuration as convention.

Composition Through Pipes

# Generate, validate, deploy
ma generate-code.copilot.md | ma review.claude.md | ma deploy.copilot.md

Each agent is a filter. Each filter transforms text. This is grep | sed | awk for the AI age.

---

Section 3: Escalation Patterns (4 minutes)

The Unix Insight: Different Tools for Different Jobs

copilot for speed:

---
command: copilot
model: gpt-4.1
silent: true
---
Quick git status summary

claude for depth:

---
command: claude
model: opus
---
Deep architectural analysis of @./src/**/*.ts

Demo 2: Intelligent Escalation

#!/bin/bash
# Try fast first, escalate if needed

result=$(ma quick-check.copilot.md)

if echo "$result" | grep -q "NEEDS_REVIEW"; then
    ma deep-review.claude.md
else
    echo "$result"
fi

The pattern: Start cheap. Escalate when needed. This is try || fallback for intelligence.

The Cost/Intelligence Tradeoff

Agent	Speed	Cost	Use Case
copilot	Fast	Low	Routine tasks
claude-haiku	Fast	Low	Quick analysis
claude-sonnet	Medium	Medium	Complex tasks
claude-opus	Slow	High	Expert reasoning

Unix taught us: use cat when you need cat, awk when you need awk. Same principle.

---

Section 4: Scripts That Know When They Need Help (4 minutes)

Beyond Static Automation

Traditional scripts are deterministic. AI-augmented scripts are adaptive.

Demo 3: Self-Aware Build Script

File: smart-build.sh

#!/bin/bash
set -e

# Run build
if ! npm run build 2>&1 | tee build.log; then
    # Build failed - ask for help
    echo "Build failed. Analyzing..."

    analysis=$(cat build.log | ma analyze-error.copilot.md)

    if echo "$analysis" | grep -q "SIMPLE_FIX"; then
        # Copilot can handle it
        ma fix-simple.copilot.md --error "$(cat build.log)"
    else
        # Escalate to Claude for complex debugging
        ma debug-complex.claude.md --error "$(cat build.log)"
    fi
fi

The insight: The script doesn't just fail - it reasons about failure. It chooses its debugging strategy based on complexity.

The Import System: Composable Context

---
command: claude
---
Review this code for issues:

@./src/main.ts          # Import file
@./src/**/*.test.ts     # Import with glob
@./src/utils.ts:10-50   # Import line range
@./src/types.ts#User    # Import specific symbol

This is #include for the AI age. Compose context like you compose programs.

---

Section 5: Text as the Universal Interface (3 minutes)

Everything is a String

# Commands inline in markdown
!`git status`

# URLs inline
@https://api.github.com/repos/owner/repo

# Templates with variables
{{ branch_name | default: "main" }}

Demo 4: The Pipeline

# Full CI pipeline in pipes
git diff HEAD~1 |
    ma summarize-changes.copilot.md |
    ma generate-changelog.copilot.md |
    ma create-release-notes.claude.md > RELEASE.md

No frameworks. No orchestrators. Just pipes.

Why "Worse is Better" Wins

Feature	Orchestration Frameworks	markdown-agent
State management	Complex	None
Error handling	Built-in	Exit codes
Parallelism	Configured	& and wait
Configuration	YAML/JSON schema	Markdown
Learning curve	Weeks	Minutes

The Unix way: simple primitives, composed infinitely.

---

Section 6: The Future is Readable (2 minutes)

Agents You Can Actually Read

Traditional "agent" code:

class Agent:
    def __init__(self, llm, tools, memory, planner):
        self.orchestrator = Orchestrator(
            llm=llm,
            tool_registry=ToolRegistry(tools),
            memory_backend=memory,
            planning_strategy=planner
        )
    # ... 500 more lines

markdown-agent:

---
command: claude
model: opus
---
Analyze the codebase and suggest improvements.
@./src/**/*.ts

Which one would you rather debug at 3 AM?

The Promise

"The next generation of software engineers won't learn to code. They'll learn to instruct."

But the Unix philosophy endures: small tools, composed simply, through text.

---

Closing: The Continuity (1 minute)

"I'm fascinated that 50 years later, the Unix philosophy isn't just surviving - it's thriving. The tools got smarter, but the composition stayed simple."

The call to action:

1. Start with pipes, not frameworks
2. Write agents as readable markdown
3. Compose intelligence like you compose commands
4. Let the tools do one thing well

Final slide:

# The Unix philosophy, evolved
cat problem.txt | think | solve | verify | deploy

Thank you.

---

Demo Appendix

Quick Demo Scripts

Demo 1 files needed:

# hello.copilot.md
ma hello.copilot.md

Demo 2 files needed:

# quick-check.copilot.md
# deep-review.claude.md
./escalate.sh

Demo 3 files needed:

# smart-build.sh
# analyze-error.copilot.md
# fix-simple.copilot.md
# debug-complex.claude.md

Demo 4 live:

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

---

Backup Talking Points

• If asked about security: "Same as any CLI tool - sanitize inputs, don't pipe untrusted content, use sandboxing when available"
• If asked about cost: "Start cheap, escalate when needed - that's the whole point of composition"
• If asked about vendor lock-in: "The markdown format is command-agnostic. Change command: copilot to command: claude in one line"
• If asked about production use: "It's just spawning processes. If you trust your CLI tools in production, you can trust ma"