# Insurance Expert > Expert-level insurance systems, underwriting, claims processing, actuarial analysis, risk assessment, and insurtech solutions. Use when the user mentions underwriting, claims, actuarial, risk, or insurtech, or when the task involves Insurance Systems, Insurance Types, Standards and Regulations, or Claims Processing. - Skill: `personamanagmentlayer/insurance-expert` (Agent Skill, multi-file: 2 files) - Install (CLI): `npx skillmds add personamanagmentlayer/insurance-expert` - Raw SKILL.md: https://api.skillmd.com/api/skills/personamanagmentlayer/insurance-expert/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Productivity - Author: personamanagmentlayer (https://skillmd.com/u/personamanagmentlayer) - Updated: 2026-09-09 - Page: https://skillmd.com/skills/personamanagmentlayer/insurance-expert --- # Insurance Expert Expert guidance for insurance systems, underwriting, claims processing, actuarial analysis, risk assessment, fraud detection, and modern insurtech solutions. ## Core Concepts ### Insurance Systems - Policy Administration Systems (PAS) - Claims Management Systems - Underwriting workstations - Actuarial modeling systems - Reinsurance management - Agency management systems - Document management ### Insurance Types - Property & Casualty (P&C) - Life insurance - Health insurance - Auto insurance - Commercial insurance - Specialty insurance - Cyber insurance ### Standards and Regulations - ACORD standards (insurance data exchange) - SOX compliance - State insurance regulations - NAIC (National Association of Insurance Commissioners) - GDPR for customer data - Anti-money laundering (AML) ## Claims Management System ```python from enum import Enum class ClaimStatus(Enum): REPORTED = "reported" INVESTIGATING = "investigating" APPROVED = "approved" DENIED = "denied" CLOSED = "closed" @dataclass class Claim: """Insurance claim""" claim_number: str policy_number: str claim_type: str # 'collision', 'theft', 'liability', etc. date_of_loss: datetime reported_date: datetime description: str estimated_loss: Decimal status: ClaimStatus adjuster_id: Optional[str] reserve_amount: Decimal paid_amount: Decimal deductible: Decimal class ClaimsManagementSystem: """Claims processing and management""" def __init__(self): self.claims = {} self.fraud_detector = FraudDetectionSystem() def file_claim(self, claim_data: dict) -> Claim: """File new insurance claim""" claim_number = self._generate_claim_number() claim = Claim( claim_number=claim_number, policy_number=claim_data['policy_number'], claim_type=claim_data['claim_type'], date_of_loss=claim_data['date_of_loss'], reported_date=datetime.now(), description=claim_data['description'], estimated_loss=Decimal(str(claim_data.get('estimated_loss', 0))), status=ClaimStatus.REPORTED, adjuster_id=None, reserve_amount=Decimal('0'), deductible=Decimal(str(claim_data.get('deductible', 0))), paid_amount=Decimal('0') ) # Fraud detection screening fraud_result = self.fraud_detector.screen_claim(claim) if fraud_result['fraud_score'] > 0.8: claim.status = ClaimStatus.INVESTIGATING self._flag_for_siu(claim, fraud_result) # Special Investigation Unit # Auto-assign adjuster claim.adjuster_id = self._assign_adjuster(claim) # Set reserve amount claim.reserve_amount = self._calculate_reserve(claim) self.claims[claim_number] = claim return claim def investigate_claim(self, claim_number: str) -> dict: """Investigate claim details""" claim = self.claims.get(claim_number) if not claim: return {'error': 'Claim not found'} claim.status = ClaimStatus.INVESTIGATING # Gather evidence investigation_steps = [ 'Review policy coverage', 'Verify loss details', 'Inspect damage', 'Review police report (if applicable)', 'Interview claimant', 'Review medical records (if applicable)', 'Obtain repair estimates' ] return { 'claim_number': claim_number, 'status': claim.status.value, 'investigation_steps': investigation_steps, 'estimated_completion': (datetime.now() + timedelta(days=14)).isoformat() } def approve_claim(self, claim_number: str, approved_amount: Decimal) -> dict: """Approve claim for payment""" claim = self.claims.get(claim_number) if not claim: return {'error': 'Claim not found'} # Validate coverage if not self._validate_coverage(claim): return {'error': 'Loss not covered under policy'} # Apply deductible payment_amount = approved_amount - claim.deductible if payment_amount <= 0: return {'error': 'Approved amount does not exceed deductible'} claim.status = ClaimStatus.APPROVED claim.paid_amount = payment_amount # Process payment payment_result = self._process_payment(claim, payment_amount) return { 'claim_number': claim_number, 'approved_amount': float(approved_amount), 'deductible': float(claim.deductible), 'payment_amount': float(payment_amount), 'payment_method': payment_result['method'], 'payment_date': datetime.now().isoformat() } def deny_claim(self, claim_number: str, reason: str) -> dict: """Deny claim""" claim = self.claims.get(claim_number) if not claim: return {'error': 'Claim not found'} claim.status = ClaimStatus.DENIED # Send denial letter self._send_denial_letter(claim, reason) return { 'claim_number': claim_number, 'status': 'denied', 'reason': reason, 'appeal_deadline': (datetime.now() + timedelta(days=60)).isoformat() } def _calculate_reserve(self, claim: Claim) -> Decimal: """Calculate reserve amount for claim""" # Reserve is an estimate of total claim cost # Based on claim type and severity reserve_multipliers = { 'collision': Decimal('1.5'), 'theft': Decimal('1.3'), 'liability': Decimal('2.0'), 'comprehensive': Decimal('1.4') } multiplier = reserve_multipliers.get(claim.claim_type, Decimal('1.5')) reserve = claim.estimated_loss * multiplier return reserve def _assign_adjuster(self, claim: Claim) -> str: """Auto-assign claim to adjuster""" # Would use load balancing and expertise matching return "ADJ001" def _validate_coverage(self, claim: Claim) -> bool: """Validate that loss is covered under policy""" # Would check policy coverages against claim type return True def _process_payment(self, claim: Claim, amount: Decimal) -> dict: """Process claim payment""" # Integration with payment system return {'method': 'direct_deposit', 'transaction_id': 'TXN123'} def _flag_for_siu(self, claim: Claim, fraud_result: dict): """Flag claim for Special Investigation Unit""" # Implementation would notify SIU pass def _send_denial_letter(self, claim: Claim, reason: str): """Send claim denial letter""" # Implementation would generate and send letter pass def _generate_claim_number(self) -> str: import uuid return f"CLM-{uuid.uuid4().hex[:10].upper()}" class FraudDetectionSystem: """Fraud detection for claims""" def screen_claim(self, claim: Claim) -> dict: """Screen claim for fraud indicators""" fraud_score = 0.0 indicators = [] # Check for suspicious patterns # Late reporting days_to_report = (claim.reported_date - claim.date_of_loss).days if days_to_report > 30: fraud_score += 0.2 indicators.append('Late reporting') # High loss amount if claim.estimated_loss > Decimal('50000'): fraud_score += 0.15 indicators.append('High loss amount') # Multiple claims (would check historical data) # Implementation would query claim history return { 'fraud_score': fraud_score, 'indicators': indicators, 'recommendation': 'investigate' if fraud_score > 0.5 else 'proceed' } ``` ## Actuarial Analysis ```python import numpy as np from scipy import stats class ActuarialAnalysis: """Actuarial modeling and analysis""" def calculate_loss_ratio(self, total_claims_paid: Decimal, total_premiums_earned: Decimal) -> dict: """Calculate loss ratio""" if total_premiums_earned == 0: return {'error': 'No premiums earned'} loss_ratio = (total_claims_paid / total_premiums_earned) * 100 # Interpret loss ratio if loss_ratio < 60: assessment = "Profitable" elif loss_ratio < 75: assessment = "Target range" elif loss_ratio < 100: assessment = "Unprofitable" else: assessment = "Significant losses" return { 'loss_ratio': float(loss_ratio), 'claims_paid': float(total_claims_paid), 'premiums_earned': float(total_premiums_earned), 'assessment': assessment } def calculate_combined_ratio(self, loss_ratio: float, expense_ratio: float) -> dict: """Calculate combined ratio""" combined_ratio = loss_ratio + expense_ratio profitable = combined_ratio < 100 return { 'combined_ratio': combined_ratio, 'loss_ratio': loss_ratio, 'expense_ratio': expense_ratio, 'profitable': profitable, 'underwriting_gain_loss': 100 - combined_ratio } def estimate_reserves(self, claim_data: List[dict]) -> dict: """Estimate loss reserves using chain ladder method""" # Simplified chain ladder method # In production, would use more sophisticated methods open_claims = [c for c in claim_data if c['status'] != 'closed'] total_incurred = sum(c['paid_amount'] + c['reserve'] for c in open_claims) return { 'total_reserve': total_incurred, 'open_claim_count': len(open_claims), 'method': 'chain_ladder' } def price_product(self, expected_claims: Decimal, expense_ratio: float, profit_margin: float) -> Decimal: """Calculate premium for insurance product""" # Pure premium (expected losses) pure_premium = expected_claims # Load for expenses expense_load = pure_premium * Decimal(str(expense_ratio / 100)) # Load for profit profit_load = pure_premium * Decimal(str(profit_margin / 100)) # Total premium total_premium = pure_premium + expense_load + profit_load return total_premium.quantize(Decimal('0.01')) ``` ## Best Practices ### Underwriting - Use consistent risk assessment criteria - Implement automated underwriting for simple cases - Maintain underwriting guidelines documentation - Use predictive analytics for risk scoring - Conduct regular portfolio reviews - Segment risks appropriately - Monitor loss ratios by segment ### Claims Processing - Provide 24/7 claim reporting - Assign adjusters quickly - Set appropriate reserves - Communicate regularly with claimants - Implement fraud detection - Track claim cycle time - Use photos and video for inspections ### Fraud Prevention - Screen all claims for fraud indicators - Use predictive analytics - Maintain Special Investigation Unit (SIU) - Share fraud data industry-wide - Train staff on fraud detection - Implement identity verification - Monitor for organized fraud rings ### Compliance - Maintain state licensing - Follow NAIC model laws - Implement proper data privacy controls - Conduct regular compliance audits - Maintain required reserves - File timely regulatory reports - Follow fair claims practices ## Anti-Patterns ❌ Manual underwriting for all policies ❌ No fraud detection system ❌ Slow claims processing ❌ Inadequate loss reserves ❌ Poor customer communication ❌ No data analytics ❌ Ignoring regulatory changes ❌ Inconsistent underwriting decisions ❌ No claims automation ## Reference Documentation Detailed material lives alongside this skill and is read on demand: - [Policy Administration System](references/POLICY_ADMINISTRATION_SYSTEM.md) ## Resources - ACORD Standards: https://www.acord.org/ - NAIC (National Association of Insurance Commissioners): https://www.naic.org/ - ISO (Insurance Services Office): https://www.verisk.com/iso/ - Society of Actuaries: https://www.soa.org/ - Casualty Actuarial Society: https://www.casact.org/ - Insurance Information Institute: https://www.iii.org/ - A.M. Best (ratings): https://www.ambest.com/