AI-accelerated delivery at Delta Air Lines: three operational apps in three months
Delta Air Lines had one quarter to deliver three operational applications inside an existing enterprise platform, without letting AI break it.
Kiro was Delta’s standard. We turned it into a governed delivery practice and shipped one legacy rewrite and two greenfield apps in three months.
The problem
Delta Air Lines had one quarter to deliver three operational applications inside an existing enterprise platform.
One was a legacy operations dashboard rewrite with years of operational behavior baked in. Two were greenfield apps that still had to follow the same Angular/Nx architecture, shared design system, backend contracts, CI checks, and release controls from day one.
Delta already had an AI development standard in Kiro. The risk was not whether AI could generate code, it was whether it could move fast without creating platform drift.
Under-use makes an agent expensive autocomplete; over-trust ships code that breaks platform rules. We aimed for the third path - structured acceleration inside explicit product, architecture, and delivery constraints:
- code had to land in the right Angular/Nx libraries and respect module boundaries
- shared UI and design-system patterns had to be reused, not recreated
- backend differences had to stay behind adapters and data-access services
- runtime/environment behavior had to fit the deployment model
- lint, tests, builds, code review, and CI/CD all still had to pass
The result
AI-accelerated delivery, governed by engineering discipline.
Representative, anonymized indicators.
3 apps
one legacy rewrite + two greenfield, in a single quarter
3 months
one delivery window, three parallel tracks
6 Delta teams
collaborated with to gather requirements and encode context - product, design, backend, frontend, infrastructure, and release
40–50%
faster than the planned effort - quality controls intact
Sector
- Airline / aviation operations
- Enterprise transportation
Scope
- AI workflow automation
- Agentic system design
- AI-powered coding assistant
- AWS cloud architecture
- LLM integration
Stack & tooling
- Angular · Nx · TypeScript
- AWS Lambda · DynamoDB · CloudWatch
- Kiro - spec-driven agentic IDE
We took Delta’s standard AI toolchain, mastered it fast, and turned it into a repeatable delivery practice across product discovery, stakeholder alignment, architecture, implementation, and quality gates.
What we shipped
Not one app, a small operational suite built into Delta’s existing platform.
The hero project was an operations dashboard rewrite: an older operational tool moved into the modern Angular/Nx monorepo, with current design-system usage and the workflows people relied on preserved. Two greenfield operational apps were built from the same architectural playbook.
These are tools operations teams lean on through the day - to watch status, coordinate, and act on issues while aircraft are moving.
When the legacy dashboard lagged or drifted from the platform, it slowed the people keeping operations running. So continuity mattered as much as modernization: the rewrite had to feel familiar on day one while shedding years of legacy drag.
The hard part
The hard part was not "using Kiro." It was encoding enough product context, platform rules, team constraints, and release gates that AI could help without creating drift.
We worked with product, backend, frontend-platform, infrastructure, design, and release owners across six partner groups. Their constraints became structured context for the workflow.
Kiro wasn’t guessing the product. Its context was earned - through close collaboration with stakeholders and six partner teams across product, design, backend, frontend, infrastructure, and release - then clarified and encoded so the agent worked from what the people who run operations actually know.
How the workflow worked
A handful of layers turned that context into repeatable execution - each one a place where AI added speed and engineering kept control.
The workflow, in plain English
Persistent context about architecture, naming, shared libraries, state patterns, and testing expectations, so generated work matched the platform before review.
Steering, made concrete
Steering files gave Kiro persistent, plain-language rules about the platform - where code belongs, what to reuse, how data flows, and what "done" means. A simplified excerpt:
# Steering - operations platform
ARCHITECTURE
- Code lands in the right Nx library by scope (feature / ui / data-access / util)
- A feature depends only on its own scope and "shared" - no cross-app imports
- Respect module boundaries; no deep relative paths across libraries
UI
- Reuse design-system components; never recreate primitives
- Keep presentational components dumb; state and side effects live in facades
DATA
- All API access goes through data-access services and adapters
- Hide old/new API differences behind the adapter, not the screen
QUALITY
- Every change ships with tests and passes lint, build, and CI
- Run the affected-only checks before opening a PRThe rewrite also improved the hot path behind the UI
This was not only a frontend rewrite. We owned enough of the path - frontend workflows, backend APIs, performance-critical data, and selected infrastructure - to improve the experience end to end.
The key shift: move repeated work out of the user’s path.
Instead of every screen refresh triggering the same expensive chain of backend calls, a new v2 API layer served refreshed snapshots. One snapshot could cover the frontend’s full ~45–60s polling window, so repeated dashboard polls became cache hits instead of repeated upstream calls.
What changed, and why it mattered
One cached snapshot served ~45–60s of frontend polling - faster repeated refreshes, fewer backend calls during normal use.
Technical implementation notes
New read endpoints for the operational data the dashboards query most - asset and fleet lookups, search, status, deployment counts, health, and audit trails - shaped around how operators actually use the screens.
What it meant for operations
Faster screens, fresher data, lower cost - without risk to the people already relying on the tools.
10× less
backend calls during a normal dashboard session - screens feel instant
Real-time
operators see live, same-or-fresher status, even at peak - no more lag
Zero downtime
improvements shipped behind new endpoints - no migration, no risk for existing users
Lower cost
repeated work moved off the hot path, trimming cloud spend at peak
The operations dashboard: preserving operational knowledge
The operations dashboard was the highest-pressure track because it carried legacy knowledge forward - years of accumulated behavior, environment assumptions, and UI decisions.
For users, the value was continuity without legacy drag:
- familiar workflows stayed intact
- the app moved into a cleaner shared shell with current design-system usage
- backend differences were normalized behind services and adapters
- the codebase could evolve alongside the two new apps instead of staying a one-off island
The same practice that modernized the legacy dashboard also started the two greenfield apps from zero - inside the same architecture from the first commit.
How we knew it was safe to ship
No single tool, prompt, or test carried the system. Quality was layered, and humans owned the bar:
AI made these patterns faster to apply. The patterns kept the work enterprise-grade.
The guardrails
Engineers owned architecture, quality, and release readiness; intent and design were approved before implementation accelerated.
Why it worked
The win was not that an agent wrote more code.
The win was turning messy enterprise delivery into repeatable, governed execution - without making quality negotiable.
Delta had the AI tool standard. We brought the operating discipline (product context, architecture, specs, scoped capabilities, automation, and gates) and shipped one legacy rewrite and two greenfield operational apps in three months inside a large Angular/Nx monorepo, with Delta’s standards intact.
Anyone can run the agent. The value is the discipline around it that lets AI move fast without breaking the platform.