A harness for working with AI agents: the memory, loops, checks and skills around the model. Coding first, and now most of everything else.
I build and ship production software with coding agents (Claude Code, Codex) as my main interface. Over time the same agent took over most of the rest of my work too: my notes, my meetings, what I learn, my deploys and DNS. This repo is the operating system behind that, written down so your agent can use it too:
- Skills your agent can load today: turn a call recording into notes and tasks, keep a personal wiki that gets smarter with every source, deploy and manage DNS without opening a dashboard, run code changes through a plan → build → audit loop, and write your own skills.
- The principles behind them, each with a real receipt: what went wrong before the rule existed.
- Honest limits: every piece says how proven it is, and the mistakes are written down on purpose.
It all comes from real work on Delphy, SUPERPOWERS, Summer AI and fermartz.com.
1. Hand it to your agent (easiest). Paste this, and edit the list:
Read https://github.com/fermartz/agent-vault (README, then the skills I name).
Install these skills for me: meeting-to-notes, video-transcript, llm-wiki.
For each one, read its Requirements section, check what's already installed on my
machine, and tell me what's missing with the install command. Ask me before
installing anything. Then add the brevity block from playbook/human-context.md to
my CLAUDE.md (or AGENTS.md), and tell me how to try each skill once.
2. Copy one skill yourself:
git clone https://github.com/fermartz/agent-vault.git
mkdir -p ~/.claude/skills
cp -r agent-vault/skills/meeting-to-notes agent-vault/skills/video-transcript ~/.claude/skills/3. Adopt the whole loop for code: read The Blueprint, then
load skills/blueprint.
Codex, other agents, requirements per skill, and customizing: docs/getting-started.md.
| For | Skill | What it does |
|---|---|---|
| Building code | blueprint | Plan → build → verify → audit by a second agent; ceremony sized S/M/L/XL |
| code-review | Adversarial review of a diff: APPROVED or REQUEST_CHANGES with findings | |
| cross-artifact-sweep | After a fix, sync docs and memory with the code so review loops stay short | |
| agent-init | Set up the .agent/ working-memory folder and the first source map |
|
| public-repo-audit | Read a whole repo like a skeptical senior engineer before you share it | |
| Notes and knowledge | llm-wiki | A markdown + git wiki the agent maintains: ingest, query, lint |
| meeting-to-notes | Call recording → local transcript kept as evidence → notes, tasks, open loops | |
| video-transcript | The spoken text of a social video or audio file, locally, plus what it actually claims | |
| teach-in-bites | Learn anything one bite at a time, at your pace, then keep the lesson | |
| Operations | agent-deploy | Deploys, env vars, domains and DNS on Vercel + Cloudflare, with a human yes before anything billable or public |
| Making skills | skill-builder | Turn a workflow into a shareable skill; a guided interview if you start from an idea |
- The Blueprint: one agent builds, a different agent audits, and big changes don't ship until the audit approves (by default; the audit is a switch, see below). Change levels keep a typo from getting the full loop.
- The LLM Wiki: raw sources in, a growing web of linked pages out. Each source is folded into every page it affects when it arrives, so answers get richer over time.
| Principle | In one line |
|---|---|
| Give the Agent a Memory | Durable knowledge belongs in files, not the chat |
| A Plan Is a Contract, Not a Spec | Plan the what and why; leave how to the code |
| Don't Grade Your Own Homework | The agent that built it is the wrong one to judge it |
| Protect the Context | An agent reasons best with a small, relevant window |
| Protect the Human's Context | Your attention is a window too: short by default, deep on request |
| Synthesize When You Write | Fold each source in when it arrives, so knowledge compounds |
| Hand Over Keys, Not the Keyring | Scoped access, secrets never through the agent, ask before money or anything public |
Plus one convention: keep the agent's brain in one folder (.agent/).
flowchart LR
PB["Playbook — the WHY (principles)"]
WF["Workflows — the HOW (recipes)"]
SK["Skills — the WHAT (loadable tools)"]
PB --> WF
WF --> SK
WF -. "applies" .-> PB
SK -. "embodies" .-> PB
Every workflow cites the principles it applies and the skills it uses; every skill points back to the principle behind it. Enter from any side.
The second-agent audit is my strongest habit and my default, but it costs tokens and time, so it's
a switch. One line in your CLAUDE.md / AGENTS.md:
Audit: auto(default): simple changes skip it, features and risky changes get it.Audit: always: every change.Audit: off: none. Things can still turn out fine; you just lose the second pair of eyes.
Or per change: "skip the audit" / "audit this one", which beats the setting either way. The agent never turns it off by itself, and it logs every audit it skips that the setting would have run. Why I keep it on: a building model once graded its own work "B+, ready to ship", and a second agent found real bugs in the same diff. Writing this repo's own skills, audits caught three bugs in what looked like a documentation move, and advice that could have leaked secrets. Details: the audit switch.
Written for Claude Code and Codex, and usable by any agent that reads markdown: the skills are plain
SKILL.md files, and the workflows are documents an agent can follow. Skills that need tools
(Python, ffmpeg, a CLI) list them, check before running, and ask before installing anything.
macOS and Linux are covered; on Windows, use WSL (native Windows commands are in the docs, untested).
- battle-tested: used repeatedly on shipped work
- working: the practice has run for weeks; the written form is newer
- experimental: promising, still shaking out
Each skill, workflow and principle says which one it is.
Growing in public: seven principles plus the .agent/ convention, two workflows and eleven skills
today, more added piece by piece, the same way I build everything.
Built by Fer Martz, an engineer building production AI products: agents, the agentic web, and the tooling that drives them. fermartz.com · github.com/fermartz · LinkedIn
MIT. Use anything here. If it saves you a review round, that's the point.