Notes

Artificial Intelligence

Building an AI Operating Model by Using It

I started by using AI to rebuild my portfolio. Along the way, I began writing down how I work so an AI collaborator could take on more of the process.

Michael Whitaker20 min read

I was rebuilding my design portfolio when this started. I had years of project material scattered across Figma, old presentations, research notes, and folders full of screenshots. Plenty to work with. A crap ton to sort through, too.

AI (GPT, Make, Claude) was already helping me plan and outline the site and studies, work through design iterations, write code and work through the content. As I used it more and became more fixated and curious, I started paying attention to everything I was doing around those tasks: explaining the project again, deciding what came next, checking the work, and reminding it of decisions we'd already made.

I was doing a lot of that in my corporate design and product work. I was coordinating the process, and much of the process still lived in my head.

I want to see how much of that knowledge I can get out of my head and make usable by an AI collaborator. My future projects (at varying stages) can have AI take on more responsibility without needing me to direct every step, but also allow me to understand and review said steps and be the one to approve things like merges. That's the goal at least.

That rabbit hole of exploration is what I'm calling my "AI Operating Model", or AIOM. In practice, it's very much an AI-assisted operating model, with me still acting as the owner and decision maker.

My portfolio site is still where I test it. Eventually, I'd like to carry the useful parts into other projects without rebuilding the whole working process each time. I started that work on a couple new projects to test the AIOM even further. One is for pleasure and the other is out of necessity! A running club website frontend with authenticated backend for member access. There is only one club member right now. Yes, it's me. I'm the only member of my own club that is fully branded and in pursuit of a fully functioning website and member area! See my reasoning. (opens in a new tab)

The other site is being built out of pure frustration with the current hiring market for senior-level design IC and leadership roles. I'm calling that project "MGLO Job Hunt". A private, local-first job-hunt system for tracking applications end to end (intake/capture, track, resume/answer/profile management, and (wip) browser automation for filling out applications) with me reviewing before submissions. It's not a public job board. It is a single-user personal productivity app that runs on my own machine against my own data.

More on those projects later. I'll cover how my AIOM is orchestrating their discovery, design and builds in future Notes.


Coordinating the work became its own project

Back to my portfolio refactor. The individual tasks were fairly easy to hand off. AI could critique an interface, help structure a case study, or write the React for a page. Keeping the work moving coherently and timely took more effort.

I kept having to determine which source material was reliable and whether I had given enough context to continue. I needed to decide when a review was necessary and where my approval actually mattered. Starting a fresh session meant figuring out how to get it caught up without retelling the entire project.

I've experienced and worked through versions of these problems on my human teams.

Side note: what a time to be alive when we have to specify our colleagues as humans or robots. Could be animals too, depending on industry, I suppose.

Teammates needed to understand their responsibilities and have enough context to make decisions. They also needed a shared understanding of what good work looks like and when it's ready to implement and release.

I started putting those expectations into the portfolio repo. Workflows described how to approach recurring tasks. Standards gave the reviews something concrete to check. I documented decisions and made my authority explicit where I needed to retain it.

Over time, the repository began to hold a usable record of how I wanted the work done. That gave each new session somewhere to start.


Giving the operating model a home

As more of that structure took shape, I separated the reusable pieces from the portfolio itself.

┌───────────────────────────────────────────────┐
│                  MWD AIOM                     │
│                                               │
│   Reusable operating-model architecture       │
│   Core + Seed + Kernel + Bootstrap rules      │
│                                               │
│                 mwd-aiom                      │
└──────────────────────┬────────────────────────┘
                       │
                    Bootstrap
                       │
             ┌─────────┴──────────┐
             ▼                    ▼
┌──────────────────────┐  ┌──────────────────────┐
│      Portfolio       │  │    Future Project    │
│                      │  │                      │
│ application code     │  │ application code     │
│ project state        │  │ project state        │
│ workflows            │  │ workflows            │
│ decisions            │  │ decisions            │
│ knowledge            │  │ knowledge            │
└──────────────────────┘  └──────────────────────┘

