Vibe Coding with Claude

What "Vibe Coding" Actually Is

Describe your trading ideas in plain English. AI turns them into working automations, scripts, dashboards, or mini-apps. No coding required. Transform your trading knowledge into functional tools.

Why Traders Love It

Traditional software development is slow, expensive, and technical. Vibe coding flips this model, giving you direct control over your tools.

• 10× Faster: Weeks become hours. Prototype and iterate on trading strategies in real-time.
• No Dev Costs: Stop paying developers. Build exactly what you need, when you need it.
• No Waiting: Build what you want instantly. Adapt to market changes immediately.
• Rapid Iteration: Test ideas instantly. Modify and redeploy in minutes, not months.

Real Trader Wins

Build tools previously only available to hedge funds with dedicated teams. Six real-world applications:

Your Mindset Shift

You're no longer just a trader. You're now the product owner, and Claude is your junior developer who never sleeps. You describe the vision; Claude builds it.

Before: Great idea → Look for software → Nothing matches → Compromise or pay developer → Weeks/months later.

After: Great idea → Describe to Claude → Claude builds it in minutes → You test → You refine → Custom tool ready.

Your new reality: Don't become a programmer. Become a clear communicator of your trading logic. The AI handles implementation. You provide domain expertise and strategy.

Claude feels like having a full development team in one window. You control which stage to use – start in Chat, escalate to Cowork, then go full Code when you want a finished tool. This flexibility means you're never overpowered or underwhelmed; you get exactly the right level of assistance for each task.

The Three Modes Explained

Claude operates in three distinct modes. Think of it like having access to a consultant, collaborator, and full development team all in one place. Understanding when to use each mode is key to maximizing productivity.

Stage 1 – Chat = Consultant Service

Quick expert advice, explanations, brainstorming. Perfect for getting unstuck or understanding concepts. Like having a knowledgeable trading consultant available 24/7. (Use: claude.ai chat window)

When to use Chat:

• Understanding new indicators or concepts
• Brainstorming strategy ideas
• Getting unstuck on problems
• Explaining complex topics simply
• Quick research questions

Act as my trading consultant – explain Bollinger Bands and when to use them in plain English

Stage 2 – Cowork = Automate Workflow

Step-by-step collaboration with memory. Building small automations together. Claude remembers context and builds iteratively. Like having a capable junior developer sitting next to you. (Use: Claude Projects — gives Claude persistent memory across sessions)

When to use Cowork:

• Building multi-step automations
• Iterating on existing code
• When you want to be involved in process
• Complex tasks needing guidance
• Learning while building

Cowork with me – turn my Excel watchlist into an automated RSI + volume spike alert workflow

Stage 3 – Code = Building System

Full agent mode: plans, writes, debugs, and delivers complete working systems. Claude handles everything from architecture to deployment. Like having a full development team at your disposal. (Use: Claude Code — the CLI tool that runs directly in your terminal and IDE)

When to use Code:

• Complete projects from scratch
• Complex systems with multiple components
• When you want Claude to handle everything
• Production-ready implementations
• Full-stack applications

Build me an entire portfolio dashboard system that pulls live prices, runs my custom strategy, and emails daily signals

Pro Tip: Progressive Escalation

Start in Chat mode, escalate to Cowork as you get more specific, then move to Code mode when ready for a finished product. Progressive escalation ensures you're always using the right tool for the job.

Example workflow:

1. Chat: "What's the best way to create a trading journal?" (Research and ideas)
2. Cowork: "Help me build a simple journal that tracks trades and calculates P&L" (Iterative building)
3. Code: "Create a full trading journal system with charts, reports, and cloud backup" (Complete system)

Super high-level only – no jargon overload. You only need 5% of programming knowledge to vibe code effectively. The goal: understand enough to communicate with your AI partner.

The Trader-Programmer Translation Guide

Programming concepts sound intimidating, but when translated into trading terms, they become intuitive. Here's your cheat sheet:

Variables

Think of variables as labeled boxes where you store data. In trading, you're constantly dealing with data – stock prices, portfolio values, indicators, trade quantities. Variables are how computers remember this data.

• In trading: Your watchlist, portfolio size, current price, RSI value, number of shares
• In code: `stock_symbol = "AAPL"`, `shares = 100`, `current_price = 178.50`
• Why it matters: Helps you give Claude clear instructions about what data to track

