Expert subagents
Narrow, role-scoped specialists instead of one do-everything prompt. The infra agent thinks like an ops engineer; the security auditor thinks like an adversary. Each is good at its lane and stays in it.
1
What this is
The elevator pitch — one idea, two states.
Instead of
One general AI chat that forgets, doesn't know your rules, and answers from a blank slate every time.
You get
A versioned, personal team of specialized AI agents that share memory, follow your rules, and get sharper over time.
Not a chatbot — a small, governed, self-improving AI org that's yours.
It lives in a git repo
Versioned and backed up from day one — you can read it, diff it, and roll it back.
It plugs into Claude Code
Built on familiar primitives — subagents, slash commands, hooks. No new app.
It adapts to YOUR stack
Nothing here is prescribed — your AI interviews you and tailors every specific.
2
The five pillars
Five ideas hold the whole thing up. Everything else is detail.
Layered memory
Semantic (facts that are true now) + episodic (a decision journal) + procedural (skills & checklists) — with time-awareness so it doesn't silently go stale and start lying to you.
Governance
Always-on rules: no silent behaviour changes, strict secret hygiene, and human approval for anything risky.
Self-improving loop
Agents flag friction → you run a periodic review → they get coached and improve. Compounding, human-triggered, no always-on daemon.
Grounding
Agents look at reality — your repos, optionally live systems — instead of guessing. You choose the blast radius.
3
The roster
Who's on the team — and what each one is trusted to touch.
Infra / Ops expert
RO → RWKnows your homelab. Starts read-only; you decide if it earns write access.
Dev expert(s)
RWWrites and refactors code in your repos, following your conventions.
UI / UX designer
RWDesigns and builds interfaces with a committed point of view, not templates.
Security auditor
READ-ONLYHunts for risks and leaks. Reports them — never edits anything itself.
Devil's advocate
READ-ONLYArgues the other side and pokes holes in plans before you commit to them.
Product / Idea partner
READ-ONLYHelps you turn raw ideas into shaped specs. Thinks with you, doesn't ship.
Remediation planner
READ-ONLYTurns audit findings into an ordered fix plan. Plans the work; doesn't do it.
Engineering-manager
PROPOSESRuns the review and coaches the roster. Proposes changes — you approve them.
› runs the self-improving loop
The principle to remember
Read-only by default; write is a privilege — and the agent that decides what to change never applies it unattended. The reviewer is never the applier.
4
The self-improving loop
The heart of it. A closed cycle with one explicit human-approval gate.
1
Capture friction
While you work, agents flag what got in the way — a missing fact, a gotcha, a correction you had to make.
2
Journal — local & private
Those notes accrue into a local, private decision journal. It's read only at review time, so it never bloats your day-to-day startup.
3
You run
You run /eng-review
Periodically — and only when you choose, never on a timer — you kick off the review.
4
Engineering-manager proposes coaching
It reads the journal, finds patterns, and proposes concrete improvements to memory, skills, and agent instructions.
★
You approve the diffs human gate
Nothing changes until you say yes. Then the agents improve — and the loop returns to Capture, a little sharper.
It compounds — but only if you actually run the review. A start-of-session nudge reminds you when retros are piling up.
5
Memory architecture
Three layers, each with a different job. Together they make it remember.
Semantic
Facts that are true now
read at startupYour current reality — hosts, conventions, the lay of the land. The fast-loading top layer the agents lean on every session.
Episodic
What happened — the journal
read at review onlyThe decision & activity log. Read only at review, so it can grow rich without ever bloating startup.
Procedural
Reusable skills & checklists
loaded on demandThe "how we do X here" layer — distilled playbooks the agents reach for when a familiar task comes around again.
It stores the non-derivable — not what's already in your code.
Memory captures gotchas and decisions: the things you'd otherwise re-explain every time. It deliberately doesn't duplicate what an agent can just read from your repo.
⏱ Time-aware on purpose
Each layer knows roughly how fresh it is — because staleness is silent. Old facts get flagged and pruned at review, so the system never quietly lies to you.
6
How setup works
You don't build it all at once. You grow it as real friction tells you to.
-
Interview
Your AI interviews you
It asks about your domains, stack, conventions, guardrails, and risk posture — so everything that follows fits you, not a template.
-
Scaffold
It scaffolds a clean git repo
A tidy structure, committed and backed up from day one — so your knowledge is never sitting in a single fragile local folder.
-
Start small
Begin with 2–3 agents you'll actually use
Not the whole roster. The two or three roles that match what you do today, so the thing is useful in week one.
-
Add the loop
Add the self-improving loop
Once you have agents worth coaching, wire up the journal and
/eng-review. Now the system starts getting sharper on its own cadence. -
Expand
Grow as real friction tells you to
Add domains and agents when you actually hit a wall — never speculatively. The journal will show you where the friction is.
Build the smallest useful thing, use it, and let friction guide what's next.
7
Principles & anti-patterns
Keep these on the left. Watch for the ones on the right.
✓ Do
The habits that compound
- ✓Commit + back up from day one — the repo is your source of truth.
- ✓Generate your self-description from the live tree, so it never lies about itself.
- ✓Read-only by default — grant write deliberately, role by role.
- ✓Capture the human's corrections — your fixes are the highest-signal memory there is.
- ✓Prune stale memory at review, so old facts don't quietly mislead.
- ✓Human approves every change — the gate is the point, not a speed bump.
✗ Avoid
The traps that rot the system
- ✗A source-of-truth repo with no backup — one disk failure from gone.
- ✗Hand-maintained docs that rot — they drift out of sync and start lying.
- ✗Dead / unused agents cluttering the roster with config that never fires.
- ✗Capture with no review — a journal nobody reads is just noise.
- ✗Agents grading their own work — "all went great" is noise, not signal.
- ✗Always-on agents with broad access — the largest blast radius for the least gain.