The shift

• AI went from research labs to every desktop
• ChatGPT reached 100M users in 2 months
• Every industry is being reshaped
• Finance is especially impacted

Today's goal

• Understand what AI/LLMs actually are
• Know the key concepts and vocabulary
• See how AI writes & understands code
• Learn about Claude Code extensibility

How it's built

• Collect billions of pages of text (books, websites, code)
• Train a neural network to predict "what comes next"
• Fine-tune it to be helpful, harmless, and honest
• Result: a system that can converse, analyze, and create

Key properties

• General purpose — not built for one task
• Natural language — you talk to it in English
• Context-aware — remembers the conversation
• Probabilistic — generates likely responses, not exact lookups

Great at

• Summarizing documents & reports
• Drafting emails, memos, presentations
• Explaining complex concepts simply
• Analyzing and transforming data
• Writing, reviewing, and debugging code
• Translating between languages
• Brainstorming and ideation

Not great at

• ✗ Guaranteed factual accuracy
• ✗ Real-time information (without tools)
• ✗ Complex math with exact precision
• ✗ Accessing your private systems (without integration)
• ✗ Replacing human judgment on critical decisions
• ✗ Understanding context it hasn't been given

Already happening

• Automated report generation
• Regulatory document analysis
• Customer service chatbots
• Code generation for quant models
• Risk assessment summarization
• Internal knowledge search

Emerging

• AI-assisted due diligence
• Automated compliance checking
• Natural language database queries
• Portfolio commentary drafting
• Contract review & extraction
• Anomaly detection explanations

Human language

Calculate the total revenue
for Q4 2025 and show it
as a formatted table.

Code (Python)

revenue = df[df['quarter'] == 'Q4-2025']
total = revenue['amount'].sum()
print(f"Q4 Revenue: ${total:,.2f}")

Terminal

$ ls project/
README.md  src/  tests/  package.json

$ claude
Claude Code v1.0
Ready. What would you like to do?

> Find all files that handle
  user authentication and
  explain how they work

Searching your codebase...

Bad: no context

You: "Fix the bug"

AI: "What bug? In what project?
     What language? What file?"

The AI is guessing.

Good: rich context

You: "Fix the login bug"

[Claude Code already knows:]
- Your tech stack (React + Node)
- The auth system (JWT tokens)
- Recent git changes
- The error in the logs

The AI gives a precise fix.

Vague prompt

"Make this better"

Better how? Faster? Prettier? More secure? The AI guesses.

Clear prompt

"Add input validation to the
login form. Check that email
is valid and password is at
least 8 characters. Show
error messages below each field."

Chatbot (basic)

You ask → it answers → done.

One question, one response. No actions taken.

Agent (Claude Code)

You ask → it thinks → reads files → plans → edits code → runs tests → fixes errors → reports back.

Multi-step, autonomous, uses tools along the way.

Permission model

• Claude asks before running commands
• You approve or deny each action
• You can pre-approve safe actions
• You can block dangerous actions permanently

Example

Claude wants to run:
npm test

[Allow]  [Deny]  [Always allow]

"Always allow" means you won't be asked again for npm test.

Without CLAUDE.md

You: "Run the tests"
AI: "What test framework?
     What command?
     Where are the tests?"

You: "Jest. npm test. In /tests"
AI: "Got it..."

(Repeat every session)

With CLAUDE.md

You: "Run the tests"
AI: "Running npm test..."

Claude already knows:
- Framework: Jest
- Command: npm test
- Location: /tests
- Style: 2-space indent
- Language: TypeScript

Folder structure

your-project/
├── CLAUDE.md
└── .claude/
    └── rules/
        ├── code-style.md
        ├── security.md
        ├── api-standards.md
        └── compliance.md

All .md files in rules/ are loaded automatically.

Path-specific rules

# .claude/rules/api-standards.md
---
paths:
  - "src/api/**/*.py"
---