Loops

Doing the same thing multiple times automatically. This is powerful for traders because you often need to apply the same analysis across multiple stocks, timeframes, or days.

• In trading: Checking every stock for signals, calculating indicators for each day, applying strategy to multiple positions
• In code: "For each stock in my list, check if RSI is low", "Loop through last 30 days to calculate moving average"
• Why it matters: Loops turn manual tasks into automated processes that work at scale

Functions

Reusable pieces of code that do one specific job. Think of functions as pre-built calculators or tools you can use repeatedly with different inputs.

• In trading: "Calculate RSI" for every stock, "Calculate position size" for every trade, "Calculate stop loss" consistently
• In code: A function you can call with any stock price to get RSI, a function that takes risk amount to suggest position size
• Why it matters: Functions ensure consistency and make code easier to maintain. Change one place, updates everywhere

If-Statements

Making decisions based on conditions. This powers trading strategies – it's the "if this, then that" logic that determines when to buy, sell, or hold.

• In trading: "If price crosses above $200, then buy", "If RSI drops below 30, look for reversal", "If earnings are positive, consider position"
• In code: `if price > 200: buy()`, `if rsi < 30: check_for_reversal()`
• Why it matters: If-statements encode your trading strategy into rules a computer can execute automatically

Think Like a Trader: Data → Logic → Output

At its core, all trading follows this pattern: you have data, you apply logic (your strategy), and you get output (decisions). Programming follows the exact same pattern.

• Data: Stock prices, volume, news, indicators, your portfolio
• Logic: Your trading strategy, entry/exit rules, risk management
• Output: Buy/sell signals, position sizes, portfolio allocations, alerts

You Don't Need to Be an Expert

The beauty of vibe coding: you don't need to master these concepts. Understand them well enough to explain what you want to Claude. When in doubt, describe it in plain English: "I want to check all my stocks and send me an alert if any are cheap." Claude figures out the loops, conditions, and data structures.

Hands-on! Automate what you do manually in Excel/Google Sheets. Transform repetitive tasks into automated workflows that run in the background, freeing you to focus on analysis and decision-making.

Fetch Market Data (Free & Paid APIs)

The foundation of trading automation is data. Numerous free APIs provide real-time and historical market data. These APIs feed your automated tools with the information they need.

Popular Data Providers:

What you can get:

• Real-time prices: Current stock prices, volume
• Historical data: Daily, weekly, intraday prices
• Fundamentals: Earnings, balance sheets, income statements
• Technical indicators: Moving averages, RSI, MACD
• Crypto data: Real-time and historical prices from CoinGecko, CoinMarketCap

How to start:

Most free APIs require signup for an API key. Use Claude to write code that fetches data. You don't need to learn API documentation – just tell Claude what data you want, it figures out how to get it.

Simple Analysis & Alerts

Once you have data, analyze it and get alerts when something important happens. This automates your trading strategy – define conditions, system watches 24/7.

Portfolio Tracker from Broker CSV

Export holdings, manually track in spreadsheet. Build system that does it all automatically.

What to automate:

• Real-time value: Fetch prices and calculate total portfolio value
• Gain/loss: Track realized and unrealized P&L
• Sector allocation: See diversification across sectors
• Risk metrics: Calculate beta, concentration risk, position sizing
• Performance: Compare returns to benchmarks
• Dividend tracking: Track dividend income and yield

Trading Journal Integration:

News + Sentiment Digest

Information overload is real. Every day, hundreds of articles compete for attention. AI reads all content and delivers concise summaries.

What Claude can do:

• Aggregate headlines: Pull from multiple sources (Yahoo Finance, Bloomberg, Reuters, Seeking Alpha)
• Filter relevance: Identify headlines that matter for your watchlist
• Sentiment analysis: Classify articles as bullish, bearish, or neutral
• Key themes: Identify common themes across sources (e.g., AI regulation)
• Actionable insights: Summarize information to help trading decisions

📰 NEWS DIGEST - March 15, 2026

🟢 AAPL: Bullish sentiment (78% positive)
   - Strong iPhone 18 pre-orders reported
   - Analyst upgrades from Morgan Stanley and Goldman Sachs
   - New chip partnership announced with NVIDIA

