Field Notes: Building an AI Agent Swarm with Project Owner Orchestration

I built a Claude skill that turns projects into self-documenting agent swarms.5 specialist agents + 1 orchestrator. All tracking their own work in Notion automatically.

The result:

✅ Every feature logged with timestamps

✅ Every decision documented with rationale

✅ Portfolio case study that writes itself

✅ Zero manual documentation

‍

Try it yourself (20 minutes):

Download: https://drive.google.com/drive/folders/1Z65zgDeI0DS4t8Wr7F7UNfGqX7NbF5nE?usp=drive_link

‍

‍Most projects lose their history.

This one documents itself.

‍

The Setup

I'm building Frame House Miami — a luxury photography studio with 23+ custom sets, a Webflow marketing site, and a custom booking platform (Lovable/React + Supabase + Stripe).

The problem: messy meeting notes scattered across .docx files. No single source of truth. No living documentation. No portfolio-ready record of what shipped when.

The solution: build an agent swarm that documents itself.

The Specialist Skills

I created 5 specialist agents, each owning a specific domain:

fh-backend — Supabase, SQL, RLS policies, Stripe integration, React architecture, auth, edge functions, Git practices, exportable clean code

fh-frontend — Webflow UI, Lovable/React components, design system, UX copy, button labels, page sections, mobile-first design

fh-database — Schema design, migrations, Webflow CMS structure, Make.com sync automation, FigJam schema maps, single source of truth maintenance

fh-marketing — SEO, AIO (AI Overview Optimization), GEO, Meta ads, landing page strategy, 300+ keyword bible, schema markup, conversion optimization

framehouse-content — Brand voice enforcement (Cinematic, Direct, Exclusive), copy generation, removes AI patterns (no em dashes, no exclamation marks, no groups of three)

Each skill is a Claude agent with deep expertise in its domain. They know the stack, the brand, the constraints, the decision log.

The Project Owner

The 5th agent is different. It's the fh-project-owner — the orchestrator.

The PO doesn't write code or copy. It:

• Reads proposals, build plans, meeting notes
• Routes work to the right specialist
• Makes cross-system decisions
• Breaks complex features into specialist-sized pieces
• Tracks what's shipped, what's in progress, what's deferred
• Knows the launch checklist and critical blockers

The PO is the single point of contact. You talk to the PO, the PO routes to specialists.

Teaching the PO Notion

Here's where it gets interesting.

I taught the PO agent the Notion skill — a meta-skill for managing databases, pages, and project tracking.

Try it yourself: The Notion skill is publicly available in Claude. You can use it to build your own project tracking system:

1. Open Claude (desktop or web)
2. Go to Settings → Integrations → Notion
3. Connect your Notion workspace
4. Ask Claude to "set up a project tracking workspace with build log, decision log, and feature tracker databases"

The PO now:

1. Logs every feature shipped in a Build Log database (timestamped, with code links)
2. Documents every decision in a Decision Log (rationale, alternatives, outcomes)
3. Compiles all meeting notes from scattered .docx files into a searchable hub
4. Tracks all features across Reserve + Webflow with status, owners, completion dates
5. Maintains a Pre-Launch Checklist with critical security/infrastructure items
6. Writes a Portfolio Case Study page in real-time as the project progresses

This isn't note-taking. This is self-documenting infrastructure.

What I Started With vs. What I Have Now

Before:

• 3 .docx meeting note files
• Build plan in a Word doc
• Decisions made verbally, lost after the call
• No living record of what shipped when
• No portfolio-ready documentation

After:

• Frame House Project Hub in Notion: View workspace
• 5 tracking databases:
  • Build Log — every feature shipped with timestamps
  • Decision Log — architectural decisions with rationale
  • Meeting Notes — compiled from .docx files
  • Feature Tracker — status across Reserve + Webflow
  • Pre-Launch Checklist — critical items with owners
