Claude's Corner: Zymbly - AI for the People Keeping Your Plane in the Air

# How to Build a Zymbly Clone with Claude Code

A step-by-step guide for developers who want to build an AI-powered voice copilot for a regulated industrial vertical.

---

## Step 1: Database Schema

You need three core data domains: the document corpus, the operator context, and the audit trail.

```sql
-- Document corpus (aviation manuals, service bulletins, etc.)
CREATE TABLE documents (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  operator_id UUID REFERENCES operators(id),
  doc_type TEXT NOT NULL, -- 'AMM', 'IPC', 'TSM', 'SB', 'AD', 'defect_record'
  aircraft_type TEXT NOT NULL, -- e.g. 'A320-200'
  ata_chapter TEXT, -- ATA chapter reference
  revision TEXT,
  effective_date DATE,
  content TEXT NOT NULL,
  embedding VECTOR(1536), -- pgvector for semantic search
  source_metadata JSONB,
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Operator context (airline/MRO fleet and configuration)
CREATE TABLE operators (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name TEXT NOT NULL,
  erp_type TEXT, -- 'AMOS', 'SAP', 'Ramco', etc.
  erp_connection_config JSONB, -- encrypted connection details
  fleet JSONB, -- aircraft registrations and types
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Technician sessions
CREATE TABLE sessions (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  operator_id UUID REFERENCES operators(id),
  technician_id UUID NOT NULL,
  aircraft_registration TEXT,
  work_order_id TEXT,
  started_at TIMESTAMPTZ DEFAULT now(),
  ended_at TIMESTAMPTZ
);

-- Audit trail (every query, every action)
CREATE TABLE audit_events (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  session_id UUID REFERENCES sessions(id),
  event_type TEXT NOT NULL, -- 'query', 'doc_retrieved', 'action_flagged', 'doc_signed'
  payload JSONB NOT NULL,
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Index for vector similarity search
CREATE INDEX ON documents USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
CREATE INDEX ON documents(operator_id, aircraft_type, doc_type);
```

---

## Step 2: Document Ingestion Pipeline

Aviation documents come in PDF, XML (ATA iSpec 2200), and proprietary formats. Build an ingestion pipeline that handles them all.

```python
# ingestion/pipeline.py
import anthropic
from supabase import create_client
from typing import Literal

client = anthropic.Anthropic()

DocType = Literal['AMM', 'IPC', 'TSM', 'SB', 'AD', 'defect_record']

def chunk_aviation_doc(raw_text: str, doc_type: DocType) -> list[dict]:
    """Split aviation docs at natural boundaries: task cards, procedures, chapters."""
    # Use Claude to extract structured chunks with ATA chapter references
    response = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=8096,
        system="You are an aviation documentation specialist. Extract structured chunks from this document, preserving ATA chapter references, task numbers, and effectivity ranges.",
        messages=[{
            "role": "user",
            "content": f"Document type: {doc_type}\n\nContent:\n{raw_text[:50000]}"
        }]
    )
    # Parse response into chunks with metadata
    return parse_chunks(response.content[0].text)

def embed_and_store(chunk: dict, operator_id: str, supabase_client):
    """Embed a chunk and store with metadata."""
    # Use text-embedding-3-small or equivalent
    embedding = get_embedding(chunk['content'])
    supabase_client.table('documents').insert({
        'operator_id': operator_id,
        'doc_type': chunk['doc_type'],
        'aircraft_type': chunk['aircraft_type'],
        'ata_chapter': chunk.get('ata_chapter'),
        'revision': chunk.get('revision'),
        'content': chunk['content'],
        'embedding': embedding,
        'source_metadata': chunk.get('metadata', {})
    }).execute()
```

---

## Step 3: Retrieval Layer with Aviation-Aware Ranking

Generic cosine similarity retrieval will return wrong results on aviation docs. You need effectivity filtering (does this procedure apply to this specific aircraft serial number?) and revision currency checks.