🔴 TSLA: Bearish sentiment (62% negative)
   - Production delays at new Berlin plant
   - Increased competition in Chinese EV market
   - CEO tweet causes short-term volatility

🟡 NVDA: Mixed sentiment (55% neutral)
   - Strong data center demand
   - Concerns about AI chip oversupply

Key Themes: AI chip demand, EV market competition, Apple product cycle

Help me build a simple script that:
1. Fetches daily prices for my watchlist
2. Calculates RSI for each stock
3. Sends me an email alert if any stock's RSI is below 30

Getting Started

The hardest part is starting. Simple progression to get comfortable:

1. Start small: Pick one simple task (e.g., checking price of one stock)
2. Describe to Claude: "I want to get an alert when AAPL is above $200"
3. Test it: Run automation and verify it works
4. Iterate: "Now do the same for my whole watchlist"
5. Expand: Add more conditions, stocks, complexity as you get comfortable

Understanding modern application architecture in simple terms. No CS degree needed – just practical knowledge of how trading tools are built.

The Four Key Components

Every modern trading application has four main parts. Understanding these helps you communicate what you want and make better architectural decisions.

How Claude Builds Systems

Claude can generate an entire stack for you. You describe what you want, and Claude handles:

• Architecture planning: How components connect and communicate
• Front-end development: Building the user interface
• Back-end implementation: Server logic and calculations
• Database design: Structuring your data
• API integration: Connecting to external services

Architecture Diagram

Visual representation of a typical trading application:

Build me a simple web dashboard that shows my portfolio + AI sentiment

Requirements:
- Display my current portfolio with real-time prices
- Show AI sentiment analysis for each holding
- Include a chart of portfolio performance over time
- Make it look clean and professional

Why you need an editor even when using AI. The right IDE makes vibe coding 10× more efficient by providing better code organization, debugging tools, and seamless integration with AI assistants.

Why You Need an Editor

• Better organization: Keep your projects structured and manageable
• Debugging tools: Find and fix errors quickly
• Code completion: Write code faster with intelligent suggestions
• Version control: Track changes and collaborate easily
• AI integration: Seamless access to AI coding assistants

VS Code + Claude Extension

Free, most popular IDE with powerful Claude integration. Perfect for most vibe coding needs.

Features:

• Free and open-source
• Huge ecosystem of extensions
• Official Claude extension available
• Built-in debugging and terminal
• Great documentation and community

When to use VS Code:

• Starting out with vibe coding
• Need to integrate with other tools
• Working with existing projects
• Learning standard development practices

Cursor – The AI-First Editor

VS Code fork with AI built-in from the ground up. Designed specifically for AI-assisted coding.

Features:

• Built-in AI code completion and generation
• Intelligent code refactoring suggestions
• Better context awareness for AI
• Familiar VS Code interface
• Optimized for AI workflows

When to use Cursor:

• Wanting the best AI-assisted experience
• Heavy focus on AI-powered development
• Comfortable with VS Code but want more AI
• Building complex AI applications

Antigravity – Google's Agent-First IDE

Google's new experimental IDE built around AI agents. Different approach to AI-assisted coding.

Features:

• Agent-based development model
• Built specifically for AI workflows
• Advanced AI collaboration features
• Google ecosystem integration
• Experimental and evolving rapidly

When to use Antigravity:

• Interested in cutting-edge AI development
• Wanting to experiment with agent-based coding
• Already in Google ecosystem
• Comfortable with beta software

Quick Setup Guide

1. Download: Get VS Code from code.visualstudio.com
2. Install Claude extension: Search for Claude in Extensions marketplace
3. Sign in: Connect your Claude account
4. Create your first project: File → Open Folder
5. Start coding: Use Claude extension or web interface

Running, Debugging, and Improving Code

Once your code is written, your IDE helps you run it, find errors, and improve it:

• Run code: Use the terminal or built-in run buttons
• Debug: Set breakpoints, inspect variables, step through code
• Improve: Ask Claude to refactor, optimize, or extend functionality
• Test: Write and run test cases to ensure code works correctly

Understanding the landscape of AI coding assistants. While Claude is our primary tool, knowing alternatives helps you make informed decisions and choose the right tool for each situation.

Comparison Table

