Enterprise Recording Integration Skills

The Problem

The company’s enterprise document recording platform — county recording as a service — needed adoption across multiple internal applications. Each onboarding took close to a month. A single integration with one application required weeks of back-and-forth because the recording platform carried significant hidden complexity: non-standard API behaviors, case-sensitive field names, undocumented required fields, and error response shapes that only surfaced through live testing. Only the core recording team understood these quirks, creating a tribal knowledge bottleneck. Every new integration was hand-rolled, leading to inconsistent patterns, repeated discovery of the same gotchas, and slowed platform adoption across the organization.

The Solution

I built three Claude Code skills that function as a domain expert for the recording platform. Point any of them at a host application, and they scan its architecture, map its domain models to the recording API’s requirements, and generate a complete, typed integration plan — API client, auth service, data mappers, embedded UI wrapper, entity registration, tests, and documentation. The developer executes the plan; the skills supply all the hard-won API knowledge that previously lived only in the recording team’s heads. What took a month now takes a session.

Outcome & Impact

The manual integration baseline was approximately one month per application. The skills reduce that to minutes for plan generation and hours for execution — a compression of roughly 20x on the time-to-integration estimate.

Metric	Before	After
Time to integration	~1 month (prior application)	Minutes to generate plan, hours to execute
Knowledge required	Recording team tribal knowledge	Encoded in skill reference materials
Consistency	Ad-hoc per application	Standardized 13-step plan
Scalability	One application at a time	Any app with a supported framework

Tested against a live Next.js application. Generated working code across all seven layers: typed API client, auth service, data mappers, embedded UI wrapper, entity registration, integration tests, and workflow documentation. /auto-integrate correctly identified four enrichment gaps after base installation and generated plans for each. The full flow — draft creation, validation, entity association, embedded UI rendering — was validated end-to-end.

My Role & Contributions

Aspect	Detail
Role	Sole designer and implementer
Team size	1
Timeline	3 days (June 2026)
Scope	Architecture, skill design, reference documentation, implementation, testing against a live application
Key decisions	Skill decomposition into three distinct tools, reference material structure, confidence scoring rubrics for integration point discovery, scope boundaries for the POC

Every decision — from how to split the skills, to what domain knowledge to encode, to the scoring heuristics — was mine.

Technical Overview

┌──────────────────────────────────────────────────────────────┐
│                     Claude Code Skills                       │
├──────────────────┬──────────────────┬────────────────────────┤
│  /install        │  /use-recording  │  /auto-integrate       │
│  Full integration│  Single API call │  Workflow analyzer     │
│  plan generator  │  placement       │  + plan generator      │
└────────┬─────────┴────────┬─────────┴──────────┬─────────────┘
         │                  │                    │
         ▼                  ▼                    ▼
┌──────────────────────────────────────────────────────────────┐
│               Shared Reference Materials                     │
│  • API Contract (live OpenAPI fetch + static fallback)       │
│  • Embedded UI PostMessage Protocol                          │
│  • Framework Detection Rules                                 │
│  • OpenAPI → TypeScript Type Mapping                         │
│  • Workflow Pattern Library (6 categories)                   │
│  • Placement Scoring Rubric                                  │
└──────────────────────────────────────────────────────────────┘
         │
         ▼
┌──────────────────────────────────────────────────────────────┐
│                 Host Application                             │
│  (Next.js, NestJS, Angular, .NET, Express)                   │
└──────────────────────────────────────────────────────────────┘

The three skills decompose the integration problem by intent:

Install is the primary skill. It runs a 7-phase process: detect the host framework, fetch the live API spec (falling back to an embedded static contract if offline), scan domain models and score field-match confidence, analyze embedded UI surfaces, generate a 13-step implementation plan, and hand off to execution. It produces all seven integration artifacts in a single run.

Use is for surgical placement. Given a natural-language description of intent (“create a draft when an order reaches recording stage”), it maps to a specific API operation, reads the target file, and produces a focused plan that respects existing code patterns.

Auto-integrate inverts control. Instead of the developer deciding where recording belongs, it discovers the optimal integration point. It runs six workflow pattern detectors (state machines, route handlers, service chains, event handlers, pipelines, entity systems), builds a data availability matrix across lifecycle stages, and scores candidates: confidence = (data_completeness × 0.4) + (workflow_fit × 0.4) + (effort_inverse × 0.2). It outputs ranked recommendations, each with a full plan.

Embedded Domain Knowledge

The skills encode API behaviors that only surfaced through live testing — the kind of undocumented quirks that burned days during manual integrations. Baking these directly into reference materials eliminates that friction for every subsequent integration.

Challenges & Key Decisions

Scope discipline under real-world complexity

The first integration target had a deeply layered workflow — multi-step entity lifecycles, participant enrichment chains, five or more data sources feeding a single API payload. The temptation was to automate all of it. I drew the line at install + single API call (draft creation). That boundary kept the POC deliverable in three days while still proving the concept end-to-end.

Three skills instead of one

A monolithic “do everything” skill would have been unwieldy and hard to maintain. The decomposition mirrors how a human expert approaches the problem: first establish the foundation (/install), then discover where gaps remain (/auto-integrate), then fill each gap precisely (/use-recording). Each skill is independently useful; together they compound.

Confidence scoring over rigid rules

Host applications don’t conform to templates. Rather than a decision tree (“if framework X, do Y”), I used scoring rubrics that weigh field name matching, workflow fit, and data availability simultaneously. This handles the messy reality of real codebases and surfaces better recommendations when signals are ambiguous.

Static + live API references

Skills first attempt to fetch the live OpenAPI spec and fall back to an embedded static contract. They work offline while staying current when connected — important for a POC that needs to demonstrate reliably across different developer environments.

Tech Stack

Layer	Technologies
Skills Runtime	Claude Code
Generated Code	TypeScript, React, OAuth2
Target Frameworks	Next.js, NestJS, Angular, .NET, Express
API Integration	OpenAPI, REST
Test App	Next.js, TypeScript, TanStack Query

Lessons Learned

• Encoding tribal knowledge into AI skills is high-leverage. The API quirks that burned days during manual integrations are exactly the kind of thing that scales poorly via documentation. Baking them into reference materials eliminates that entire class of friction for every future integration.

• Scope discipline is a POC deliverable. The temptation to handle the full workflow complexity was real. Drawing a firm line — install plus one API call — kept the work deliverable in three days and still validated the core concept.

• Design the detection layer first. The six workflow pattern detectors in /auto-integrate are the most powerful part of the system, but were built last. They would have informed better scope decisions for the other skills if I had designed them first.

• Skills compound. /install creates the foundation, /auto-integrate finds the gaps, /use-recording fills them. Each run makes the next more effective — the value accumulates across a session.