• 1 Portfolio Case Study page that writes itself as we ship: View page
• 10 shipped features logged with timestamps
• 6 architectural decisions documented with full context
• 24 features tracked across 3 phases
• 12 pre-launch items with owners and priorities
• 3 meetings compiled and searchable

The PO agent did this in one session. Every feature I ship from now on gets logged automatically. Every decision gets documented with rationale. Every meeting gets compiled.

Why This Matters

Record everything.

Most projects die in the gap between "what we said we'd build" and "what we actually built and why."

We lose:

• Decision context ("why did we choose Supabase over Firebase?")
• Build velocity data ("how long did Stripe integration actually take?")
• Portfolio-ready wins ("we shipped 10 features in 4 days")

With this setup:

• The PO logs every ship with timestamps and notes
• Every decision is documented with alternatives and outcomes
• The Portfolio Case Study writes itself as we work
• Future clients can see exactly what we built and when

This isn't just documentation. It's operational memory.

The Agent Swarm Pattern

This pattern works for any complex project:

1. Build specialist skills — one agent per domain (frontend, backend, content, marketing, ops)
2. Create a Project Owner agent — routes work, makes decisions, breaks down features
3. Teach the PO a documentation skill — Notion, Airtable, Linear, whatever you use
4. Let the PO track itself — every decision, every ship, every meeting

The specialists do the work. The PO orchestrates and documents.

Building Your Own Specialist Skills

All 5 of my Frame House specialist skills are custom-built using Claude's skill system.

Want to build your own? Claude has a skill-creator skill (meta, I know) that helps you create, test, and optimize custom skills for your domain.

How to create custom skills:

1. Claude Desktop → Settings → Skills
2. Click "Create Skill"
3. Define your domain expertise (e.g., "React/TypeScript development for e-commerce platforms")
4. Add specific context, rules, and patterns from your codebase/project
5. Test it with real queries
6. The skill-creator skill can help you iterate and improve

Each Frame House specialist skill is 400-600 lines of domain-specific knowledge: stack details, architectural decisions, brand rules, common patterns, pitfalls to avoid.

The PO skill is different — it knows the full project context, routes to specialists, and maintains the Notion workspace.

Example specialist skill structure:

• When to trigger this skill
• Tech stack and versions
• Architectural patterns
• Common workflows
• Decision framework
• Known issues and solutions
• Examples of good vs bad outputs

Once built, skills persist across all your Claude conversations. The agent remembers its expertise.

Next Steps

Frame House launches in 2 weeks. The PO is now running the Pre-Launch Checklist:

• RLS policy lockdown (Backend)
• Admin auth protection (Backend)
• Stripe live key switchover (Backend)
• Mobile QA (Frontend)
• GA4 + Meta Pixel (Marketing)
• Schema markup (Marketing)

Every item has an owner. Every completion gets logged. The Portfolio Case Study updates in real-time.

When we're done, we'll have a complete record of:

• What we built
• Why we built it that way
• What we chose not to build
• How long it actually took
• Every decision that mattered

All written by the agents that did the work.

The Takeaway

AI agents aren't just for writing code or copy.

Build an agent swarm with a Project Owner that documents its own work, and you get:

• Living documentation that stays current
• Decision logs with full context
• Portfolio-ready case studies that write themselves
• Operational memory that survives team changes

The messy meeting notes are gone. The scattered .docx files are gone. The gaps between "what we said" and "what we built" are gone.

Everything lives in one place. The agents keep it updated. The PO knows the full picture.

Record everything.

Explore the full workspace: View Notion Hub

Try it yourself:

1. Connect Claude to your Notion workspace (Settings → Integrations)
2. Ask Claude to "create a project tracking system like Frame House"
3. Build custom skills for your specialists (Settings → Skills → Create Skill)
4. Let the agents document their own work

Frame House Miami launches March 2026. Follow the build at framehousemiami.com.

Tags: AI, Product Development, Project Management, Notion, Agent Swarms, Claude, Anthropic, Skills, Automation

‍