Figure 1. The reusable AIOM is separate from the applications that operate under it. Projects maintain their own code, state, decisions, and knowledge.

The mwd-aiom repo holds the operating model. Each project keeps its own application code and the knowledge that belongs to it.

I'm not treating mwd-aiom as a starter app to clone and rename. A portfolio case study needs a different review process from a running club app or a job hunting app. A project handling sensitive data will have requirements that a simple marketing site may never need.

The shared model should give those projects a starting structure while leaving room for their actual needs. Otherwise, I'd just be making every future project inherit the quirks of my portfolio.


What belongs in Core

I separated the architecture into layers to help decide where things belong.

AIOM Core covers the operating responsibilities I expect to need across projects, including coordination, authority, and validation. Capability Bundles group related abilities that a project might use. Each project then activates the capabilities relevant to its work and adds its own standards.

┌───────────────────────────────────────┐
│              AIOM CORE                │
│                                       │
│ orchestration                         │
│ authority                             │
│ state                                 │
│ governance                            │
│ validation                            │
│ knowledge                             │
└──────────────────┬────────────────────┘
                   ▼
┌───────────────────────────────────────┐
│         CAPABILITY BUNDLES            │
│                                       │
│ reusable groups of related abilities  │
│ selected according to project needs   │
└──────────────────┬────────────────────┘
                   ▼
┌───────────────────────────────────────┐
│           PROJECT AIOM                │
│                                       │
│ project context                       │
│ activated capabilities                │
│ governed work                         │
│ Owner authority                       │
│ project-specific standards            │
└───────────────────────────────────────┘

Figure 2. AIOM separates universal operating responsibilities from reusable capabilities and project-specific implementation.

I've had to be careful about what "available" means here. A capability can be relevant to a project without being activated. An activated capability may still be unavailable in the current runtime. Having access to it also doesn't give AI permission to use it however it wants.

For example, the AI collaborator might have the tools to publish a site. The project may need those tools eventually. I still need the operating model to recognize whether publishing is authorized at this point in the work or not. That is needed more as more capabilities are added.


Where Skills and Plugins fit

As I was building this, Claude's Skills and Plugins gave me another way to think about the boundaries.

Specialized capabilities can help with design reviews, specifications, or work in Figma. There's plenty of overlap with tasks I'd already been trying to support. That helped me reconsider how much expertise I should be encoding myself.

If a good design-review capability already exists, I want to use it. My job is to define what that review needs to accomplish in this project. It needs to know which standards apply, when the review happens, and what to do with the findings.

A Skill or Plugin can carry instructions and provide access to tools. It still needs the project's context to participate in the workflow I've established. Access to a Figma file, for example, doesn't tell it whether the current work is ready for visual review or whether a finding requires my decision.

┌─────────────────────────────────────────────┐
│                  MWD AIOM                   │
│          How does work get done?            │
├─────────────────────────────────────────────┤
│ Lifecycle and state                         │
│ Orchestration                               │
│ Authority                                   │
│ Governance                                  │
│ Workflows                                   │
│ Capability activation                       │
│ Quality gates                               │
│ Knowledge and decisions                     │
│ Validation                                  │
├─────────────────────────────────────────────┤
│ CAPABILITY PROVIDERS                        │
│                                             │
│ Claude Skills   Plugins   MCP               │
│ Claude Code     Scripts   APIs              │
│ Validators      Humans    Other AI          │
└─────────────────────────────────────────────┘

Figure 3. Skills, Plugins, tools, scripts, and even people can be capability providers. AIOM coordinates how those capabilities participate in governed work.

Writing is a good example, too. A brand-voice capability might help reproduce my style, but the portfolio needs specific guidance about how I describe my role and which terminology to preserve. It also needs to respect my writing and reflections. Reviewing, organizing, and refining my writing doesn't give it permission to make stuff up or invent new experiences or outcomes.

I'd rather spend my time defining those expectations than maintaining my own instructions for every possible task. As the available capabilities improve, I hope to have less of that generic guidance to maintain.


