← All Posts

I Use AI vs I Engineered an AI Practice

Technology

Most people use an artificial intelligence (AI) assistant as a smarter autocomplete. Over the past two months of Friday posts I have described something else: an operating system for my own work, built on top of one. Each post took a layer and shipped a file. This is the map, the seven principles that tie the layers together, and the difference between "I use AI" and "I engineered an AI practice."

Five Layers and the Thing That Maintains Them

LayerWhat it doesThe post
InstructionsGoverning rules that shape every response, including the gateThe Gate That Fires Every Time
MemoryLayered persistence so a lesson survives across sessionsRight Knowledge, Right Lifetime
SkillsDocumented, tested playbooks loaded on demandWrite the Skill, Not the Answer
AgentsSpecialized workers for scoped tasks that return one reportGo Do X and Report Back
Session historyA queryable log for standups, search, and self-improvementThe Record You Can Mine
Background tasksThe upkeep that keeps the other five honestA Workspace That Maintains Itself

Everything is progressive disclosure. Only the rules, skills, agents, and memory relevant to a given task load for it, which is how a library of dozens of capabilities costs almost nothing until one is needed. The design goal is simple to state and hard to hold to: minimize the work I have to do to get a correct, on-brand, actionable result, and make the assistant's behavior reproducible rather than lucky.

Seven Principles

PrincipleIn one line
Progressive disclosure everywhereLoad only what the task needs; context stays lean and behavior stays focused
Determinism over vibesRules key off observable signals and produce pass or fail checks, so behavior is reproducible, not lucky
Verify, never assumeSchema, status, and facts are confirmed against the source before use; no fabrication, no inferred status
Minimize the human's workReprint whole drafts, give clickable links not identifiers, hand over exact runnable commands
Capability compoundsA novel solution becomes a skill, a lesson becomes a memory, a task becomes a logged session
Right knowledge, right lifetimeThree memory scopes and path-scoped instructions mean context is neither lost nor over-shared
Governed, not freewheelingPreflight gates, backup before edit, and marker-preserving publishes protect against the failure modes that matter

If I had to defend two, it would be the second and the fifth. Determinism over vibes is why any of this survives a long session: a rule that fires on a signal the model can see in its own output does not decay the way a remembered preference does. And capability compounds is why the system is better this month than last. Nothing is solved twice. The cost of every improvement is one file, written once.

What It Adds Up To

The assistant sounds like me, because the formatting and style rules are mechanical and it cannot be spotted as machine-generated. It does not repeat mistakes, because memory is layered and consulted before acting. It has a growing library of documented, tested capabilities and a roster of specialized workers. It verifies before it asserts, because data and content integrity are gates, not intentions. It maintains itself. And it keeps a queryable record of everything it did.

None of it is proprietary and none of it depends on a particular vendor. It is a pattern, not a plant. Every piece is a text file, and every file was written at the moment something went wrong for the second time.

The Difference

"I use AI" means the assistant is very good and you hope it stays that way. "I engineered an AI practice" means its behavior is reproducible, governed, and compounding, and you can show someone the files that make it so. The second one takes longer to set up and it is the only one that gets better with use.

If you build one layer, build the gate. If you build two, add memory. Everything else in the table above is downloadable from the post that describes it, and each one is a Friday afternoon's work.

0 Comments