Glade AI · Technical Product Lead (Contract)
Agent-Ready Onboarding
April to July 2026
Converted a service-heavy legal onboarding process into an explicit lifecycle state machine an agent could reason over, and shipped the production code myself.
The admin console I built. The Status column is the lifecycle state machine, live for every firm.
TL;DR: Transformation & Impact
Key Outcomes
- Converted a service-heavy legal onboarding process into an explicit lifecycle state machine built for agents to read and act on
- Shipped self-serve attorney signup, account creation, and workflow configuration with graduation logic
- Solo-built the React/TypeScript admin observability surface for live customer health and onboarding stage
- Caught an unknown signup and a $2,500 pricing configuration error in the dashboard's first standup use
- Replaced 30-60 minutes of manual customer-bug setup with agent-driven production bug reproduction
- Automated the legal-ops triage loop: a scheduled Claude task that reads Linear and Granola over MCP and surfaces which recurring work is worth automating
- Shipped ~170 production PRs myself using Claude Code across multiple repositories
What Changed
Context
Glade AI builds software for law firms. When I joined as a contract Technical Product Lead, getting a new firm onboarded was a service-heavy process: valuable, but manual, opaque, and expensive to scale. My mandate was to shift onboarding from operations toward product.
I operated as a hands-on build partner: defining the product direction, designing the workflows, and shipping production React/TypeScript myself alongside the engineering team.
Challenge
The hard part wasn't building features. It was that the onboarding journey existed only as institutional knowledge:
- Implicit process: no software representation of where a firm stood, what was complete, or what remained.
- No observability: the team couldn't see customer health or onboarding stage without asking around.
- Nothing for an agent to drive: an AI agent can't route users through a workflow that only exists in people's heads.
- Slow debugging: reproducing a customer bug meant 30-60 minutes of manual account and data setup.
Lifecycle State Machine (Simplified)
What I Did
Built the Lifecycle State Machine Agents Can Run On
The onboarding journey lived in operations, not product: implicit, manual, and impossible for software to reason about. I modeled it as an explicit state machine with one authoritative state per firm. Listeners read that state to decide what a firm sees, write back as steps complete, and graduate the firm automatically. It is also what makes onboarding agents possible: it turns "where is this firm?" from institutional knowledge into a field software can act on.
Tradeoff: Upfront modeling work before any visible feature shipped, but it became the foundation everything else was built on.
Shipped Self-Serve Signup and Workflow Creation
Attorneys needed to create accounts, configure their workflows, and graduate to active use without a human walking them through every step. I built the signup, account creation, and graduation logic that move a firm toward completion on its own.
Tradeoff: Self-serve flows had to handle edge cases that white-glove operations previously absorbed by hand.
Solo-Built the Admin Observability Surface
The team had no live view of customer health or onboarding stage. I designed and built a React/TypeScript admin layer with stuck-state detection so anyone could see exactly where every firm stood and where intervention was needed.
Tradeoff: None significant: in its first standup use it surfaced an unknown signup and a $2,500 pricing configuration error.
Built Agent-Driven Production Bug Reproduction
Reproducing a customer bug required 30-60 minutes of manual account and data setup. I built an agent-driven workflow that recreated production bug conditions automatically, backed by automated testing with Playwright and MSW.
Tradeoff: Time spent on internal tooling instead of customer-facing features, repaid on every single bug investigation after.
Automated the Legal-Ops Triage Loop
The legal-ops backlog kept refilling with the same shapes of work, and nobody had time to notice which repeats were worth automating. I built a scheduled Claude task that reads the live backlog from Linear and call load from Granola over MCP, classifies every issue as automate / recurring-ops / cleanup / keep-manual, surfaces the configuration-pattern share of the automate pile, and publishes a dashboard that recomputes daily. It turned "what should we automate next?" into a standing answer instead of a meeting.
Tradeoff: A tool for the internal team rather than customers, but it made the automation backlog self-prioritizing.
Shipped Production Code Directly with Claude Code
Rather than handing off requirements, I investigated, prototyped, and shipped alongside the engineers: roughly 170 production React/TypeScript PRs across Postgres, Sentry, Mixpanel, legacy services, and multiple repositories.
Tradeoff: Required earning trust in the codebase and the team's review process as a PM shipping production code.
What Shipped
Self-serve signup: firms create their own dashboard, no operator required
The setup wizard: steps open as the firm advances toward graduation
Health scoring: engagement, adoption, and outcomes
Impact & Results
Onboarding went from a manual service to an observable, self-serve, agent-ready product surface. The Head of Product's assessment: I "totally drove that whole initiative forward" on my own. The contract wrapped cleanly when the company reprioritized toward petition preparation and e-filing, with the door left open.
~170
Production PRs Shipped
$2,500
Pricing Error Caught on First Use
30-60 min
Manual Bug Setup Eliminated
Key Takeaways
Make the Workflow Explicit Before Adding AI
An agent can only drive a process the software can reason about. What changed things at Glade wasn't a better model. It was converting an implicit operational workflow into an explicit state machine an agent can read and act on.
Observability Is a Product Feature
A live view of customer state isn't internal plumbing. It caught real revenue errors on day one and turned "how is onboarding going?" from a research project into a glance.
PMs Who Ship Change the Conversation
Shipping production code myself compressed every iteration loop: I could investigate, prototype, and fix alongside engineers instead of writing tickets and waiting.
Design for Completion, Not Conversation
An onboarding agent's job isn't to chat. It's to drive every firm to a completed, validated setup and surface where a human needs to step in. The state machine was built for that job first.
Next Case Study