AI agents built for real operational work.

PM and builder, working directly with AP/AR team

Solo build, deployed into a finance ops workflow

There was no dedicated invoicing platform, so each invoice was hand-built in Google Sheets. Every client had different formatting, naming conventions, banking details, and billing preferences, and those rules lived in informal notes. Urgent invoice requests interrupted other work and slowed cash collection.

I mapped the client billing rules before touching any automation. Each client's preferences, naming conventions, and banking details needed to be a real source of truth, not informal notes. I structured these as versioned YAML configs in GitHub, then built a Claude Code agent that takes a natural-language request, loads the right client profile, applies numbering and filename rules, populates banking and line items in the existing Sheets template, and prompts only when something is genuinely missing. New decisions are written back to the config so each invoice is marginally faster than the last.

Invoice prep dropped from 10 minutes to seconds. Account managers generate invoices without spreadsheet expertise, billing is consistent across all clients, and faster delivery tightened cash collection timing. The decision not to purchase a dedicated billing platform saved recurring SaaS spend while achieving the same outcome.

PM and builder, partnered with the account managers

Solo build, deployed into a client onboarding squad

White-glove onboarding required reviewing 100+ contracts, offer letters, and comp schedules per client and converting them into a strict import spreadsheet. The work was repetitive and error-prone, schedules varied wildly (one-time, monthly, custom dates, ad hoc bonuses), and slow prep delayed client go-live and first payouts.

Before writing any prompts, I encoded the platform's import schema, payout-expansion rules, and validation requirements so the agent could reason about them accurately. Getting these rules wrong meant incorrect payouts for real people. The agent ingests a folder of mixed documents, extracts member details and comp terms, classifies each payment type, expands recurring schedules into one row per payout event, and flags ambiguous or conflicting data instead of guessing. The design kept humans in the loop for exceptions, not routine entry. The same encoded rules later became the foundation for the platform's self-service onboarding logic.

Onboarding prep collapsed from multiple days to a few hours per client. Error rates dropped as the agent flagged ambiguities rather than guessing. Time to first payout shortened, and the team's role shifted from data entry to judgment on flagged exceptions, a meaningful step up the value chain. The encoded rules and data model built for this agent later informed the platform's self-service onboarding design.

PM, team lead, and builder of the agent workflow

Solo build, validated with new hires

New hires were ramping on the product through ad hoc Loom recordings and scattered Notion pages. Critical context lived in one person's head, videos went stale fast, and existing docs explained what the product did but never why it worked that way.

I mapped the actual onboarding flow before automating anything. That meant understanding what questions new hires actually asked, where context was missing, and why existing docs kept going stale. Then I built a Claude Code skill that ingests a Loom transcript, the relevant Notion pages, and the linked GitHub repo, and produces a structured runbook covering product behavior, decision rationale, and code references. The agent merges new context into existing docs instead of overwriting them, so institutional knowledge compounds rather than resets with each update.

Onboarding repetition dropped by more than 80%. New hires answer their own questions from runbooks instead of pinging me on Slack, and decision rationale is preserved alongside implementation details as institutional knowledge that survives personnel changes.