Welcome & The Vibe-Coding Mindset
Understanding the paradigm shift that transforms how you build trading tools
Session Overview
20 minutes
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:
Auto-Pull Stock Data
Fetch daily prices and sentiment for your watchlist. Stop manual copy-pasting data every morning.
Portfolio Rebalancer
Auto-calculate trade signals for rebalancing. Maintain your target allocation without spreadsheets.
Earnings Alert Bot
Get notified when watchlist companies announce earnings. Never miss a date or market reaction.
Simple Backtester
Test strategies against historical data. Validate ideas before risking real money.
Dashboard
Custom dashboard showing all your metrics. Combine prices, indicators, news, and portfolio data.
AI Consensus
Aggregate opinions from multiple AI sources. Get consensus views on stock picks and market direction.
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.
Key Takeaways
- Vibe coding = plain English + AI = working tools
- 10× faster, no dev costs, no waiting
- You = product owner, Claude = junior dev
- Six applications: data fetcher, rebalancer, alerts, backtester, dashboard, AI consensus
- Your job: communicate logic clearly. Claude's job: implement it
Claude's 3-Stage Power System
Mastering Chat, Cowork, and Code modes for maximum productivity
Session Overview
45 minutes
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:
- Chat: "What's the best way to create a trading journal?" (Research and ideas)
- Cowork: "Help me build a simple journal that tracks trades and calculates P&L" (Iterative building)
- Code: "Create a full trading journal system with charts, reports, and cloud backup" (Complete system)
Key Takeaways
- Stage 1 (Chat): Quick questions, explanations, brainstorming
- Stage 2 (Cowork): Step-by-step building with memory
- Stage 3 (Code): Full system planning and development
- Start low, escalate up as needed
- Progressive escalation is most effective workflow
Basic Programming Concepts
You only need 5% of this to vibe code effectively
Session Overview
30 minutes
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.
Key Takeaways
- Variables = labeled data storage
- Loops = repeat actions across multiple items
- Functions = reusable tools/calculators
- If-statements = conditional actions (your trading logic)
- Data → Logic → Output (the universal pattern)
- Understand enough to communicate, not enough to code from scratch
Automation Superpowers
Hands-on building your first automations
Session Overview
50 minutes
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.
RSI Alert
Notify when RSI drops below 30 (oversold) or above 70 (overbought). Catch potential reversals early.
MACD Crossover
Alert when MACD line crosses signal line. Reliable momentum indicator for timing entries and exits.
Volume Spike
Detect unusual trading volume – potential news or breakout. Sudden volume changes precede price movements.
MA Crossover
Golden cross and death cross alerts. Classic trend-following signals across all timeframes.
Price Change Alert
Notify when stock moves by percentage. Catch breakouts and crashes as they happen.
Earnings Reminder
Never miss earnings. Get alerts before earnings and after results release.
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:
- Start small: Pick one simple task (e.g., checking price of one stock)
- Describe to Claude: "I want to get an alert when AAPL is above $200"
- Test it: Run automation and verify it works
- Iterate: "Now do the same for my whole watchlist"
- Expand: Add more conditions, stocks, complexity as you get comfortable
Key Takeaways
- Free APIs provide all data you need (Alpha Vantage, Yahoo Finance, FMP, EOD, Massive)
- Automate RSI, MACD, volume alerts, MA crossovers easily
- Transform broker CSVs into actionable insights with real-time updates
- Claude can summarize news at scale and provide sentiment analysis
- Integrate with trading journal platforms (Trade Metria, TraderSync, TradeZella)
- Start small, iterate, expand – don't try to automate everything at once
Big-Picture Architecture
How real apps are built – in trader terms
Session Overview
30 minutes
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.
Front-end
What you see – The dashboard, charts, buttons, and interface. What users interact with directly.
Back-end
The brain – Servers, calculations, data processing, business logic. Does the heavy lifting.
Database
Storage – Your watchlist, trade history, settings. Persistent storage for everything.
API Endpoints
Connectors – "Give me AAPL price", "Save this trade", API calls that connect everything.
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:
Yahoo Finance, Alpha Vantage] BE -->|Send Alert| NOTIF[Email/SMS Alerts] DB -->|Save Trades| FE EXT -->|Market Data| BE
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
Key Takeaways
- Front-end = what you see (dashboard, interface)
- Back-end = the brain (calculations, logic, processing)
- Database = storage (watchlist, history, settings)
- API endpoints = connectors between components
- Claude can generate entire stack – you describe, Claude builds
Working with IDEs
VS Code, Cursor, and Antigravity – when to use which
Session Overview
30 minutes
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
- Download: Get VS Code from code.visualstudio.com
- Install Claude extension: Search for Claude in Extensions marketplace
- Sign in: Connect your Claude account
- Create your first project: File → Open Folder
- 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
Key Takeaways
- VS Code: Free, popular, great Claude integration
- Cursor: AI-first version of VS Code, optimized for AI
- Antigravity: Google's agent-first IDE, experimental
- Start with VS Code, try Cursor if you want more AI
- IDE provides organization, debugging, and AI integration
Claude Alternatives
Comparison table and when to switch
Session Overview
15 minutes
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
| AI Assistant | Speed | Cost | Strengths | Best For |
|---|---|---|---|---|
| Claude | Fast | Free tier available, reasonable pricing | Excellent code quality, strong reasoning, great for trading logic | Overall vibe coding, complex projects |
| CodeX (OpenAI) | Fast | Pay-as-you-go | Strong code generation, multi-language support | Quick code generation, debugging |
| Z.AI | Very Fast | Competitive | Speed, specialized coding tasks | Rapid prototyping, quick tasks |
| Kimi | Fast | Competitive | Good at context-heavy tasks, Chinese support | Large codebases, international users |
| Alibaba CodePlan | Fast | Enterprise pricing | Enterprise features, governance, compliance | Enterprise projects, large teams |
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
Key Takeaways
- Claude: Best overall for vibe coding and complex trading logic
- CodeX: Strong code generation, good for quick tasks
- Z.AI: Very fast, good for simple tasks
- Kimi: Good for large codebases and international users
- Alibaba CodePlan: Enterprise features, large teams
- Start with Claude, explore others based on specific needs
Wrap-Up & Next Steps
Limitations, resources, and your next projects
Session Overview
20 minutes
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
Safety First
Always test automations with small amounts first. Never trust AI blindly with your capital.
Test Thoroughly
Backtest strategies thoroughly. Validate automations with paper trading before going live.
Review Everything
Always review AI-generated code. Understand what it does before running it.
Best Next 3 Projects for Traders
Ready to start building? Here are three beginner-friendly projects to get you started:
Project 1: Watchlist Price Fetcher
Difficulty: Beginner
- Fetch daily closing prices for your watchlist
- Store prices in a simple database or spreadsheet
- Send daily email summary
- Skills: API calls, data storage, email automation
Project 2: RSI Alert Bot
Difficulty: Intermediate
- Calculate RSI for watchlist stocks
- Send alerts when RSI is below 30 or above 70
- Add volume spike detection
- Skills: Technical indicators, automation, alerts
Project 3: Simple Portfolio Dashboard
Difficulty: Intermediate
- Build a web dashboard showing your portfolio
- Display real-time prices and P&L
- Show sector allocation breakdown
- Skills: Front-end, back-end, real-time data
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:
Hallucinations
AI can confidently state things that aren't true. Always verify facts and code.
Context Limits
Large codebases may exceed context limits. Break projects into smaller pieces.
Bugs
Generated code may have bugs. Test thoroughly and debug systematically.
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. 📉🚀
Key Takeaways
- Never paste real API keys – use test environments
- Always test thoroughly before going live with real money
- Review AI-generated code before running it
- Start with simple projects: price fetcher, RSI bot, dashboard
- Use free APIs: Alpha Vantage, Yahoo Finance, CoinGecko
- Join communities: Reddit, Discord, GitHub for support
Claude Code – The Full Power
Go beyond the chat window. Run Claude as an agent directly in your terminal and IDE.
Session Overview
Self-paced
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:
Read Your Entire Project
Understands all your files — trading scripts, data pipelines, config — not just what you paste in.
Run Commands
Executes terminal commands, runs your backtests, installs packages, commits code to git.
Verify Its Own Work
Runs tests after making changes, checks output, and fixes mistakes — without you stepping in.
Remember Between Sessions
Auto memory stores what it learns about your project. Next session it picks up where it left off.
How Claude Code Works (The Loop)
Every task runs through the same four-step cycle:
- Gather context: Claude reads your files and searches for relevant code
- Take action: Makes file edits, runs commands, calls external services
- Verify results: Runs tests, checks output, compares with expected results
- 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:
| File/Folder | What It Does |
|---|---|
CLAUDE.md | Your standing instructions — Claude reads this every session. Put your coding rules, trading conventions, and build commands here. |
CLAUDE.local.md | Your personal notes (not shared with teammates). |
.claude/settings.json | Project configuration — permission modes, allowed commands. |
.claude/skills/ | Custom workflows you can trigger with /skill-name (e.g. /backtest, /deploy). |
~/.claude/projects/ | Auto memory — Claude's notes from past sessions about your project patterns. |
Store Instructions & Memories
Two memory systems work together:
- CLAUDE.md (your rules): Write once, Claude follows every session. Example:
# 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:
| Mode | What Claude Does Without Asking | Best For |
|---|---|---|
| Default | Read files only | Getting started, reviewing code |
| Accept Edits | Read and edit files freely | Active development you're watching |
| Plan Mode | Reads files, shows a plan, waits for your approval | Major strategy changes — review before any edit |
| Auto | All actions with background safety checks | Long tasks, reducing interruptions |
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
/clearbetween 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
Understand Existing Code
"give me an overview of this project" "explain how the data pipeline works" "where is RSI calculated?"
Fix a Bug
"my price fetcher returns NaN for TSLA" "find and fix the issue, then run tests"
Add a Feature
"add MACD calculation to my indicator module" "send an email alert when RSI crosses 30"
Commit & PR
"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-namecommand. Example:/analyze-backtestthat 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
Rules That Actually Matter
- Give Claude something to verify against. Include expected output or test cases — Claude checks its own work.
- Explore first, then code. Start in Plan Mode to understand, then switch to normal mode to implement.
- Be specific upfront. Name the file: "@src/indicators.py — add MACD here"
- Use /clear between tasks. Starting a fresh context prevents confusion from earlier conversation.
- Write a good CLAUDE.md. Include your build commands, test runner, and trading conventions. Claude can't guess these.
- Never paste real API keys. Even in Claude Code — use environment variables and .env files.
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
- Install Claude Code: VS Code extension or
curl -fsSL https://claude.ai/install.sh | bashfor terminal - Open your trading project folder in VS Code
- Run
/init— Claude scans your project and generates a starter CLAUDE.md - Edit CLAUDE.md — add your trading conventions and build commands
- Start your first task: "explain what this script does" or "help me debug this data fetcher"
Essential Commands
| Command | What It Does |
|---|---|
/init | Generate a starter CLAUDE.md for your project |
/clear | Start a fresh conversation (keeps memory) |
/memory | View your instructions and auto-learned knowledge |
/rewind | Undo back to a previous state |
/resume | Continue a previous conversation |
@filename | Include a specific file in your message |
| Shift+Tab | Cycle through permission modes |
Key Takeaways
- Claude Code runs inside your project — reads all files, not just what you paste
- CLAUDE.md = your standing instructions. Keep it under 200 lines.
- Use Plan Mode before any major trading logic change
- /clear between unrelated tasks keeps context clean and responses sharp
- VS Code integration gives you inline diffs — review changes visually before accepting
- Skills and MCP let you connect Claude to your real data sources and workflows
- Full docs: code.claude.com/docs
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.
GitHub Search
Search GitHub for path:.claude/skills or filename:*.md path:.claude to find public projects that have shared their skills. Many open-source Claude Code projects include skill libraries.
Community Repos
The Claude Code community shares skill templates on Reddit (r/ClaudeAI), Discord, and dedicated GitHub repos like awesome-claude-code. Search for trading-specific skill collections.
Official Docs
code.claude.com/docs includes example skills. The skills section shows the full schema and advanced features like conditional loading and file imports.
Ask Claude to Generate
Describe any repetitive workflow to Claude and ask it to "create a skill for this." Claude generates the markdown file, places it in .claude/skills/, and explains how to invoke it.
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.
Skills Summary
- Skills = reusable workflows in
.claude/skills/your-skill.md - Invoke with
/skill-name— Claude loads and executes the workflow - Build skills from workflows you repeat manually — let Claude write the skill file
- Skills load on-demand, don't bloat your context window
- Can reference supporting files with
@path/to/filesyntax - Share with teammates by committing
.claude/skills/to your repo
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:
algorithmic-trading
Backtesting engines, signal generators, strategy libraries. Many are plug-and-play with yfinance data.
stock-market
Price trackers, screeners, watchlist tools. Great for finding dashboard templates to customise.
backtesting
Backtrader, Zipline, VectorBT — full backtesting frameworks you can clone and run your own strategies against.
sentiment-analysis
News scrapers and sentiment classifiers for finance. Feed your trading decisions with AI-labelled sentiment scores.
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" tradingor"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 tradingor#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"
GitHub + Claude Code Summary
- Search GitHub topics:
algorithmic-trading,backtesting,stock-market - Clone any repo → open Claude Code → "explain this project" → customise
- Claude reads and modifies code it didn't write — existing repos are fair game
- Claude handles all git commands — branches, commits, PRs — in plain English
- Find Claude-built tools on r/ClaudeAI, Twitter #vibecoding, Hugging Face Spaces
- 80% of what you need probably already exists — find it, clone it, customise the last 20%
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 | Best For | Free Tier? | Difficulty | Notes |
|---|---|---|---|---|
| Render | Web dashboards, APIs, background workers | Yes (sleeps after 15 min idle) | Easy | Best all-rounder for traders. Connects to GitHub — push code, it auto-deploys. |
| Railway | Full-stack apps, databases, scheduled jobs | Yes ($5 credit/month) | Easy | Great when you need both a web server AND a database in one place. Very fast setup. |
| Cloudflare Pages | Static websites, this course site | Yes (generous) | Very Easy | Perfect for HTML/JS dashboards with no back-end. Blazing fast CDN. Not for Python. |
| Cloudflare Workers | Lightweight APIs, webhooks, data transformers | Yes (100k requests/day) | Medium | Runs JavaScript/Python at the edge. Great for price alert webhooks. No persistent storage. |
| PythonAnywhere | Python scripts, scheduled tasks, simple web apps | Yes (limited) | Easy | Beginner-friendly. Built-in scheduler (cron) — perfect for daily price fetchers. But slow. |
Platform Deep-Dives
Render — Recommended Starting Point
What it is: A cloud platform that runs your Python web apps and background scripts. Think of it as a laptop in the cloud that never sleeps (on paid plans).
Trader use cases:
- Your Flask/FastAPI portfolio dashboard — accessible from any device, 24/7
- A background worker that fetches prices every hour and sends alerts
- A REST API that your trading journal can call to get indicator data
How to deploy:
- Push your project to GitHub
- Go to render.com → New → Web Service
- Connect your GitHub repo
- Set build command:
pip install -r requirements.txt - Set start command:
python app.pyorgunicorn app:app - Add environment variables (API keys, database URLs) in the dashboard
- Click Deploy — every git push auto-deploys from now on
# 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."
Railway — Best for Full-Stack Apps
What it is: Similar to Render but with tighter database integration. You can deploy your app and a PostgreSQL database side-by-side in the same project.
Trader use cases:
- A trading journal web app with its own database — all hosted together
- A price history service that stores data in PostgreSQL and serves charts
- Scheduled jobs: Railway has built-in cron scheduling without extra config
Standout feature: Railway's environments — you can have a staging environment (for testing) and a production environment (live) wired to the same GitHub repo. Push to main → goes live. Push to staging → goes to test server.
# 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."
PythonAnywhere — The Beginner's Server
What it is: A Python-specific cloud platform with a browser-based terminal. No CLI or git knowledge required to get started — you can upload files directly.
Trader use cases:
- A daily price fetcher that runs at 6am every morning via cron
- A simple Flask app serving your watchlist as a web page
- Learning to deploy for the first time — the UI is forgiving
Limitation: The free tier only makes outbound HTTP requests to a whitelist of sites (Yahoo Finance is on it; some brokers aren't). Paid plans ($5/month) remove this.
# 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.
1. Create a Repo
Go to github.com → New repository. Give it a name, set it private (for trading tools with API keys), click Create.
"Push this project to a new private GitHub repo called trading-dashboard"
2. Push Changes
After editing code, push to GitHub — the platform auto-deploys.
"Commit all my changes and push to GitHub"
3. Protect API Keys
Never commit API keys. Use a .env file locally and environment variables on the platform.
"Add a .gitignore that excludes .env and any CSV files with trading data"
4. Roll Back
If a deployment breaks something, roll back to any previous version in seconds.
"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:
SQL (Relational)
Data lives in structured tables with rows and columns — like a spreadsheet, but queryable. You query it with SQL: SELECT * FROM trades WHERE ticker = 'AAPL'.
Examples: SQLite, PostgreSQL, MySQL, Neon
Best for: Trade history, portfolio snapshots, price series, anything that has structure and you'll query by date or ticker.
NoSQL (Document / Key-Value)
Data lives as flexible JSON-like documents or key-value pairs. No fixed schema — each record can have different fields.
Examples: MongoDB, Redis, Firestore
Best for: News articles, unstructured sentiment data, user preferences, caching API responses. Less common for trading core data.
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.
# 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
# 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
Neon (neon.tech)
What it is: A serverless PostgreSQL database. You get a full PostgreSQL database hosted in the cloud with a generous free tier — no server to manage, no billing headaches at small scale.
Why Neon is exciting for traders:
- Serverless: The database scales to zero when you're not using it (free tier friendly) and wakes up instantly when you query it
- Branching: Like git branches but for your database. Create a "branch" of your production database to test new features without touching live data — then merge when ready
- Free tier: 0.5GB storage, unlimited requests — enough for years of daily price data for a personal watchlist
- Works everywhere: Connect from Render, Railway, PythonAnywhere, or your local machine using a standard PostgreSQL URL
Getting started:
- Sign up at neon.tech (free, no credit card)
- Create a project → copy the connection string
- Paste into your deployment platform as
DATABASE_URLenvironment variable - Done — your app now has a persistent cloud database
# 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?
| Situation | Recommended Database | Why |
|---|---|---|
| Local script, no deployment | SQLite | Zero setup, works immediately, data in one file |
| Learning / prototyping | SQLite | No accounts, no billing, instant start |
| Deployed to PythonAnywhere | SQLite | Simple, persistent disk storage on paid plans |
| Deployed to Render / Railway (free tier) | Neon | Free tiers restart servers; Neon keeps data safe externally |
| Production dashboard, multiple users | PostgreSQL (Railway / Render) | Managed, reliable, scales, same platform billing |
| Want free cloud PostgreSQL forever | Neon | Generous free tier, branching, serverless scaling |
| Caching real-time prices (sub-second) | Redis | In-memory key-value store, extremely fast reads |
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"
Deployment + Database Summary
- PythonAnywhere: Easiest start. Browser-based, built-in cron, good for daily scripts
- Render: Best all-rounder for web dashboards. GitHub push = auto-deploy
- Railway: Best when you need app + database together. Built-in cron scheduling
- Cloudflare Pages: For static sites only (like this course site). Not for Python backends
- SQLite: Start here. Zero setup, data in a file. Perfect for local tools
- Neon: Free cloud PostgreSQL. Use when deploying to Render/Railway to avoid data loss on restarts
- PostgreSQL: The upgrade path. Handles scale, multiple users, production loads
- Claude handles all git, deployment config, and database migration — just describe what you want
Additional Resources
Everything you need to continue your vibe coding journey
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
- Start: Build a simple price fetcher for your watchlist
- Progress: Add technical indicators and alerts
- Advanced: Build a portfolio dashboard
- 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