I build with AI. For real, in production.

Agents with roles, routing, skills and memory.
Claude Code for the orchestration. MCP to reach the tools that matter.
Real auth - SSO, SCIM - because serious software needs it.
A human approves anything public, money, or irreversible.
This is where I write about how it's built.

Why I built it

I wanted leverage without headcount. Real work done by a system I could reason about, not a pile of one-off prompts. So I built an agent OS from scratch - routing, roles, skills, memory - on Claude Code. Small enough to hold in my head, serious enough to run in production.

How it works

Routing
Work lands in the right place. The system knows which agent, which skill, which repo - without me routing every task by hand.
Roles
Each agent has a seat with a boundary. Vault editor, product reasoning, code review - defined roles, not one blob of AI doing everything and doing none of it well.
Skills
Repeatable playbooks encoded once and invoked on demand. Draft the post, run the audit, commit and open the PR - the work that used to need a hire becomes a command.
Memory
Context persists across sessions in plain markdown - facts, decisions, daily logs, three tiers deep. The system remembers, so it never starts from a blank page. This is the part most people get wrong.

Claude Code, plugins and MCP

Claude Code runs the orchestration. The repeatable work is packaged as plugins and skills, so a job that used to take a person becomes one command that any agent in the system can call.

MCP is how it reaches the real world. I build MCP servers so an AI can drive live tools directly - create records, move money, touch the systems a business actually runs on. Not a chatbot that answers. Software that acts.

When a new capability ships, I turn it into something working in days, not quarters. That gap - between a release note and a tool you can actually use - is where most of the value is, and it is the part I enjoy most.

Auth that holds up

Here is the half that makes AI software safe to hand to a business: real identity. SSO, SAML and OIDC. SCIM provisioning. Roles, seats and spend limits.

It is the plumbing nobody demos and every serious deployment needs. I build it in, because software that touches other people's data and money has to be accountable before it is clever.

A human stays in the loop

One rule I never relax. Anything public, anything involving money, anything you cannot undo, waits for a person. The agents do the work. I sign it off.

That is not caution for its own sake. Leverage without control is just a faster way to break things. The approval gate is the design, not a limitation on it.

In production

This is not a lab experiment. It runs in production - live users, real billing, real consequences. Built, shipped and maintained end to end.

I even pulled the engine out of my own setup and it stood up as a product of its own - Corey. It built its own website and wired its own checkout with barely a hand on the wheel. If a system can build and sell itself, it can do the day job. Proof, not a promise.

The writing is where I work it out in the open - articles and notes on what I am building and what it is teaching me.

Principles

  • Leverage beats headcount.The repeatable work should not need another hire.
  • A human stays in the loop.The system does the work; a person approves what ships. Always.
  • Your stack, not mine. It reaches into the tools you already use over MCP. Not another platform to migrate to.
  • Ship small, ship often. Trust is earned one real task at a time.