← → navigate · N notes · F fullscreen
Cornell University · AI Platform

# AI-DLC
at Cornell

Governing how we build with AI — not just what we build
Workshop · August 3–4, 2026
Slide 01

# Why are we in the room?

Building is no longer the expensive part.

An agent will write the Lambda, the template and the tests while you read this slide. The cost has moved somewhere else: deciding what to build, agreeing on the seams between our systems, and being able to prove afterwards what was deployed and by whom.

Which is exactly why coming together matters more, not less.

- Alignment doesn't parallelise. One shared repo, one shared account, one green `main`.
- Design intent lives in people's heads until we write it down where an agent can read it.
- Trust is built once, in a room, then encoded — not renegotiated per team.

AI-DLC at Cornell
Slide 02

# Discovery just got compressed to nothing

The prompt we're all afraid of
“Build me an ERP.
Make no mistakes.”

Eighteen months of discovery, collapsed into eleven words — and every assumption that used to surface in those eighteen months is now made silently, by the model, in a fraction of a second.

- Requirements gathering was slow enough to be a control. It isn't anymore.
- The agent will happily invent a data model, an auth story and a region. All plausible. None of them ours.
- Nothing is wrong in the output — it's just unaware of Cornell.
- Speed didn't remove the need for intent. It removed the time we used to spend accidentally forming it.

AI-DLC at Cornell
Slide 03

# The architecture job is now stating intent

We cannot review every build at agent speed. So we stop reviewing outputs one by one and start encoding design intent where the agent will read it — then let it read the instructions and build following the instructions.

Written down

### Intent as a file

Constraints live in the repo, in prose the agent loads on every session — not in a wiki page nobody opens and no model ever sees.

Reusable

### Intent as a blueprint

Governed building blocks a builder composes. The safe choice is also the fastest one available, so nobody has to be talked into it.

Enforced

### Intent as a check

Tags, stack naming, registry mirroring, `tools/check`. If it isn't enforced by a gate, it is a preference, not an architecture.

In this repo that's CLAUDE.md, the four cornell:* tags, pipeline/stacks.yml and the validate check — the whole design intent of the platform, in a form an agent obeys.
AI-DLC at Cornell
Slide 04

# Govern the builder agent, not just the agents it builds

#### The instinct

Govern every AI app we ship. Review each chatbot, each RAG pipeline, each assistant, one at a time.

The surface grows faster than the review capacity. Policy arrives after the deploy. You are permanently behind.

#### The leverage

Govern the agent that does the building. One place where design intent, permissions and guardrails are applied.

Every application it produces inherits them — tagged, IaC, PR-only, auditable — without asking the builder to care.

There is one builder agent and many applications. Governing the narrow end of the funnel is the only version of this that scales — and it's the version where the builder never needs an AWS account, a console login, or a security review to move.

AI-DLC at Cornell
Slide 05

# An approach that works

AI orchestrates the development process with planning, task decomposition, architectural suggestions — not just the typing.

Developers retain the ultimate responsibility for validation, decision‑making and oversight.

AI-DLC at Cornell
Slide 06

# SDLC → AI-DLC

Traditional SDLC phases
Requirements Gathering and Analysis
Design and Planning
Development
Deployment
Support and Maintenance
AI-DLC phases
Inception Intent, decomposition, units of work — where the human judgement concentrates.
Construction Design and build stop being separate activities. Logical → code → IaC, in one loop.
Operation Deploy, observe, maintain. Tagged and inventoried from the first resource.
Not a two-week sprint cadence with a copilot bolted on. The phases themselves change shape — and the ratio of thinking to typing inverts.
AI-DLC at Cornell
Slide 07

# This is not agile with a copilot

A sprint is a batching strategy for expensive change. You batch two weeks of work because re-planning costs more than being slightly wrong for a fortnight.

When change is nearly free, batching is pure latency. The ceremony that protected you becomes the thing slowing you down.

- The unit shrinks. From a two-week sprint to a single bolt of work, completed in a sitting.
- Plans are cheap and disposable. Re-derive rather than defend a stale plan.
- The human moves upstream. Less “is this implemented right”, more “is this the right thing, and can we prove it”.
- The gate replaces the ritual. Automated checks, not a status meeting, decide what ships.

AI-DLC at Cornell
Slide 08

# Meanwhile: people are already building

Today, without us

### Keys in notebooks

Credentials pasted into a Colab cell, a personal account, an unmanaged subscription. No rotation, no owner, no inventory.

Today, without us

### No paper trail

Nothing tagged, nothing in IaC. Nobody can answer what is running, who owns it, or what data it can reach.

Today, without us

### Cost and risk invisible

Spend appears on a card statement. Exposure appears in an incident. Both after the fact.

This isn't recklessness — it's people getting unblocked because we never offered them a fast, safe road. The answer to shadow IT has never been a stricter policy. It's a better default.

AI-DLC at Cornell
Slide 09

# What Cornell's AI Platform is actually building

01

### An AI service catalog

A blueprint layer: reusable, governed building blocks that campus builders compose into working applications — knowledge bases, chat frontends, retrieval, identity.

02

### Governance & security as a service

Tagging, secrets handling, least‑privilege roles, inventory and cost attribution arrive inside the blueprint — not as a checklist a builder has to pass.

03

### A builder path, not an AWS account

Builders describe what they want in Claude Code. The pipeline deploys it into an account the platform team controls. PR‑only write access — no console, no keys.

Serverless-first · us-east-1 Everything is IaC Secrets only in Secrets Manager All four cornell:* tags, every resource
AI-DLC at Cornell
Slide 10

# How a merge becomes a deployment

1
Source
Webhook on merge to `main` — starts within seconds
2
PipelineDeploy
The pipeline deploys itself from `pipeline/pipeline.yml`
3
BlueprintDeploy
One CloudFormation action per blueprint stack
4
Terraform
Azure / Entra modules — plan, then apply, unattended
The thing to internalise

### Every merge to `main` deploys to a shared AWS account.

No console step. No post-merge approval. Everyone works in this one repo for two days, so a red `main` blocks every other track — and a hung stack is worse than a failed one.

Branch protection means PR-only, `validate` must pass, and a team member merges their own work. That check is the only automated gate between a branch and a live account — so run `tools/check` before you push.

AI-DLC at Cornell
Slide 11

# What we want to leave with

- A path, not a demo. Something a builder outside this room can walk on Wednesday, without us in the loop.
- Design intent written down where an agent reads it — and a check that fails when it's ignored.
- One decision per file in `docs/decisions/`, so the next team inherits reasoning instead of archaeology.

If a constraint here is wrong, say so in the room.

Today, out loud — not by working around it in a PR at 4pm tomorrow. The constraints are deliberate, and they are also ours to change while we're all still sitting here.

Cornell AI-DLC Workshop · August 3–4, 2026 · one repo, one shared account, one green `main`.
AI-DLC at Cornell
Speaker notes — press N to hide