This case study is protected by NDA

It is extremely easy to get started with Terraform, AKA "day one" but scaling past that, "day two" is difficult

Security teams could spot misconfigurations but didn't own the code. Platform teams owned standards but not every repo. App teams were closest to delivery but rarely set up for infra remediation. The result: handoffs, backlog churn, and a pile of repetitive work that mattered but belonged to no one.

I approached this as a workflow design problem, not a generic AI feature.

My role was to figure out what the first useful experience should be, where trust would break down, and how the workflow could fit the way Terraform teams already operated. I pulled together customer-zero conversations, engineering syncs, and product discussions to find the focus. Three signals kept coming up.

A focused remediation loop: detect issue, generate fix, open PR, human review.

We kept the scope tight: one workflow, one loop. The agent finds a remediation opportunity, generates a proposed change, and writes it back through PR mechanics. Every surface points back to that same loop, with enough context at each step that a reviewer can actually act on it.

Auto raising PR's on Github to reduce toil and cutdown on time to remediation.

Logging all actions that an agent takes to drive trust in the system.

Presenting code diffs so that a user understands why a change is being made.

The empty state is a product moment, not a placeholder

Challenge: Agentic workflows ship off by default. Without a meaningful landing, teams that would benefit from this just never turn it on.

Decision: I designed the pre-enablement page to do real work. It leads with what the agent can do, shows a preview before anyone commits to enabling it, and introduces each available agent by name. By the time someone hits "Enable agentic workflows," they already understand what they're signing up for.

Pre-enablement landing: the agent introduces itself before asking for commitment.

Make trust visible inside the workflow

Challenge: An auto-created PR is meaningless without context. Teams needed to understand why a change existed before they could act on it.

Decision: Confidence signal, rule context, blast radius, and a history of prior PRs were not extra polish. They were the product. I treated each as a required surface. Without them, the PR exists but cannot actually be reviewed.

Treat write-back as a reusable product surface

Challenge: Every new integration would arrive with its own conventions. Designing a one-off handoff each time wasn't going to scale.

Decision: I built write-back around three shared surfaces any source can plug into: a unified PR feed, a normalized findings inbox, and a per-finding inspect view with the rule, recommended diff, and reasoning trace.

Per-finding inspect view: rule, diff, confidence, and reasoning. Everything the reviewer needs before deciding.

Make agent actions auditable, not opaque

Challenge: When an agent acts autonomously, "what did it actually do?" becomes a trust question fast.

Decision: I designed agent logs as a first-class surface, not a debug afterthought. Every job captures a full event stream: deploys, tool calls, results, successes, and failures. Admins can drill in and replay exactly what happened, in order. That verifiability is what makes the rest of the workflow safe to leave on.

Agent log drill-down: a full event stream per job run, replayable in sequence.

Favor the user's operational model over the simpler technical model

Challenge: Repo-based onboarding was technically simpler, but it obscured blast radius and ownership, especially in monorepos and shared-module setups.

Decision: I pushed for workspace and project context over repo-based thinking, because it matched how Terraform operations are actually managed. That gave teams a clearer sense of what the agent was acting on and fit the mental model they already used.

In enterprise AI, the product is not just automation. It is automation people can understand, verify, and safely act on.

We narrowed a broad agentic concept into a focused remediation workflow and made trust requirements explicit. Confidence, explainability, blast radius, and history were core, not extras.

This project sharpened how I think about AI in enterprise products. The design problem was never "how do we add an agent?" It was how to make automation feel accountable inside a messy system of repos, workspaces, permissions, and human ownership. The more powerful the automation, the more important it is to design for verification, control, and shared understanding.