```python
# retrieval/aviation_rag.py

def retrieve_for_query(
    query: str,
    operator_id: str,
    aircraft_registration: str,
    supabase_client,
    top_k: int = 8
) -> list[dict]:
    """
    Retrieve relevant documentation chunks with aviation-specific filtering.
    """
    # 1. Embed the query
    query_embedding = get_embedding(query)

    # 2. Get aircraft type from registration
    aircraft_type = get_aircraft_type(aircraft_registration, operator_id, supabase_client)

    # 3. Vector search with type filter
    results = supabase_client.rpc('match_documents', {
        'query_embedding': query_embedding,
        'operator_id': operator_id,
        'aircraft_type': aircraft_type,
        'match_count': top_k * 2  # over-retrieve, then filter
    }).execute()

    # 4. Filter for current revisions only (never serve superseded docs)
    current = filter_superseded(results.data)

    # 5. Re-rank by ATA chapter relevance if query contains chapter hints
    ranked = rerank_by_ata_relevance(query, current)

    return ranked[:top_k]


# Supabase RPC function for pgvector search:
# CREATE OR REPLACE FUNCTION match_documents(
#   query_embedding VECTOR(1536),
#   operator_id UUID,
#   aircraft_type TEXT,
#   match_count INT
# ) RETURNS TABLE (id UUID, content TEXT, similarity FLOAT, metadata JSONB)
# AS $$ ... $$ LANGUAGE plpgsql;
```

---

## Step 4: Voice Interface for Hangar Environments

The UX challenge is real: hangar environments are loud (jet engines, tools, PA systems). Use a combination of browser-native speech recognition with a noise-cancellation preprocessing step.

```typescript
// voice/hangar-speech.ts

export class HangarVoiceCapture {
  private mediaRecorder: MediaRecorder | null = null;
  private audioContext: AudioContext | null = null;

  async startCapture(onTranscript: (text: string) => void) {
    const stream = await navigator.mediaDevices.getUserMedia({
      audio: {
        noiseSuppression: true,
        echoCancellation: true,
        autoGainControl: true,
        // Request mono audio - less data, faster processing
        channelCount: 1,
        sampleRate: 16000
      }
    });

    // Send 3-second audio chunks to Whisper API for transcription
    this.mediaRecorder = new MediaRecorder(stream, { mimeType: 'audio/webm' });
    const chunks: Blob[] = [];

    this.mediaRecorder.ondataavailable = (e) => chunks.push(e.data);
    this.mediaRecorder.onstop = async () => {
      const blob = new Blob(chunks, { type: 'audio/webm' });
      const text = await transcribeAudio(blob); // Whisper API call
      onTranscript(text);
      chunks.length = 0;
    };

    // Capture in 4-second intervals
    this.mediaRecorder.start();
    setInterval(() => {
      this.mediaRecorder?.stop();
      this.mediaRecorder?.start();
    }, 4000);
  }
}

// The UI should work with one hand - large tap targets, voice confirmation
// of actions, no small text. Mechanics wear gloves.
```

---

## Step 5: Compliance Audit Layer

This is the part most clones skip and then wonder why airlines won't buy them.

```python
# compliance/audit.py
import anthropic

client = anthropic.Anthropic()

AVIATION_REGULATIONS = {
    'EASA_145': 'EASA Part-145 Approved Maintenance Organisation requirements',
    'FAA_145': 'FAA Part 145 Repair Station requirements',
    'CAA_UK': 'UK CAA Part-145 requirements post-Brexit'
}

def check_task_completeness(
    task_steps_completed: list[str],
    work_order_id: str,
    aircraft_type: str,
    regulatory_framework: str
) -> dict:
    """
    Verify a technician has completed all required steps before sign-off.
    Uses Claude with extended thinking for complex regulatory reasoning.
    """
    response = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=4096,
        thinking={"type": "enabled", "budget_tokens": 2048},
        system=f"""You are an aviation compliance expert under {AVIATION_REGULATIONS[regulatory_framework]}.
        Review the completed maintenance steps and identify:
        1. Any mandatory sign-off points not yet completed
        2. Safety-critical steps that appear missing
        3. Required second-person inspections not noted
        Return a JSON object with 'compliant': bool, 'missing_steps': list, 'warnings': list""",
        messages=[{
            "role": "user",
            "content": f"Aircraft: {aircraft_type}\nWork Order: {work_order_id}\n\nCompleted steps:\n" +
                      "\n".join(f"- {step}" for step in task_steps_completed)
        }]
    )

    # Log every compliance check to audit trail
    log_audit_event('compliance_check', {
        'work_order_id': work_order_id,
        'result': response.content[-1].text,
        'model': 'claude-opus-4-7'
    })

    return parse_compliance_result(response.content[-1].text)
```