Detailed Breakdown

AI Assistant Logos:

Claude

Best Overall

Excellent for vibe coding with strong reasoning, great code quality, and deep understanding of context. Particularly good at complex trading logic and maintaining conversation history across sessions.

Strengths:

• Superior code quality and reasoning
• Excellent at maintaining context across long conversations
• Strong understanding of complex business logic
• Great for trading strategy implementation
• Good balance of speed and accuracy

When to use:

• Complex trading strategy implementation
• Projects requiring deep understanding of requirements
• Multi-step workflows with context retention
• When code quality is critical

Pricing: Free tier available, Pro at $20/month

CodeX (OpenAI)

OpenAI's Coding Assistant

OpenAI's AI coding assistant, similar to Claude Code. Trained on vast code repositories and excels at generating, debugging, and explaining code across many languages.

Strengths:

• Strong code generation across many languages
• Excellent at debugging and fixing code
• Good at explaining code logic
• Integrated with OpenAI's ecosystem
• Fast and responsive

When to use:

• When you need multi-language support
• Debugging complex code issues
• Explaining how code works
• Already using OpenAI tools

Limitations:

• May not match Claude's context retention
• Different safety guardrails than Claude

Pricing: Pay-as-you-go; check OpenAI for current rates

Z.AI

Speed Specialist

Focuses on rapid code generation and specialized coding tasks. Excellent for quick prototypes and simple implementations where speed is the priority.

Strengths:

• Very fast code generation
• Good at specific coding patterns
• Quick response times
• Solid for common programming tasks

When to use:

• Rapid prototyping
• Simple, well-defined coding tasks
• When speed is more important than depth
• Learning coding patterns quickly

Limitations:

• May struggle with complex reasoning
• Less context retention than Claude

Pricing: Competitive; check their website for current rates

Kimi

Context Specialist

ByteDance's AI assistant with strong performance on context-heavy tasks. Good for understanding and working with large codebases.

Strengths:

• Good at handling large amounts of context
• Strong performance on codebase analysis
• Good for international users
• Competitive pricing

When to use:

• Working with large existing codebases
• Need to understand complex project structures
• International users (Chinese support)
• Context-heavy coding tasks

Limitations:

• May not match Claude's trading logic understanding
• Less established in English markets

Pricing: Competitive; check their website for current rates

Alibaba CodePlan

Enterprise-Grade

Designed for enterprise users with robust features, strong integration, and compliance-focused development. Good for businesses and enterprise projects.

Strengths:

• Enterprise-grade features and security
• Good integration with Alibaba's cloud services
• Strong compliance and governance features
• Suitable for large teams and organizations

When to use:

• Enterprise projects with compliance requirements
• Large team development
• Integration with Alibaba Cloud services

Pricing: Enterprise pricing; contact Alibaba for details

Congratulations! You now have the knowledge and tools to start vibe coding your trading automations. Let's cover limitations, safety considerations, and your next steps.

Limitations & Safety

While vibe coding is powerful, it's important to understand its limitations and follow safety best practices.

Never paste real money API keys:

• Never share your broker API keys with any AI assistant
• Use sandbox/test environments when possible
• Rotate API keys regularly
• Use environment variables for sensitive data

AI Limitations:

• May produce code that needs debugging
• Can hallucinate or make mistakes
• Not infallible – always review generated code
• May not know your specific broker's API quirks

Best Next 3 Projects for Traders

Ready to start building? Here are three beginner-friendly projects to get you started:

Resources & Community

Essential Resources

• Claude Documentation: docs.anthropic.com – official Claude documentation
• Tailwind CSS: tailwindcss.com – for building beautiful dashboards
• Python for Finance: O'Reilly books, online courses
• QuantConnect: quantconnect.com – algorithmic trading platform
• TradingView: tradingview.com – charting and Pine Script

Free APIs to Explore

• Alpha Vantage: Free stock market data, 25 calls/day
• Yahoo Finance: Unofficial but widely used, generous limits
• Financial Modeling Prep: Free tier available
• CoinGecko: Free cryptocurrency data

Community & Support

• Reddit: r/algotrading, r/learnprogramming
• Discord: Various trading and coding communities
• Twitter: Follow #algotrading, #vibecoding
• GitHub: Open-source trading projects