Testing it on work I actually needed

The portfolio gives me a practical place to test all of this. I have to be willing to put my name on the result and send it to someone.

One of the more useful tests was a case study for platform from my previous employer, a legal-tech modernization project I took ownership of rather quickly, called SDS. It involved an acquired enterprise legacy platform with two largely independent sub-applications. Each with their own distinct legal workflows. The work included accounting for an approved React migration and substantial UX strategy work. Research and discovery talking with the founder/managing director and a handfull of clients, auditing and evaluating the existing experience, and eventually redesigning workflows and aligning stakeholders around the direction. It was a big undertaking and loads of fun.

Because of the project scale, there was a lot of source material, and turning it into a case study required my hands-on oversight. The process had to distinguish documented evidence from my recollection and handle sensitive material appropriately. Then it had to turn all that context and material into a story and an implemented page that could pass review and be published.

I also wanted to see how much supervision the process really needed after I gave it my brain dump and supporting artifacts.

Earlier versions stopped for my approval at almost every decision point. That became so freaking tedious and had me questioning why I was even fooling with the AIOM. Once I'd authorized the work and set the boundaries, approving every ordinary transition added little value.

I started using appropriate autonomy to describe everything that I wanted. Let AI continue when the established policy gives it enough direction, and bring the decision back to me when it doesn't. I also wanted to keep explicit control over decisions that materially impact the final result.

During the that SDS case study creation, AI moved through substantial portions of the work without stopping at every phase. Specialist reviews found issues, and deterministic checks caught errors. Ambiguity still came back to me. Git delivery required explicit human authorization. Progress!

Reviewing the finished case study was more humbling.


I still wouldn't have sent the case study

The case study had passed the defined process. It was backed by evidence, the implementation had been validated, and accessibility had been reviewed within the agreed scope. It was merged and running in production (behind a PW gate).

Then I looked at it as something I'd send to a hiring manager. Definitely wouldn't send.

The basic structure was there, but the presentation needed work. Some of the strongest interface designs barely appeared. The before-and-after comparisons needed more attention, and the process artifacts could have done a better job explaining the decisions. The writing also needed tightening, especially around my role and the UX strategy behind the project and following what I wrote more verbatim.

I had a completed workflow, but a case study I wasn't comfortable using.

Evidence backed        ✓
Repository compliant   ✓
Implementation valid   ✓
Accessibility reviewed ✓
Production verified    ✓
Workflow complete      ✓

             │
             ▼

Audience ready         ✕

Figure 4. The SDS proving run exposed a gap between procedural completion and fitness for the artifact's intended audience.

That exposed a missing review near the end of the process. Before publication, I needed to look at the rendered case study and decide whether it served its intended audience. Passing the technical checks couldn't make that decision for me.

For everything I create and put my name on, my portfolio work in this case, I need to be comfortable sending to the person it was created for.

Adding that review made more sense than returning to approval at every phase. I want and need to spend less time supervising routine steps so I can give the final work the attention it needs.


Checking the work has its own failure modes

The SDS case study run also exposed a problem in evidence handling. File checksums confirmed that the archived files hadn't changed, but one artifact had been assigned the wrong identity.

The integrity check did its job, but misidentified what we were looking at.

That was a useful reminder to be precise about what a check actually proves. A checksum can verify that a file's bytes are unchanged. It can't tell me whether someone gave the file the right description.

Another error surfaced during Git delivery. The pull-request attribution conveyed the required meaning, but its Markdown formatting didn't match the repository's exact rule. The validator rejected it. AI corrected the formatting, and the check passed.

        AI REASONING
   interpretation + synthesis
             │
             ▼
      GOVERNED EXECUTION
             │
       ┌─────┴─────┐
       ▼           ▼
   SPECIALIST   DETERMINISTIC
    REVIEW         CHECKS
       │           │
       └─────┬─────┘
             ▼
      HUMAN AUTHORITY
   where consequence warrants
             │
             ▼
      PERSISTED KNOWLEDGE

