ai-org: scaffolding I clone into every new project

The most important thing when working with AI is the folder and file structure. Not the prompts. Not the model. The scaffolding the AI reads before it does anything.

I was rebuilding that scaffolding from scratch every time I started a project. So I packaged it. ai-org is the reusable structure I clone into every new repo, distributed as a Claude Code plugin that installs in seconds.

I run multiple projects in parallel: invoo.es, this portfolio, Deck IDE, ai-org itself. Each one started with a slightly different scaffold. Configs drifted. Agent definitions diverged. Decision logs lived in different places, or nowhere.

AI worked in every project. It just worked inconsistently, because the context around it was inconsistent. The bottleneck was never the model. It was the repo it walked into.

Split the system into four portable layers and ship them as one plugin.

Agents carry a point of view. Each one is opinionated, with a defined personality and domain. Skills layer abilities onto agents through explicit dos, don'ts, and rules. Commands trigger workflows so the system is easy to invoke. Product knowledge lives in the repo: initiatives, research, the standard product pipeline, all readable by the AI as real context instead of guesswork.

Distribute it through the Claude Code marketplace. One install, every project gets the same bones.

Four building blocks, all files in the repo.

An agent is a markdown file with a role, a POV, and a tone. The brand-positioner pushes back on vague claims. The code-reviewer is blunt about quality. Eighteen specialists across seven domains, each with a job they actually own.

A skill is a smaller module: a list of dos and don'ts attached to a task. Accessibility rules. Naming conventions. When to write a test, when not to. Over forty of them, composable across agents.

A command is the trigger. /feature runs a phase-gated workflow: Plan, Build, Test, Review, with gates between phases so nothing skips ahead. /review runs four sequential reviewers covering spec compliance, functional correctness, code quality, and architecture. /explore researches without touching code.

Product knowledge sits next to the code. Initiative briefs, research notes, decision logs, all committed to git. The AI reads them before it does anything, so it works with real context instead of generic answers.

The coordination layer ties it together. Claude Code reads project memory, picks the right agent for the phase, manages handoffs between them. Every decision gets logged to a memory file committed to git, so the next session picks up where the last one stopped.

Build observability from day one. I can tell the system works because the output is good and the bugs get caught early. I can't tell you which agent caught what, how often a skill changed an outcome, or where time actually goes in a /feature run. I'm flying on vibes and shipped features. Both real, neither measurable.

The deeper lesson: the hard part was never the agents. It was the folder structure they sit inside. I spent the first month tuning prompts and personalities. The unlock came when I stopped touching the agents and started fixing where the knowledge lived, how commands found it, what the AI saw before it started thinking. Get the scaffold right and average agents do great work. Get it wrong and the best agents stall.