All API endpoints must:
- Validate input with Pydantic
- Log to the audit trail
- Return standard error format
- Require authentication

These rules only activate when Claude works on matching files.

/audit-check

Review code changes for compliance with SOX, PCI-DSS, or internal audit requirements.

/data-quality

Validate data pipeline code ensures no silent data loss, null handling, and type safety.

/explain-model

Generate plain-English documentation for quantitative models and algorithms.

/security-scan

Check for hardcoded credentials, insecure API calls, and data exposure risks.

/migration

Plan and execute database schema changes with rollback strategies.

/incident-report

Generate an incident report from git logs and error traces.

Cloud service (one command)

# Connect to GitHub
claude mcp add \
  --transport http \
  github \
  https://api.githubcopilot.com/mcp/

# Then authenticate:
> /mcp

Now Claude can create PRs, review code, manage issues.

Database (local)

# Connect to PostgreSQL
claude mcp add \
  --transport stdio \
  mydb \
  -- npx -y @bytebase/dbhub \
  --dsn "postgresql://..."

Now Claude can query your database in natural language.

When can hooks fire?

• Before Claude uses a tool
• After Claude edits a file
• When you submit a prompt
• When Claude finishes responding
• When a session starts

What can they do?

• Auto-format code after changes
• Block edits to sensitive files
• Send notifications
• Run tests automatically
• Log all commands for auditing

Auto-format after every edit

{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Edit|Write",
      "hooks": [{
        "type": "command",
        "command": "prettier --write"
      }]
    }]
  }
}

Every time Claude edits a file, it gets auto-formatted.

Block editing .env files

{
  "hooks": {
    "PreToolUse": [{
      "matcher": "Edit|Write",
      "hooks": [{
        "type": "command",
        "command": "... | grep '.env'
          && exit 2 || exit 0"
      }]
    }]
  }
}

exit 2 = block the action. Protects secrets.

What's in a plugin?

• Skills — slash commands
• Hooks — automated triggers
• MCP Servers — integrations
• Agents — specialized sub-agents

Any or all of these. A plugin can be simple (one skill) or comprehensive.

Why plugins?

• Share workflows with your team
• Version your extensions
• Distribute via a marketplace
• Enforce standards across projects

Allow safe operations

{
  "permissions": {
    "allow": [
      "Bash(npm test *)",
      "Bash(git status)",
      "Read(./src/**)"
    ]
  }
}

Block dangerous operations

{
  "permissions": {
    "deny": [
      "Bash(rm *)",
      "Read(.env*)",
      "Bash(curl *)",
      "Read(./secrets/**)"
    ]
  }
}

Compliance & Audit

• Auto-check code against regulatory rules
• Generate audit logs of all AI actions
• Block modifications to sensitive data paths
• Ensure all monetary calculations use Decimal

Data & Analytics

• Query databases in plain English
• Generate reports from data pipelines
• Validate data quality checks
• Document quantitative models

Development Velocity

• Onboard new developers instantly
• Standardize code review process
• Automate repetitive development tasks
• Reduce context-switching overhead

Risk Management

• Review changes to pricing models
• Enforce permission boundaries
• Detect code that touches PII
• Ensure test coverage on critical paths

Built-in safeguards

• Permission prompts for every action
• Allow/deny lists for tools and files
• Enterprise managed settings
• MCP server access controls
• Hooks for policy enforcement
• Audit logging capabilities

Best practices

• Never commit secrets in CLAUDE.md
• Use deny rules for sensitive files
• Use read-only DB connections for MCP
• Review Claude's changes before deploying
• Enable command logging hooks
• Use managed settings for org policies

How it works

• Claude Code uses the Anthropic API
• You pay per token (input + output)
• Or use Claude Max/Team/Enterprise plans
• Check usage anytime with /cost

Controlling costs

• Use /compact to reduce context size
• Skills with context: fork use separate context
• Use smaller models for simple tasks
• Set spending limits in your account