Figure 5. AIOM combines model reasoning, specialist review, deterministic enforcement, and explicit human authority rather than relying on any one mechanism.

Those failures helped clarify how the different kinds of review should work together. Exact rules are good candidates for deterministic checks. Interpreting source material requires judgment. AI can do a lot of that work, but ambiguous or consequential interpretations still need my review and decisions. And may benefit from a focused specialist review. I keep the authority where I need to own the decision.

Better prompts can help, but I don't want every check to depend on an LLM interpreting an instruction correctly. I have so many freaking 'good' prompts that I forget to use when I'm in the zone knocking out work. I'm trying to move past that level.


Giving a fresh session somewhere to start

I also want to stop depending on one long-running conversation to hold the project together. We know how laggy and expensive long chats become. Especially cheap folks like me on the $20 plans across the board!

A useful conversation can accumulate a huge amount of context. Eventually, though, I need to start a new session. I don't want that to mean assembling another giant handoff and hoping I remembered the important parts.

The AIOM uses repository files as durable project memory, with operational state kept separately from the longer-term record of the work.

PROJECT REPOSITORY
│
├── .aiom/
│   │
│   ├── Project Profile
│   ├── Capability Activation
│   ├── Governed Work
│   └── Owner Approvals
│
├── docs/decisions/
│   │
│   ├── Observations
│   ├── Journal
│   └── ADRs
│
├── AGENTS.md
├── CLAUDE.md
│
└── application code

Figure 6. Project state and organizational knowledge live with the project so a fresh AI session can reconstruct what is happening without depending entirely on conversational memory.

The '.aiom/' directory describes the project and its active operating state. It records which capabilities are activated and which work is being governed, including the approvals needed to proceed.

I created a 'docs/decisions/' area that holds the history (knowledge capture): Observations, journal entries, and architecture decision records (ADRs). That's where a later session can find the reasoning behind a decision or learn about a problem I've already encountered. It's great for creating articles and case studies later as well for said projects. If used in a corporate setting, it would save me from utilizing outlook email search bar like the holy grail of past 'recorded' decisions from stakeholders and executives ;)

At first, doing the knowledge capture was annoying as I was ready to jump to the next task after I just finished a big chunk of work, then ask each time to do a review of the work and evaluate if any knowledge capture is needed or useful. Now it's started getting better to the point where I can review/approve the capture type suggested or skip and move onto my next thing.

During the SDS run, fresh Claude Code sessions were able to reconstruct meaningful project context from the repository. That gave me some early confidence in the approach. I still want to test it more formally after bringing the existing portfolio under the reusable AIOM architecture.

Keeping these records in Git also lets me inspect how the operating model changes alongside the work.


Making use of what goes wrong

I want these next project(s) to benefit from what I've learned on this one. That means capturing findings in a form I can revisit and deciding which ones deserve a change to the system.

The SDS CS produced Observations about approval cadence and evidence verification, along with the gap in audience readiness. Some of those findings may stay specific to the portfolio. Others could inform a reusable Capability Bundle. A finding needs stronger support before I'd put it into Core and have it affect every project.

        PROJECT WORK
             │
             ▼
           FINDING
             │
             ▼
         OBSERVATION
             │
             ▼
      ADDITIONAL EVIDENCE
             │
             ▼
    DOES IT GENERALIZE?
         │          │
        NO         YES
         │          │
         ▼          ▼
      PROJECT    AIOM INVESTIGATION
                     │
                     ▼
              DURABLE DECISION
                     │
                     ▼
                CORE / BUNDLE
                     │
                     ▼
               FUTURE PROJECTS

Figure 7. Project experience can become evidence for improving the reusable operating model without automatically turning every local lesson into universal policy.

I'm trying to avoid turning every frustrating afternoon into a new universal rule.

The finding gets recorded where it happened. Then I can look for more evidence and decide how broadly it applies. That gives the operating model a way to improve while keeping local problems in proportion.

AIOM needs the same scrutiny as the work it governs. I expect parts of it to change as I learn where the current structure helps and where it gets in the way.


