AI drafts, humans decide: building an AI-native operations practice
When the company went AI-first, most functions used AI harder on individual tasks. I built AI into the operating system itself: encoded knowledge, reusable skills, and governance, so the leverage compounds instead of resetting every chat.
The setup
The company went AI-first from the top, which is the easy part. The hard part is what happens next, and at most companies what happens next is that everyone uses AI harder on individual tasks. Every chat starts from zero. Every session gets re-briefed by hand. The output improves; nothing compounds.
There’s also a quieter failure mode, and operations sees it first: AI amplifies whatever process it runs on. Clean systems make it a multiplier. Dirty systems make it confidently wrong at scale. An org that automates on top of ambiguous process doesn’t get faster; it gets wrong faster.
I responded to the mandate differently. Instead of using AI harder, I built it into the operating system itself: encoded knowledge, reusable skills, and governance, so that leverage compounds instead of resetting every conversation.
Where I came in
This work sits on top of everything else in this portfolio. The process data contract was designed so that gates assert artifact states, not authorship, which means AI taking over the production of an artifact changes nothing in governance. That’s what “AI-ready process” actually means, and it was designed before the first skill was built.
My role here is practitioner and evangelist, in that order. Not “used AI tools.” Built the durable infrastructure an operations function needs for AI to be safe, fast, and boring.
The third time you do something manually, you build the system.
What I built
An enterprise AI knowledge architecture. A dedicated project with curated knowledge files: a canon index, stakeholder map, strategic frames, active workstreams, and a decision log. Every session starts oriented instead of re-briefed. Front-loaded context, treated as infrastructure rather than as each person’s private prompt hygiene.
A custom org-process skill. The full delivery model encoded so any team member’s AI assistant answers process questions from the current canon rather than stale docs. This is the process contract paying rent: the skill renders the canon, so it can’t drift from it.
A slide-generation skill. The deck design system encoded as a skill: design tokens, eight slide archetypes as templates, writing rules, and honesty guardrails. It turns “make me a slide about X” into a render-ready, on-brand artifact. I built it the day after a stakeholder deck request, on the third-time-manual principle above.
The governance layer, designed rather than defaulted. AI never claims in-development capabilities are live. A canon-vocabulary-only rule prevents invented process facts. The dashboard’s embedded assistant answers from registered sources only and declines rather than improvises. None of this was a policy memo; all of it is encoded in the tools themselves.
The skill shipped production output the day it was built: seven slides for a leadership-facing planning deck within hours of upload. Two things happened that day that are worth telling honestly. The honesty guardrail generalized unprompted, labeling every unconfirmed date “pending approval” without being asked. And human review caught two errors the AI had introduced, a taxonomy typo and a date-logic gap, before the deck shipped. That’s the “AI drafts, humans decide” loop working as designed. The system’s value includes the review layer, not despite it, and the honest version of this story is stronger than a flawless one.
Making it stick
Speed is the adoption argument, so here are the receipts, dated and unembellished. A stakeholder asked for a simplified planning view; a full branded five-slide deck was delivered the same day, built in under ten minutes from an existing canonical one-pager. An executive deck request arrived after hours; it was delivered by 9am the next morning. The slide skill went from built to uploaded to tested to producing shipped deck content in a single day, July 10, 2026, and the deck it fed grew from five slides to a complete seventeen-slide operator’s deck that same day.
The pattern worth naming: the speed came from the system, not from heroics. The canon existed, so rendering a new surface took minutes. Nobody stayed up late; the infrastructure did the work.
Cost discipline is part of the practice too. Single calls over agent loops, batched changes, artifacts as files rather than chat output. AI spend is an engineering budget like any other, and treating it that way is part of what makes the practice durable rather than a honeymoon.
Impact and results
The operating model was AI-ready before the AI arrived. Because gates assert states rather than authorship, delegating artifact production to AI required zero governance changes. Verification is what makes delegation safe.
Deck and doc production moved from days to minutes, with the quality floor enforced by encoded design systems rather than by whoever is best at slides.
Governance holds in production. The guardrails have been exercised, not just written: unconfirmed dates get labeled, invented vocabulary gets blocked, and the assistant declines questions its sources can’t answer.
Reflections
What I’d do again: build governance into the tools instead of writing it as policy. A guardrail encoded in a skill fires every time; a policy memo fires until people stop reading it.
What I’d do differently: log the review catches from day one. The two errors human review caught are the strongest evidence in this story, and I nearly didn’t record them because the instinct is to tell the flawless version.
Where it’s going: onboarding others into the practice. The knowledge architecture and skills were built to be provisioned, not hoarded, and the next measure of success is how many people run this loop without me in it.