acdl/demo/ACDL_DEMO.md

---
marp: true
theme: default
paginate: true
size: 16:9
header: 'ACDL · Agentic Cloud Delivery Platform'
footer: 'Executive Demo · v1.0'
style: |
  /* S&P Global-inspired palette */
  :root {
    --sp-red: #C8102E;
    --sp-red-dark: #8E0B20;
    --sp-ink: #1A1A1A;
    --sp-slate: #4A4A4A;
    --sp-gray: #6E6E6E;
    --sp-line: #D6D6D6;
    --sp-bg: #FFFFFF;
    --sp-tint: #F4F4F4;
  }
  section {
    font-size: 24px;
    color: var(--sp-ink);
    background: var(--sp-bg);
    font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
    padding: 50px 60px;
  }
  section.title {
    text-align: center;
    background: var(--sp-red);
    color: #FFFFFF;
    display: flex;
    flex-direction: column;
    justify-content: center;
  }
  section.title h1 {
    color: #FFFFFF;
    font-size: 64px;
    margin-bottom: 0;
    border: none;
  }
  section.title h2 {
    color: #FFFFFF;
    border: none;
    font-weight: 400;
  }
  section.title strong { color: #FFFFFF; }
  h1 {
    color: var(--sp-red);
    font-size: 40px;
    font-weight: 700;
    margin-bottom: 12px;
  }
  h2 {
    color: var(--sp-red);
    border-bottom: 3px solid var(--sp-red);
    padding-bottom: 6px;
    font-weight: 700;
  }
  h3 {
    color: var(--sp-red-dark);
    font-weight: 600;
    margin-top: 24px;
  }
  ul, ol { color: var(--sp-slate); }
  li { margin-bottom: 6px; }
  strong { color: var(--sp-ink); }
  table {
    font-size: 18px;
    width: 100%;
    border-collapse: collapse;
    margin: 12px 0;
  }
  th {
    background: var(--sp-red);
    color: #FFFFFF;
    text-align: left;
    padding: 10px 12px;
    font-weight: 600;
    border: 1px solid var(--sp-red-dark);
  }
  td {
    padding: 8px 12px;
    border: 1px solid var(--sp-line);
    color: var(--sp-slate);
  }
  tr:nth-child(even) td { background: var(--sp-tint); }
  pre {
    font-size: 13px;
    background: var(--sp-tint);
    border-left: 4px solid var(--sp-red);
    padding: 14px 16px;
    border-radius: 0;
    color: var(--sp-ink);
  }
  code {
    background: var(--sp-tint);
    color: var(--sp-red-dark);
    padding: 1px 5px;
    border-radius: 2px;
    font-family: 'Menlo', 'Consolas', monospace;
  }
  pre code {
    background: none;
    color: var(--sp-ink);
    padding: 0;
  }
  blockquote {
    border-left: 5px solid var(--sp-red);
    background: var(--sp-tint);
    padding: 10px 16px;
    color: var(--sp-slate);
    font-style: italic;
    border-radius: 0;
  }
  header {
    color: var(--sp-red);
    font-weight: 700;
    font-size: 14px;
  }
  footer {
    color: var(--sp-gray);
    font-size: 12px;
  }
  section::after {
    color: var(--sp-red);
    font-weight: 700;
  }
---

<!-- _class: title -->

# ACDL
## Agentic Cloud Delivery Platform

Automatic. Safe. Audited. — in 30 minutes, on stubs.

v1.0 · GitHub Actions · stub-driven

<!--
30-min exec demo. Emphasize: we prove INTENT and SAFETY, not provision real infra.
Everything runs as local stubs on Linux via GitHub Actions. No AWS.
-->

---

# The Problem

### Today, deploying infrastructure takes **weeks**

- Ticket → triage queue → copy-paste config → peer review → security review → waiting for central IT to release

> Two weeks of human latency for a service that should take minutes.

### What we want instead

- Developer commits a **contract** → pipeline runs
- Safety **computed** automatically (confidence signal)
- Manual gates only where they matter (QA, Prod)
- Every step written to a tamper-evident **evidence stream**

<!--
Set the pain. Ask: who has lived this? Then pivot to the vision.
-->

---

# How It Works

```
              ┌────────────── acdl-contracts ──────────────┐
 Developer ──▶│ commit contract.yaml                     │
              └───────┬───────────────────────────────────┘
                      │ (push)
 Citizen    ┌─────────┴──────────┐
  │ "ingest gas pricing into data lake"
  ▼
 Claude agent ──▶ contract.yaml ─┘
                      │ (push)
                      ▼
            ┌─────────────────┐
            │ reusable         │
            │ GitHub Actions   │
            │ pipeline         │
            └────────┬────────┘
                     │
       ┌─────────────┼─────────────┐
       ▼             ▼             ▼
 Dev (auto)   QA (approval)   Prod (approval)
       │
       ▼
 evidence_writer ─▶ audit.json (hash-chained) ─▶ Pages timeline
```

Two entry paths, **one** pipeline, **one** audit trail — developer via GitHub, citizen developer via their own Claude agent.

<!--
Two surfaces: developers push contracts directly to GitHub; citizen developers prompt a Claude agent they own, which writes and pushes the contract for them.
Both converge on one GitHub Actions pipeline with three stages.
-->

---

# The Safety Story

### Computed, not requested

| Signal | Behavior |
|--------|----------|
| **Base confidence** | 0.90 |
| **On policy violation** | drop to 0.40 + reason code |
| **Gate threshold** | ≥ 0.50 to proceed past Dev |

### Policy (v1)
- `public-ingress: true` → `POLICY_VIOLATION:PUBLIC_INGRESS`

### Evidence
- Each event appended to `audit.json` with SHA-256 link to previous (`prev_hash` + `hash`)
- Published to Pages → vanilla-JS timeline

<!--
Safety is computed by the platform, not asked of the developer.
Threshold 0.50 is exact → 0.90 passes, 0.40 halts. That's what makes the three scenarios deterministic.
-->

---

# Scenario 1 — Developer Self-Service

### Trigger
Developer commits a valid `contract.yaml` requesting **`l2-commodity-price-feed`** via **GitHub**.

### What you'll see
- **Dev:** policy ✅ → apply api-gateway, lambda, s3 → confidence **0.90** → proceed
- **QA:** pipeline pauses → click **Approve**
- **Prod:** pipeline pauses → click **Approve**
- **Finalize:** `audit.json` committed → Pages timeline updates

### Evidence outcome
Timeline shows: contract received → policy pass → apply × 3 → confidence 0.90 → QA → Prod → published.

<!--
Normal developer flow: human writes the contract, pushes to GitHub, the GitHub Action pipeline runs.
Narrate: developer commits and walks away; platform does the rest.
Pause visibly at each gate so the audience sees human-in-the-loop.
End by refreshing the Pages timeline.
-->

---

# Scenario 1 — Journey

```mermaid
flowchart LR
  classDef gh fill:#F4F4F4,stroke:#1A1A1A,stroke-width:2px,color:#1A1A1A
  classDef stage fill:#C8102E,stroke:#8E0B20,stroke-width:1px,color:#FFFFFF
  classDef gate fill:#FFFFFF,stroke:#1A1A1A,stroke-width:2px,color:#1A1A1A
  classDef evidence fill:#F4F4F4,stroke:#C8102E,stroke-width:1px,color:#1A1A1A

  D["Developer"]:::gh -->|"writes contract.yaml"| GH["GitHub<br/>acdl-contracts"]:::gh
  GH -->|"push triggers<br/>GitHub Action"| DEV["Dev<br/>(autonomous)"]:::stage
  DEV -->|"policy ✅ · confidence 0.90"| QA["QA<br/>approval gate"]:::gate
  QA -->|"approve"| PROD["Prod<br/>approval gate"]:::gate
  PROD -->|"approve"| FIN["Finalize<br/>commit audit.json"]:::stage
  FIN --> TL["GitHub Pages<br/>timeline"]:::evidence
```

<!--
Point to the two approval gates — QA and Prod — both human clicks.
The whole chain from commit to timeline is one GitHub Actions workflow.
-->

---

# Scenario 2 — Citizen Developer

### Trigger
Non-technical user prompts their **own Claude agent** in natural language:

> "I need a new service to ingest real-time natural gas pricing data into our data lake."

### What you'll see
- Claude agent parses intent, writes `contract.yaml` for **`l2-commodity-price-feed`**, pushes a branch
- Issue **closed**; branch push triggers the **identical** pipeline from Scenario 1
- Citizen developer follows the run all the way to **Prod**

### Evidence outcome
Timeline is **indistinguishable** from Scenario 1 — the agentic surface is first-class, not a bolt-on.

<!--
Punchline: same timeline, same safety, same audit — different entry.
The citizen developer owns and drives their own Claude agent; they are the actor, not the platform.
Normal developers (Scenario 1) keep using GitHub directly — two surfaces, one pipeline, one audit.
-->

---

# Scenario 2 — Journey

```mermaid
flowchart LR
  classDef cit fill:#F4F4F4,stroke:#C8102E,stroke-width:2px,color:#1A1A1A
  classDef agent fill:#C8102E,stroke:#8E0B20,stroke-width:1px,color:#FFFFFF
  classDef stage fill:#1A1A1A,stroke:#1A1A1A,stroke-width:1px,color:#FFFFFF
  classDef gate fill:#FFFFFF,stroke:#1A1A1A,stroke-width:2px,color:#1A1A1A
  classDef evidence fill:#F4F4F4,stroke:#C8102E,stroke-width:1px,color:#1A1A1A

  CD["Citizen developer"]:::cit -->|"natural-language<br/>prompt"| CL["Claude agent<br/>(citizen-owned)"]:::agent
  CL -->|"generates<br/>contract.yaml"| GH["GitHub<br/>acdl-contracts"]:::cit
  GH -->|"push triggers<br/>GitHub Action"| DEV["Dev<br/>(autonomous)"]:::stage
  DEV -->|"policy ✅ · confidence 0.90"| QA["QA<br/>approval gate"]:::gate
  QA -->|"approve"| PROD["Prod<br/>approval gate"]:::gate
  PROD -->|"approve"| FIN["Finalize<br/>commit audit.json"]:::stage
  FIN --> TL["GitHub Pages<br/>timeline"]:::evidence
```

<!--
Highlight the red Claude-agent node — owned by the citizen, not by the platform.
From GitHub onward the journey is identical to Scenario 1.
-->

---

# Scenario 3 — The Safety Net

### Trigger
Developer commits a **malicious** `contract.yaml` for `l2-regulatory-reporting` via **GitHub**:

```yaml
stack: l2-regulatory-reporting
public-ingress: true
```

### What you'll see
- **Dev:** `policy_checker` → `POLICY_VIOLATION:PUBLIC_INGRESS`
- `confidence_signal` drops 0.90 → **0.40**
- `0.40 < 0.50` → pipeline **halts in Dev**
- Rejection reason written to the evidence stream

### Evidence outcome
Timeline shows the attempted deploy, the violation, the confidence drop, and the **halt** — visible and explained.

<!--
The safety money shot. The platform said NO, and said WHY, on the record.
No human had to catch it — the confidence signal computed the risk.
Contrast with The Problem's old-world review queue.
-->

---

# Scenario 3 — Journey

```mermaid
flowchart LR
  classDef gh fill:#F4F4F4,stroke:#1A1A1A,stroke-width:2px,color:#1A1A1A
  classDef stage fill:#C8102E,stroke:#8E0B20,stroke-width:1px,color:#FFFFFF
  classDef halt fill:#1A1A1A,stroke:#1A1A1A,stroke-width:1px,color:#FFFFFF
  classDef evidence fill:#F4F4F4,stroke:#C8102E,stroke-width:1px,color:#1A1A1A

  D["Developer"]:::gh -->|"writes malicious<br/>contract.yaml"| GH["GitHub<br/>acdl-contracts"]:::gh
  GH -->|"push triggers<br/>GitHub Action"| DEV["Dev<br/>(autonomous)"]:::stage
  DEV -->|"POLICY_VIOLATION:PUBLIC_INGRESS<br/>confidence 0.90 → 0.40"| HALT["Halt in Dev<br/>+ rejection reason"]:::halt
  HALT --> TL["GitHub Pages<br/>timeline"]:::evidence
```

<!--
The black halt node is the whole point — pipeline stops, evidence records why.
Notice there are no QA/Prod gates on this path; the journey ends at Dev.
-->