What is actually built

After the SDS run, I went back to mwd-aiom for a read-only implementation assessment. I wanted a clear account of what existed and how well it had been tested. An architecture decision can describe an intended feature long before there's working code behind it, and I needed to keep that distinction straight.

The assessment showed that the implementation was farther along than I'd remembered.

The Core Seed is implemented. It includes the operating-model definitions and safeguards, along with the Bootstrap process, capability catalog, and project templates. It also provides guidance for how a runtime discovers the project's instructions.

The Minimal Executable Kernel is TypeScript code. It has schemas and deterministic validation, checks proposed state transitions, and includes a Runtime Probe. It also implements runtime-neutral orchestration and Bootstrap behavior.

A working invocation layer and CLI provide a way to use it. The CLI can bootstrap an external project or validate existing AIOM state. It can also evaluate a proposed Work Item transition and return an orchestration disposition describing how the work should proceed.

At the time of the assessment, 299 tests across 40 test files passed, along with linting, type checking, and build validation. Packaging was tested too: a packaged version could be installed outside the source repository and exercised end to end.

┌─────────────────────────────────────────────────────┐
│                     mwd-aiom                        │
│                                                     │
│   CORE SEED                     EXECUTABLE KERNEL    │
│   policy + templates            deterministic code  │
│          │                              │            │
│          └──────────────┬───────────────┘            │
│                         ▼                            │
│                    INVOCATION                        │
│                  CLI + runtime                       │
└─────────────────────────┬───────────────────────────┘
                          │
                      BOOTSTRAP
                          │
                          ▼
                 PROJECT REPOSITORY
                          │
              ┌───────────┴───────────┐
              ▼                       ▼
         LOCAL STATE             LOCAL KNOWLEDGE
           .aiom/               docs/decisions/

Figure 8. MWD AIOM v0.1 now combines reusable policy and templates with an executable kernel that can bootstrap and validate project-local operating state.

Bootstrap starts with inspection. A reasoning runtime, which can be AI or a human, examines the target repository and supplies the decisions required by the Bootstrap contract. The executable Bootstrap validates those decisions. With an explicit materialization destination, it can then create the project's .aiom/ state and runtime-discovery instructions.

That initial state includes a Project Profile and Capability Activation Record. It also establishes the first governed Work Item and retains a snapshot of the Seed used to initialize the project.

An earlier version had already been tried on Chicago Mountain Runners(my running club project), a relatively simple new project. That experiment predated the supported CLI, so it used an ad hoc bridge into the Kernel. This is why I need to work on one thing at a time!

The weakness it revealed was after Bootstrap. An Invalid Work Item state could accumulate if the Kernel wasn't invoked again. There was no delivery gate, and the project's AIOM state was never fully reconciled afterward.

The Kernel can check the rules when it's called. It can't currently make an AI runtime call it.

A generated workflow contract can instruct Claude Code to validate state at the beginning of a session. If Claude follows that instruction, the deterministic check runs. If it skips it, there isn't yet a mechanical enforcement layer that stops the work.

The current system has other limits. Seed upgrades and reconciliation aren't implemented. There isn't a general deterministic API for managing the Work Item lifecycle after Bootstrap. Delivery authorization isn't directly connected to an actual Git push, pull request, or deployment. Portability beyond the current Node and Claude Code path is also largely unproven so far, but I have plenty of time. I'm only 43!

Those limits matter when I describe AIOM v0.1. The code and tests establish a working foundation, but reliable use across projects still needs work and evidence to build and mature from.


Bringing it back to the portfolio

The next planned test is to use the supported v0.1 distribution on the portfolio itself. It's the 'brownfield Bootstrap proving run'. GPT or Claude gave it that name. I'm not that smart. Basically, I'm testing whether AIOM can adopt an existing project that already has its own ways of working.

The portfolio version of the AIOM is much more involved than the run club, job hunt, or another new project. It has established workflows and specialist roles, plus a substantial history of decisions. It also contains the earlier repository-local operating model that informed AIOM in the first place.