AI Limitations (In Pictures)

Understanding when AI might struggle:

A Reality Check (Just for Laughs!)

When you're vibe coding, keep these sarcastic truths in mind:

The "Looks Good to Me" Moment

When the AI gives you 200 lines of complex code you absolutely don't understand, but you click "Accept" anyway because it has a cool function name. 🤷‍♂️

The "Fixed It!" Flex

AI breaks your code, then proudly announces "Fixed the bug I introduced in the previous message." It's like hiring a contractor who sets your house on fire then charges you to rebuild it. 🔥🚒

The "I Have No Idea What I'm Doing" Power Trip

"Build me a neural network to predict stock prices using quantum mechanics." You have no idea what that means, the AI has no idea what that means, but now you're trading with it. 📉🚀

Claude Code is a separate tool from claude.ai. Instead of chatting in a browser, Claude runs directly inside your project folder, reads every file, runs commands, and ships working code — all from your terminal or VS Code. This is "Stage 3 – Code" from Module 2, in full detail.

Core Concepts

Think of Claude Code as a coding colleague who lives inside your project. It can:

How Claude Code Works (The Loop)

Every task runs through the same four-step cycle:

1. Gather context: Claude reads your files and searches for relevant code
2. Take action: Makes file edits, runs commands, calls external services
3. Verify results: Runs tests, checks output, compares with expected results
4. Repeat: Each result informs the next step until the task is complete

For traders: describe your strategy goal, Claude builds the script, runs a quick test, and fixes any errors — all in one session.

The .claude Directory

Claude Code uses a hidden .claude/ folder in your project to store its brain. Key files:

Store Instructions & Memories

Two memory systems work together:

• CLAUDE.md (your rules): Write once, Claude follows every session. Example:
  Copy

  # Trading Conventions
  - Always use 2 decimal places for position sizes
  - Fetch data using yfinance library, not Alpha Vantage
  - Run pytest before committing any changes
  - Never hardcode API keys — use environment variables

