Ace Level 1

Ace Level 1 is the no-frills entry point to the system I use to run my companies with AI agents. You clone the repo, open it in Claude Code, type start here, and ten minutes later you have a workspace that captures your work, tracks your goals, and saves itself to git on demand.

This write-up is the talk behind the repo - Get a Grip on Your Business Brain - in readable form. If you’d rather skip the why and just build, go straight to the repo.

Why I built this

Current AI systems are not built for business. Out of the box, a coding agent gives you three problems that compound:

• Cognitive debt. Every decision, every piece of context, every “why did we do it this way” lives in your head or in a chat scroll that nobody will ever read again.
• Context switching. You run more than one thing - projects, clients, functions. Each switch throws away the state you had loaded, and rebuilding it is where your day goes.
• Entropy. Give an agent free rein in an unstructured folder and you get sprawl: duplicated files, orphaned drafts, conventions that drift by the week. Left alone, the workspace rots.

The fix isn’t a smarter model. It’s structure the model can hold onto.

How your business actually works

Strip any business down and it has the same shape:

1. Your business: purpose, values, vision, culture, org chart.
2. OKRs: objectives and the key results that measure them.
3. Projects and tasks: what’s being done, why, by who, by when, and the assets around it.
4. Work and decision logs: what actually happened, and what was decided along the way.

Everything flows down that spine: the purpose justifies the objectives, the objectives justify the projects, the projects generate the work, and the logs record it. When your workspace mirrors this shape, an agent can navigate your company the way it navigates a well-organized codebase.

The interface, in levels

You don’t need to build a platform to start. There are three levels:

• Level 1 - Claude Code with hooks and markdown files. This repo. Your whole company brain is folders, .md files, and YAML, with Python hooks that capture work as it happens.
• Level 2 - dashboards plus Telegram or Slack. Same brain, more surfaces: status boards and chat access for the team.
• Level 3 - database, interface, and users. The full operations platform, when the file-based brain outgrows files.

Level 1 is deliberately humble, and that’s the point: it proves the whole model with nothing but a repo.

Below the hood

The engine is whatever LLM you point at it - Claude, Codex, anything competent. The engine is swappable. What makes the system work is not the engine; it’s three things layered on top:

1. Memory
2. Automation
3. Human / agent alignment

1. Memory

Continuously capture the pieces of information a business actually runs on: what was decided and why, what was actually done, by who, and when.

At Level 1 that’s a temp log, written as work happens:

2026-04-29 @ 10:00am
@41fred
- Decided on content A vs content B because...
- Designed Klaviyo email with /email-skill
- Scheduled for mm/dd/yy

Unglamorous, and that’s why it works. An agent consolidates these into monthly session logs, so the raw capture stays cheap and the record stays organized.

2. Automation

Four kinds, all included at Level 1 or one level up:

• For memory: hooks capture the logs; an agent consolidates and organizes them.
• Context management: project files stay organized and standardized, so no session starts from zero.
• Assign and execute: work goes to the right person or agent, and executes through the right tools.
• Live data connectors: pull from Stripe, QBO, Shopify, Klaviyo on a schedule, so the brain reflects the business as it is.

3. Human / agent alignment

The piece most setups miss. Alignment is three habits:

• Organized folders and databases: a place for everything, so retrieval doesn’t depend on memory.
• Consistent conventions and readability: the same names for the same things, everywhere.
• A model built after exactly how your business works: not a generic template, but your purpose, your OKRs, your projects, in your language.

The project shape

Here’s what a workspace looks like in practice - one of my companies, a matcha wholesale brand:

nice-green/
├── CLAUDE.md
├── nicegreen-status.md
├── decisions.md
├── tasks-inbox.md
├── goals/
│   └── q2-okrs.yml
├── logs/
│   └── nicegreen-session-log-2026-05.md
└── projects/
    ├── nashville-territory/
    │   ├── project-wiki.md
    │   ├── customer-list.md
    │   ├── samples-tracker.md
    │   └── assets/
    ├── cobrand-poster/
    │   ├── project-wiki.md
    │   ├── copy-v3.md
    │   └── assets/
    └── q3-sourcing/
        ├── project-wiki.md
        ├── pricing-quotes.md
        └── samples-notes.md

Every project carries the same project-wiki.md template: what & why, status, people, goals (linked OKRs), decisions (linked to decisions.md), assets, open questions, activity (linked logs).

Open any project. Same template. Always. That predictability is what lets an agent - or a new hire - walk into any corner of the company and be useful in minutes.

The core agents

Three roles do most of the work:

• 🗂️ Secretary: keeps everything stored and up to date: OKRs, projects, tasks. The librarian of the company brain.
• 📍 PM: assigns tasks to humans or agents, and decides when a human gate is needed.
• ⛏️ Skill Mining: learns from experience. When something works, it turns the pattern into reusable company knowledge.

Humans stay in the loop where judgment matters; agents carry the load where structure makes the work legible.

When the framework lights up

The same spine, running for real at that matcha company: the org chart names five people; the quarterly objective - expand into two new cities and triple revenue - sits above three KRs with live status (revenue growth on track, city expansion at risk, LA wholesale base on track, synced minutes ago). Projects each hold their one-line state. The task list mixes owners naturally:

☐ @lee-ann  - follow up Reverie Coffee by Fri
☐ @jan      - approve poster copy v3
☐ @mei      - lock Uji pricing before 5/15
☐ @alfred   - sign Nashville distribution agreement
☐ @claude   - generate weekly sales recap from Stripe
☐ @auto     - consolidate temp logs EOD

The Secretary captures a decision with its why attached (“approved $4,200 print run - cobranded signage drove +23% lift in the Brooklyn pilot”). And the Skill Mining agent, reading across logs, spots the pattern and suggests the reuse: templatize the cobranded retail launch playbook for future wholesale accounts.

That’s the after state: not a chatbot bolted onto a business, but a business whose own structure has become operable.

The result

• ☀ You own your data: it’s markdown and YAML in your git repo.
• 🌱 Your company gets smarter: every log and decision compounds.
• 🔁 Things that work are surely repeated: mined into playbooks instead of lost.
• 🧠 Your processes are absorbed: the model is built after how you actually operate.
• 🧺 Your people are happier: less re-explaining, less status theater.

Try it in Claude Code this week

Everything above ships in the repo:

• CLAUDE.md context: the brain; Claude reads it every session.
• Hooks for logs: Python hooks that capture work as temp logs and auto-consolidate them monthly.
• Tasks inbox: one open list for anything that doesn’t yet have a home.
• Context agents: session-logger, status-reporter, and workspace-sync (git through plain English: “save my work”, “what changed since Monday”).
• OKR onboarding agent: goals-onboarding walks you from annual objectives to quarterly KRs to tasks, stored as YAML.
• VS Code setup agent: configures the editor and explains the permission layers.

Clone it, open it in Claude Code, and type intro for the five-minute tour - it’s this talk, built into the workspace - or start here to begin the ten-minute setup.

github.com/41fred/ace-level1 →