There's useful work in there that Bootstrap needs to preserve.

Before allowing it to write any sort of AIOM state, I want to see whether it understands the environment it has inspected. It needs to recognize the existing governance and where I retain authority. It also needs to identify which capabilities belong in this project and what the next governed action should be.

If that succeeds, the test continues across fresh Claude Code sessions. Each session should discover the project state, follow the runtime instructions, and invoke validation at the required boundaries. It should be able to recover the next action and continue real portfolio work from the repository's records.

Annnnd that should help me see if the code isn't running or calling functions properly when I start up a new project or new feature on an existing one. I already know the Kernel can perform checks. I need to observe whether the runtime calls it consistently when the contract requires it, and what happens when it doesn't.

I want that information before spending more hours and tokens designing more enforcement around the issue.

The same restraint applies to the SDS findings. I have useful evidence about visual storytelling and authorship fidelity, as well as the approval and verification issues. Another proving run should help me decide where the changes belong. Some may affect the Kernel or Bootstrap. Others may be better handled in a Capability Bundle or left in the portfolio's own standards, not in the reusable AIOM.

PORTFOLIO EXPERIMENT
        │
        ▼
SDS AUTONOMY PROVING RUN
        │
        ▼
OBSERVATIONS + ASSESSMENT
        │
        ▼
MWD-AIOM IMPLEMENTATION AUDIT
        │
        ▼
CURRENT V0.1 STATE ESTABLISHED
        │
        ▼
PORTFOLIO BROWNFIELD BOOTSTRAP
        │
        ▼
MULTI-SESSION GOVERNED WORK
        │
        ▼
OBSERVE + CAPTURE EVIDENCE
        │
        ▼
EVIDENCE-DRIVEN AIOM IMPROVEMENTS
        │
        ▼
REMEDIATE SDS USING IMPROVED AIOM
        │
        ▼
TEST ON AN INDEPENDENT PROJECT
        │
        ▼
LEARN AGAIN

Figure 9. The next proving run moves from testing workflow autonomy to testing whether the reusable AIOM can safely adopt and govern a mature existing project.

I'm also interested in how this changes as Skills, Plugins, and other AI capabilities improve. If they reduce the amount of specialist guidance I have to maintain, great. I'd be happy for the durable part of AIOM to get smaller.

The project will still need a record of its context and decisions. It will still need to establish what is authorized and how the result should be checked. Those responsibilities persist even if I change the model or tool doing the work.

CONTEXT
   ↓
STATE
   ↓
WHAT SHOULD HAPPEN NEXT?
   ↓
WHICH CAPABILITY?
   ↓
IS IT AUTHORIZED?
   ↓
EXECUTE
   ↓
VALIDATE
   ↓
DOES A HUMAN DECISION MATTER HERE?
   ↓
PERSIST WHAT WAS LEARNED
   ↓
NEXT GOVERNED ACTION

Figure 10. The provider can change while the operating model continues to govern why work happens, when it happens, what authority applies, how it is validated, and what the system learns afterward.

I started this because I wanted help getting my portfolio built. Working through it has given me a way to examine how much of my own professional experience and expertise can be made explicit and useful to an AI collaborator.

Some of it can be written as policy. Some can be enforced in code. Other decisions still need me to look at the work and take responsibility for it, as the SDS case study made clear and some other case studies if I'm honest!

At this point, I have a reusable Seed and executable Kernel, with a supported way to invoke them. I also have my run club project outside the portfolio that showed how easily the controls can go unused, along with the job hunt project giving me a different environment to keep testing the model.

The next step is to bring those pieces back into the AIOM project where this started and see whether they can support the work without losing the knowledge already there. If that holds up across fresh sessions, I'll have a much stronger reason to keep tinkering away and using it in the future.

This article was drafted by GPT Sol 5.6 from lotsa knowledge capture and a big Michael brain dump. Then I still rewrote a bunch of it because I didn't understand half of what it was saying and I don't want anyone to think I know what I'm doing. That's a lesson in itself.