• Auto memory (Claude's notes): Claude automatically writes notes about things it discovers — your project structure, debugging insights, your preferences. First 25KB loaded every session.

Keep CLAUDE.md under 200 lines. Longer files get ignored.

Permission Modes

Control how much Claude can do without asking you first:

Cycle between modes with Shift+Tab. For traders: use Plan Mode whenever changing live trading logic — see what Claude intends before it touches anything.

Context Window — Your Working Memory

Claude can only hold a limited amount of information at once (think: 200,000 words of sticky notes). When it fills up, it auto-compresses old messages.

Tips to avoid running out:

• Type /clear between unrelated tasks to start fresh
• Keep CLAUDE.md concise — it loads fully every session
• Use subagents for heavy investigation work (keeps your main session clean)
• Long backtest output in your conversation eats context — pipe long outputs to a file instead

Common Workflows for Traders

"give me an overview of this project"
"explain how the data pipeline works"
"where is RSI calculated?"

"my price fetcher returns NaN for TSLA"
"find and fix the issue, then run tests"

"add MACD calculation to my indicator module"
"send an email alert when RSI crosses 30"

"commit my changes with a clear message"
"create a pull request for this feature"

Extend Claude Code

Three powerful ways to expand what Claude can do:

• Skills: Package a repeatable workflow into a /skill-name command. Example: /analyze-backtest that always follows the same steps for reviewing your strategy results.
• MCP Servers: Connect Claude to external systems — your brokerage API, a Google Sheet of trades, a Slack channel for alerts. Claude can query and post to these directly.
• Hooks: Shell commands that run automatically at specific moments (e.g. run linting after every file edit, auto-commit before deploy).

Best Practices

VS Code IDE Integration

Claude Code works inside VS Code — no terminal required. The visual interface makes reviewing changes much easier.

Install

Search "Claude Code" in the VS Code Extensions marketplace, or run:
code --install-extension anthropic.claude-code

Open Claude

Click the spark icon (top-right of editor), or use the Activity Bar. Claude panel opens on the side.

Inline Diffs

Proposed file changes appear side-by-side in the editor. Accept or reject individual hunks before they're applied.

@-Mentions

Type @filename or drag a file into the prompt to include it. Select code and press Option+K to reference it directly.

Quick Setup Guide

1. Install Claude Code: VS Code extension or curl -fsSL https://claude.ai/install.sh | bash for terminal
2. Open your trading project folder in VS Code
3. Run /init — Claude scans your project and generates a starter CLAUDE.md
4. Edit CLAUDE.md — add your trading conventions and build commands
5. Start your first task: "explain what this script does" or "help me debug this data fetcher"

Essential Commands

Skills — Your Custom Slash Commands

Package any repeatable workflow into a single command you can invoke any time, in any project.

What is a Skill?

A skill is a reusable prompt + optional supporting files stored in .claude/skills/. You invoke it by typing /skill-name inside a Claude Code session. Claude loads the skill's instructions and executes the workflow — no copy-pasting prompts ever again.

Think of a skill like a macro. Instead of typing the same analysis request every morning, you type /morning-brief and Claude fetches prices, runs your indicators, summarises news, and formats a report — all in one shot.

Why skills beat just repeating a prompt:

• Skills load on-demand — they don't consume context until you actually call them
• Skills can include supporting files, scripts, and data references that aren't in your main conversation
• Skills are version-controlled alongside your project — teammates can use them too
• Skills stay consistent — you define the workflow once and it runs exactly the same every time

How to Use a Skill

Once a skill exists in your project, using it is instant:

/backtest-analysis          → runs your standard backtest review workflow
/morning-brief              → fetches prices + news + indicator summary
/deploy-staging             → runs tests, commits, pushes to staging server
/review-strategy            → checks your strategy for logic errors and edge cases

You can also pass arguments to skills:

/analyze-stock AAPL         → runs your standard stock deep-dive on AAPL
/backtest-analysis 2024-Q4  → runs backtest review scoped to Q4 2024

How to Build a Skill

A skill is just a markdown file. Here's the exact structure:

File: .claude/skills/morning-brief.md

---
description: Generate my daily trading brief — prices, indicators, news summary
---

You are my trading research assistant. Run this morning brief workflow:

1. Fetch current prices for my watchlist using yfinance:
   AAPL, TSLA, NVDA, SPY, QQQ

2. For each ticker, calculate:
   - RSI (14-day)
   - Whether price is above/below 20-day MA
   - Yesterday's % change

3. Flag any tickers where RSI is below 30 (oversold) or above 70 (overbought)

4. Summarise in a clean table, then add a 3-line market mood comment.

Output format:
| Ticker | Price | Change% | RSI | Signal |
|--------|-------|---------|-----|--------|

That's it. Save the file, then type /morning-brief in your next Claude Code session.

More complex skills can reference other files using @path/to/file syntax inside the skill markdown:

File: .claude/skills/deploy-to-render.md

---
description: Deploy the trading dashboard to Render
---

Follow the deployment checklist at @docs/deployment-checklist.md

Then run these steps:
1. Run pytest — all tests must pass before proceeding
2. Bump version in pyproject.toml
3. git add, commit with message "deploy: v{version}"
4. git push origin main
5. Confirm Render webhook triggered at https://dashboard.render.com

Building a Skill with Claude's Help

The easiest way to create a skill is to let Claude build it for you from a workflow you already do manually:

Every morning I do the same thing:
1. I check prices for my 10-stock watchlist
2. I calculate RSI manually in a spreadsheet
3. I copy-paste headlines from Yahoo Finance
4. I decide if I want to change any positions

Build me a Claude Code skill at .claude/skills/morning-brief.md
that automates this entire workflow and outputs a formatted daily brief.

How to Find Existing Skills

You don't always have to build from scratch. Skills are plain markdown files — they can be shared, copied, and adapted.

Pro tip: Once you have a skill you like, keep a personal ~/.claude/skills/ folder with your global skills — these are available in every project, not just one.

Using Claude Code with GitHub

GitHub isn't just for professional developers. For traders it's a goldmine of free tools, starter templates, and inspiration — and Claude Code is the perfect companion to read and customise any repo.

Why GitHub Matters for Traders

GitHub hosts millions of open-source projects. Thousands of them are trading tools, data pipelines, backtesting frameworks, and dashboards — built by other traders and quants and made free to use. Instead of building from zero, you can find something that's 80% of what you need, clone it, and ask Claude Code to customise the last 20%.

Finding Inspiration on GitHub

The GitHub search bar is powerful when you know the right terms. Here are search queries that surface trading-relevant projects:

# Search on github.com
topic:algorithmic-trading language:python stars:>100
topic:backtesting stars:>50
topic:stock-market language:python
"trading dashboard" language:python
"RSI alert" language:python
"portfolio tracker" python flask
"yfinance" dashboard stars:>200
"claude code" trading
"claude code" finance

GitHub Topics to browse directly:

Cloning and Running a Repo with Claude Code

Once you find a promising repo, this is the workflow:

# Step 1: Clone the repo
git clone https://github.com/someone/cool-trading-tool
cd cool-trading-tool

# Step 2: Open Claude Code
claude

# Step 3: Ask Claude to explain it
"Give me an overview of this project. What does it do,
 what are the main files, and how do I run it?"

# Step 4: Ask Claude to set it up for you
"Install dependencies and get this running on my machine."

# Step 5: Customise it
"Change the watchlist to AAPL, TSLA, NVDA, SPY.
 Also change the email alert to use my Gmail instead of SendGrid."

Finding Tools Others Built with Claude

A growing number of developers share Claude-assisted projects specifically. Good places to look:

• GitHub search: "built with claude" trading or "vibe coding" finance
• Reddit r/ClaudeAI: Weekly show-and-tell threads where people share tools they built. Filter by "trading", "finance", "portfolio"
• X/Twitter: Search #vibecoding trading or #claudecode finance — many people share links to their repos
• Hugging Face Spaces: Many AI-assisted trading dashboards are deployed as free interactive demos at huggingface.co/spaces

Customising an Open-Source Tool with Claude Code

This is one of the most powerful workflows available to you. Here's a realistic example:

Scenario: You found a Python portfolio tracker on GitHub. It works, but it shows USD only, doesn't include your broker's CSV format, and has no RSI column.

# Inside Claude Code, after cloning the repo:

"This project is a portfolio tracker. I want to customise it:
1. Add a currency converter so values show in both USD and THB
2. Change the CSV import to accept Interactive Brokers format
   (example file at @sample_data/ib_export.csv)
3. Add an RSI column calculated over 14 days
4. Change the chart colors to match my dark theme

Make these changes one at a time and run the app after each
change so I can verify it looks right."

Claude reads the entire codebase, figures out where each change needs to go, and implements them systematically — even in code it didn't write.

Contributing Back: Git Basics with Claude Code

Claude Code handles git for you. You don't need to memorise git commands:

"Show me what files changed"
"Commit my changes with a descriptive message"
"Create a new branch called feature/add-rsi-alerts"
"Push to GitHub"
"Create a pull request with a summary of what I changed"
"Undo the last change"
"Show me the history of changes to indicators.py"

Deploying Your Trading Tools

Running a script on your laptop is just the start. Deploying it means it runs 24/7 in the cloud — fetching data, sending alerts, and serving your dashboard — even when your computer is off.

The Deployment Landscape — Which Platform for What?

Different platforms suit different types of trading tools. Here's a plain-English breakdown:

Platform Deep-Dives

# Ask Claude Code to prepare your project for Render:
"Prepare my trading dashboard for deployment to Render.
 Add a requirements.txt, a Procfile, and make sure
 the port is configurable via environment variable."

# Ask Claude Code:
"Set up my project to deploy on Railway with a PostgreSQL database.
 Create the railway.json config, update the database connection
 to use the DATABASE_URL environment variable, and add a
 railway.toml with a cron job that runs fetch_prices.py every day at 7am."

# Ask Claude Code:
"Make my price fetcher script compatible with PythonAnywhere.
 Add error handling for network timeouts, log output to a file
 instead of the console, and write a setup guide for PythonAnywhere's
 cron scheduler."

Git — The Foundation of All Deployment

Every platform above connects to GitHub to deploy your code. Understanding the basic git workflow unlocks all of them — and Claude handles every git command for you.

"Push this project to a new private
GitHub repo called trading-dashboard"

"Commit all my changes and push
to GitHub"

"Add a .gitignore that excludes
.env and any CSV files with
trading data"

"Revert to the version before
my last commit"

Databases — Storing Your Trading Data

Your tools generate data — prices, trades, signals, backtests. A database is where that data lives permanently. Choosing the right one depends on how you'll use your tool.

The Big Picture: Types of Databases

There are two main families of database that matter for trading tools:

For most trader tools, SQL is the right choice. Your data is naturally structured: tickers, dates, prices, indicators. SQL handles this perfectly and Claude writes all the SQL for you.

SQLite — Your Local Database

SQLite

What it is: A database that lives in a single file on your computer (e.g. trading.db). No server to install or configure. Python's standard library includes SQLite support — zero setup.

Strengths:

• Zero setup — works immediately with import sqlite3
• The database is just a file — easy to back up, copy, share
• Fast for personal-scale data (millions of price records is fine)
• Works on PythonAnywhere and as local storage on Render/Railway
• Perfect for learning — no cloud account or billing needed

Limitations:

• File-based: if you deploy to a cloud server, the database lives on that server's disk. If the server restarts (common on free tiers), you may lose data unless you back it up
• Not designed for multiple simultaneous writers — fine for a personal tool, not for a multi-user platform

Best for: Local scripts, personal portfolio trackers, backtesting data storage, tools that run on your own machine.

Copy

# Ask Claude to set up SQLite for your trades:
"Create a SQLite database called trading.db with a table
for storing my daily price data (ticker, date, open, high,
low, close, volume) and a table for my trades
(ticker, date, action, quantity, price, notes)."

PostgreSQL — The Production Standard

PostgreSQL

What it is: A full database server. More powerful than SQLite, runs as a separate service, and handles multiple connections simultaneously. The industry standard for web applications.

Strengths:

• Handles large datasets efficiently — millions of rows with no slowdown
• Supports multiple users/connections at the same time
• Advanced features: JSON columns, full-text search, time-series extensions
• Integrated into Render, Railway, Neon, Supabase — one-click setup
• Data persists independently of your app server — survives server restarts

When to upgrade from SQLite to PostgreSQL:

• You're deploying to the cloud and need reliable data persistence
• Your data is growing beyond a few hundred thousand rows
• Multiple people or services need to access the database simultaneously
• You want your dashboard to survive a server restart without data loss

Copy

# Ask Claude to migrate from SQLite to PostgreSQL:
"My trading app currently uses SQLite. I'm deploying to Railway
and want to use their PostgreSQL database.
Migrate my database schema and update all connection code
to use the DATABASE_URL environment variable.
Keep backward compatibility with SQLite for local development."

Neon — PostgreSQL in the Cloud, Free Forever

# Ask Claude to connect your app to Neon:
"Connect my trading dashboard to a Neon PostgreSQL database.
 Use the DATABASE_URL environment variable for the connection string.
 Add connection pooling since Neon recommends it for serverless use.
 Create a test script that inserts a sample trade and reads it back."

Which Database Should You Use?

The Migration Path

Most traders start with SQLite and graduate to PostgreSQL/Neon as their tool grows. Claude Code handles this migration entirely:

# When you're ready to upgrade:
"My tool has grown and I want to move from SQLite to Neon PostgreSQL.
 1. Export all existing data from my SQLite database
 2. Create the equivalent schema in PostgreSQL
 3. Import the data
 4. Update all database connection code to use SQLAlchemy
    so it works with both SQLite locally and PostgreSQL in production
 5. Add a DATABASE_URL environment variable check —
    if set, use PostgreSQL; if not, fall back to SQLite"

Essential Tools & APIs

Claude

claude.ai – Your primary AI coding assistant

VS Code

code.visualstudio.com – Free, powerful IDE

Tailwind CSS

tailwindcss.com – Style your trading dashboards without writing raw CSS

Alpha Vantage

alphavantage.co – Free stock market data API

SQLite

sqlite.org – Store your trade history, watchlists, and signals locally — no server needed

Python

python.org – The language Claude uses to automate your trading workflows and data analysis

Learning Path

1. Start: Build a simple price fetcher for your watchlist
2. Progress: Add technical indicators and alerts
3. Advanced: Build a portfolio dashboard
4. Expert: Implement full trading strategy automation

Community Support

You're not alone! Join communities of traders and developers who are vibe coding:

• Reddit: r/algotrading, r/learnprogramming
• Discord: Various trading and coding communities
• GitHub: Open-source trading projects
• Twitter: Follow #vibecoding, #algotrading