---

## Step 6: ERP Integration Adapter

Airlines run AMOS, SAP PM, Ramco, and custom legacy systems. Build an adapter pattern rather than point integrations.

```python
# erp/adapter.py
from abc import ABC, abstractmethod
from typing import Optional

class ERPAdapter(ABC):
    @abstractmethod
    def get_work_order(self, work_order_id: str) -> dict:
        pass

    @abstractmethod
    def get_parts_availability(self, part_numbers: list[str]) -> dict:
        pass

    @abstractmethod
    def create_defect_record(self, session_id: str, description: str, disposition: str) -> str:
        pass

    @abstractmethod
    def close_work_order(self, work_order_id: str, sign_off_data: dict) -> bool:
        pass


class AMOSAdapter(ERPAdapter):
    """Swiss-AviationSoftware AMOS ERP adapter via REST API."""

    def __init__(self, base_url: str, api_key: str):
        self.base_url = base_url
        self.headers = {'Authorization': f'Bearer {api_key}', 'Content-Type': 'application/json'}

    def get_work_order(self, work_order_id: str) -> dict:
        import requests
        response = requests.get(
            f"{self.base_url}/workorders/{work_order_id}",
            headers=self.headers,
            timeout=10
        )
        response.raise_for_status()
        return response.json()

    # ... implement other methods


class SAPPMAdapter(ERPAdapter):
    """SAP Plant Maintenance adapter via RFC or OData."""
    # ... SAP-specific implementation


def get_adapter(erp_type: str, config: dict) -> ERPAdapter:
    adapters = {
        'AMOS': AMOSAdapter,
        'SAP_PM': SAPPMAdapter,
    }
    cls = adapters.get(erp_type)
    if not cls:
        raise ValueError(f"Unsupported ERP: {erp_type}")
    return cls(**config)
```

---

## Step 7: Deployment for Regulated Environments

Aviation IT security reviews are thorough. Plan for these requirements from day one.

```yaml
# infrastructure/requirements.yaml

data_security:
  encryption_at_rest: AES-256
  encryption_in_transit: TLS-1.3-minimum
  key_management: HSM or cloud KMS (not environment variables)
  data_residency: must match airline's regulatory jurisdiction
  customer_data_isolation: per-tenant schemas or separate databases
  backup_retention: 7 years minimum (regulatory requirement for maintenance records)

audit_requirements:
  query_logging: every retrieval logged with timestamp, user, aircraft, query hash
  model_outputs: retained for 90 days minimum
  access_logs: immutable append-only log (CloudTrail or equivalent)
  retention: aligned with operator's regulatory retention schedule

deployment_options:
  cloud: AWS GovCloud or Azure Government for US operators; EU regions for EASA
  on_premise: airlines often require this; containerize everything
  hybrid: most realistic for large carriers

soc2_type2: required before most airline procurement
iso_27001: required for EASA operators
pen_testing: annual third-party, results shared with airline security team

# Do NOT train on customer data. This is table stakes trust, not a feature.
# Put it in the data processing agreement, not just the sales deck.
```

**Total estimated build time for an MVP:** 3-4 months with 3 engineers. Getting the first airline to trust it in production: 12-18 months minimum. That gap is the moat.