finance-expert

Expert guidance for financial systems, FinTech applications, banking platforms, and payment processing.

personamanagmentlayer/pcl|Updated May 12, 2026

Works with

Claude CodeCursorClineWindsurfCodexGoose

What it does

Covers payment gateway integration (Stripe), open banking APIs (Plaid), and core banking concepts including PCI-DSS, SOX, and Basel III compliance
Includes practical code examples for payment processing, refunds, webhook handling, and bank account/transaction retrieval
Provides financial calculation utilities for compound interest, loan amortization, NPV, and ROI with proper Decima

Repository

personamanagmentlayer/pcl

Last updated

May 12, 2026

Installation Guide

Select your AI agent

How to use finance-expert on Cursor

AI-first code editor with Composer

Prerequisites

Before installing skills in Cursor, ensure your development environment meets these requirements:

›Cursor installed and configured on your machine
›Node.js 16+ with npm — verify with node --version
›Active project directory where you want to add finance-expert

Run the install command

Execute the skills CLI command in your project's root directory to begin installation:

$npx skills add https://github.com/personamanagmentlayer/pcl --skill finance-expert

Fetches finance-expert from personamanagmentlayer/pcl and configures it for Cursor.

Select Cursor when prompted

The CLI shows a list of agents. Use arrow keys and space to select Cursor:

◆ Which agents do you want to install to?

│

│ ── Universal (.agents/skills) ────────────────

│ · Cline · Codex · Goose · Windsurf

│ ●Cursor(selected)

│ · Cursor · Aider · Continue

Verify installation

Confirm successful installation by checking the skill directory location:

.cursor/skills/finance-expert

Restart Cursor to activate finance-expert. Access via /finance-expert in your agent's command palette.

⚠

Security Notice

We perform automated surface-level scans (Gen AI Scanner, Socket, Snyk) during installation. These checks detect common vulnerabilities but do not guarantee complete security. Always review skill source code and verify the publisher's reputation before production use.

Skills execute code in your environment. Always review source, verify the publisher, and test in isolation before production.

›View source on GitHub ›Skills CLI docs ›About Cursor ›What are agent skills?

Documentation

List & Monetize Your Skill

Submit your Claude Code skill and start earning

Get started →

Use Cases

User Story & Requirements Generation

Create detailed user stories, acceptance criteria, and feature specs

Example

Generate user stories for 'password reset feature' with acceptance criteria, edge cases, and test scenarios

✓

Reduce spec writing time by 50%, ensure comprehensive coverage

Competitive Analysis

Research competitors, compare features, identify gaps

Example

Analyze 5 competitor products, create feature comparison matrix, suggest differentiation opportunities

✓

Complete competitive research in 2 hours instead of 2 days

Roadmap Prioritization

Evaluate features using frameworks (RICE, ICE, Kano) and create prioritized backlogs

Example

Score 20 feature ideas using RICE framework, generate prioritized roadmap with rationale

Core Concepts

Financial Systems

Core banking systems

Payment processing

Trading platforms

Risk management

Regulatory compliance (PCI-DSS, SOX, Basel III)

Financial reporting

FinTech Stack

Payment gateways (Stripe, PayPal, Square)

Banking APIs (Plaid, Yodlee)

Blockchain/crypto

Open Banking APIs

Mobile banking

Digital wallets

Key Challenges

Security and fraud prevention

Real-time processing

High availability (99.999%)

Regulatory compliance

Data privacy

Transaction accuracy

Payment Processing

# Payment gateway integration (Stripe) import stripe from decimal import Decimal stripe.api_key = "sk_test_..." class PaymentService: def create_payment_intent(self, amount: Decimal, currency: str = "usd"): """Create payment intent with idempotency""" return stripe.PaymentIntent.create( amount=int(amount * 100), # Convert to cents currency=currency, payment_method_types=["card"], metadata={"order_id": "12345"} ) def process_refund(self, payment_intent_id: str, amount: Decimal = None): """Process full or partial refund""" return stripe.Refund.create( payment_intent=payment_intent_id, amount=int(amount * 100) if amount else None ) def handle_webhook(self, payload: str, signature: str): """Handle Stripe webhook events""" try: event = stripe.Webhook.construct_event( payload, signature, webhook_secret ) if event.type == "payment_intent.succeeded": payment_intent = event.data.object self.handle_successful_payment(payment_intent) elif event.type == "payment_intent.payment_failed": payment_intent = event.data.object self.handle_failed_payment(payment_intent) return {"status": "success"} except ValueError: return {"status": "invalid_payload"}

Banking Integration

# Open Banking API integration (Plaid) from plaid import Client from plaid.errors import PlaidError class BankingService: def __init__(self): self.client = Client( client_id="...", secret="...", environment="sandbox" ) def create_link_token(self, user_id: str): """Create link token for Plaid Link""" response = self.client.LinkToken.create({ "user": {"client_user_id": user_id}, "client_name": "My App", "products": ["auth", "transactions"], "country_codes": ["US"], "language": "en" }) return response["link_token"] def exchange_public_token(self, public_token: str): """Exchange public token for access token""" response = self.client.Item.public_token.exchange(public_token) return { "access_token": response["access_token"], "item_id": response["item_id"] } def get_accounts(self, access_token: str): """Get user's bank accounts""" response = self.client.Accounts.get(access_token) return response["accounts"] def get_transactions(self, access_token: str, start_date: str, end_date: str): """Get transactions for date range""" response = self.client.Transactions.get( access_token, start_date, end_date ) return response["transactions"]

Financial Calculations

from decimal import Decimal, ROUND_HALF_UP from datetime import datetime, timedelta class FinancialCalculator: @staticmethod def calculate_interest(principal: Decimal, rate: Decimal, periods: int) -> Decimal: """Calculate compound interest""" return principal * ((1 + rate) ** periods - 1) @staticmethod def calculate_loan_payment(principal: Decimal, annual_rate: Decimal, months: int) -> Decimal: """Calculate monthly loan payment (amortization)""" monthly_rate = annual_rate / 12 payment = principal * (monthly_rate * (1 + monthly_rate) ** months) / \ ((1 + monthly_rate) ** months - 1) return payment.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP) @staticmethod def calculate_npv(cash_flows: list[Decimal], discount_rate: Decimal) -> Decimal: """Calculate Net Present Value""" npv = Decimal('0') for i, cf in enumerate(cash_flows): npv += cf / ((1 + discount_rate) ** i) return npv.

finance-expert

What it does

Category

Repository

Last updated

Installation Guide

How to use finance-expert on Cursor

Prerequisites

Run the install command

Select Cursor when prompted

Verify installation

Security Notice

Documentation

List & Monetize Your Skill

Use Cases

User Story & Requirements Generation

Competitive Analysis

Roadmap Prioritization

Install Skill

Finance Expert

Core Concepts

Financial Systems

FinTech Stack

Key Challenges

Payment Processing

Banking Integration

Financial Calculations

Stakeholder Communication

Implementation Guide

Best Practices

When to Use This

Learning Path

Related Skills

pwa-expert

antigravity-design-expert

interior-design-expert

grill-me

premortem

deslop

Reviews

Discussion

`Stakeholder Communication`

`Implementation Guide`

`Best Practices`

`When to Use This`

`Learning Path`

`Related Skills`

`Reviews`

`Discussion`