Skip to main content
skill CX Codex

trader-budget — Claude Code skill: sizing and installation

trader-budget is a Claude Code skill that sizes positions from a budget and per-trade loss limit. It runs on share-count requests or after trader-exit writes a plan.

MIT ★ 9,067 updated 2026-10-20

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add Jakeschincariol/day-trader-skill
/plugin install day-trader-skill@day-trader-skill
Open on GitHub

What trader-budget does

trader-budget turns a trade plan with an entry, stop, and target into a whole-share position size. It compares four caps: maximum loss, position size, order value, and cash left after the buffer. The selected cap is reported, and --write creates one bracket order in trader/orders.json using Alpaca's stock-order shape.

The skill reads trader/config.json and trader/plan.json; fresh prices and portfolio cash can also come from trader/prices.json and trader/portfolio.json. The sizing script runs with python3. Nothing is sent to a broker. It refuses to write an order when the stop creates too much per-share risk, the plan is for another day, or another configured rule rejects the trade.

What it helps with

  • calculate whole-share size from per-trade risk
  • cap a position by budget and reserved cash
  • create a bracket order with entry, stop-loss, and take-profit
  • reject a trade whose stop exceeds the loss limit

Example prompts for the agent

  • Calculate the share count from trader/plan.json and write the proposal to trader/orders.json.
  • I have a $5,000 budget and want to risk $50 per trade. Set the rules and size the position.
  • After /trader-exit creates the plan, keep 10% in cash and prepare the bracket order.

How to install trader-budget

1Plugin marketplace

/plugin marketplace add Jakeschincariol/day-trader-skill
/plugin install day-trader-skill@day-trader-skill

This installs the whole day-trader-skill plugin with all its skills

2Skills CLI (Vercel)

npx skills add Jakeschincariol/day-trader-skill --skill trader-budget -a claude-code

3Manually: put the files in place

~/.claude/skills/trader-budget/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/trader-budget/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about trader-budget

How do I install trader-budget in Claude Code?

Add the marketplace with /plugin marketplace add Jakeschincariol/day-trader-skill, then install the plugin with /plugin install day-trader-skill@day-trader-skill.

What does trader-budget do?

It calculates whole shares from the entry, stop, target, budget, and loss limit. It writes a proposed bracket order to trader/orders.json but does not place it.

What does trader-budget need to run?

It needs python3, a rules file at trader/config.json, and a trade plan at trader/plan.json. trader-exit can write the plan; trader/prices.json and trader/portfolio.json supply optional price and cash inputs.

Source text

SKILL.md · MIT
---
name: trader-budget
description: >-
  Budget Manager. Sizes every position to your budget and your max loss per
  trade. Reads the trade plan from trader-exit (entry, stop, target), finds
  the whole shares that fit inside four limits (max loss per trade, position
  cap, max order, cash after your buffer), says which limit decided it, and
  writes ONE bracket order (entry, stop-loss, take-profit) to
  trader/orders.json in the exact shape of Alpaca's place_stock_order. A stop
  too far away for your max loss is a plain refusal, not a smaller order.
  Nothing is placed. Use when the user says "how many shares", "size this
  trade", "how much should I buy", "I have $5,000", "I only want to risk $50
  a trade", "set my rules", "keep 10% in cash", or after /trader-exit writes
  a plan.
argument-hint: "[budget in dollars]"
---

# trader-budget

The Budget Manager turns a plan ("buy TSLA at 364.18, stop 358.32") into an
exact order ("buy 8 shares"), inside rules the user sets once. The stop
decides the size: the further away the stop, the fewer shares. It writes a
proposal only. trader-risk checks it and trader-broker asks the user yes or
no. Day trading loses most people money. Sizing to a max loss keeps each
loss small; it does not make a trade win.

`${CLAUDE_SKILL_DIR}` below is this skill's folder (where this SKILL.md lives).

```bash
python3 "${CLAUDE_SKILL_DIR}/size.py"                        # trader/plan.json + trader/config.json
python3 "${CLAUDE_SKILL_DIR}/size.py" --write                # write trader/orders.json
python3 "${CLAUDE_SKILL_DIR}/size.py" --limit --write        # a limit order at the plan's entry
python3 "${CLAUDE_SKILL_DIR}/size.py" --limit 364.00 --json  # a limit order at 364.00
python3 "${CLAUDE_SKILL_DIR}/size.py" --weights AAPL=40,KO=60 --config split.json   # weights mode, below
```

`--now "2026-10-19 10:15"` pins the clock (New York time). A plan for
another day is refused: make a new one with trader-exit.

## What it reads and writes

| file | what |
| --- | --- |
| `trader/config.json` | the rules (start from `config.example.json` in this folder) |
| `trader/plan.json` | the trade: entry, stop, target, setup, flat-by time (trader-exit writes it) |
| `trader/prices.json` | optional: a fresh price above the plan's entry means a bigger risk (trader-alerts writes it) |
| `trader/portfolio.json` | optional: its cash caps the size (trader-broker keeps it) |
| `trader/orders.json` | the one proposed bracket order it writes with `--write` |

## Step 1: set the rules once

If `trader/config.json` does not exist, copy `config.example.json` into
`trader/config.json` and ask the user for each value in plain words:

- **budget**: how much money this is for. Only money they can afford to lose.
- **cash_buffer_pct**: how much always stays in cash (default 10).
- **max_loss_per_trade_usd**: the most one trade may lose if the stop fills at the stop (default 50).
- **max_position_pct**, **max_order_usd**, **min_order_usd**: the biggest position (75% of the
  budget), the biggest order ($4,000) and the smallest order ($5).
- The day limits trader-risk enforces: **max_daily_loss_usd** (150), **max_trades_per_day** (3),
  **min_reward_risk** (1.0), **require_stop** (true), **no_entries_before** / **no_entries_after**
  ("09:45" / "15:30") and **flat_by** ("15:55"), all New York time.
- **blocked**: tickers they never want to trade.
- Keep **paper** true until they have watched it work on a paper account.

## Step 2: size the trade

```bash
python3 "${CLAUDE_SKILL_DIR}/size.py" --write
```

Whole shares only: Alpaca takes no fractions in a bracket order. The size is
the smallest of four limits:

| limit | shares |
| --- | --- |
| max loss | `max_loss_per_trade_usd` / risk a share (entry minus stop) |
| position cap | budget x `max_position_pct` / entry |
| max order | `max_order_usd` / entry |
| cash | (budget minus the cash buffer) / entry, never more than the cash in `trader/portfolio.json` |

The entry it sizes at: the limit price with `--limit`. For a market order, the
plan's entry, or the price in `trader/prices.json` if it is fresh (under 15
minutes old) and higher. A price that ran up since the plan means a bigger
loss at the same stop, so fewer shares. A lower price never shrinks the risk.

It refuses, and writes no order, when: the size is zero shares, the order is
under the minimum, reward:risk is under `min_reward_risk`, the stop is not
below the entry, the target is not above it (the move already happened), the
plan is for another day, the ticker is blocked, or the plan is a short. Say
the reason to the user in one line.

## Step 3: show the user

Show the four limits, which one decided the size, the shares, the dollars
and the max loss at the stop. Say plainly that a stop is an order, not a
promise: in a fast market it can fill below the stop. Then hand over to
`/trader-risk`.

## Example: the reel

TSLA on Monday 2026-10-19. Opening-range breakout: entry 364.18 at 10:15 AM,
stop 358.32 (the opening-range midpoint), target 370.04 (1R). Risk 5.86 a
share. The example config: $5,000 budget, 10% cash buffer, $50 max loss.

| limit | the math | shares |
| --- | --- | --- |
| max loss | $50 / 5.86 | **8 (decides it)** |
| position cap | 75% of $5,000 = $3,750 / 364.18 | 10 |
| max order | $4,000 / 364.18 | 10 |
| cash | $5,000 minus $500 = $4,500 / 364.18 | 12 |

8 shares = $2,913.44. Max loss at the stop: 8 x 5.86 = $46.88. It writes:

```json
{"symbol": "TSLA", "side": "buy", "qty": "8", "type": "market", "time_in_force": "day",
 "order_class": "bracket", "take_profit_limit_price": "370.04", "stop_loss_stop_price": "358.32",
 "why": "opening-range breakout on TSLA: 8 shares, bound by your $50 max loss per trade (8 x 5.86 = $46.88 at the stop)",
 "plan": {"entry": 364.18, "stop": 358.32, "target": 370.04, "risk_per_share": 5.86, "max_loss": 46.88,
          "setup": "orb", "entry_time": "10:15 AM", "flat_by": "15:55"}}
```

`why` and `plan` are notes for trader-risk and trader-broker. They are never
sent to Alpaca. With the stop at 300.00 instead, one share would risk 64.18,
more than the $50 max loss: no order. At 10:52 the real quote was 366.48, so
the same plan sizes to 6 shares at 8.16 a share, and reward:risk falls to
0.44: refused, because the move it was waiting for has mostly happened.

## Weights mode (kept from v1)

`--weights AAPL=22.04,KO=10.86` or `--targets FILE` (`targets.example.json`
here) splits a budget across a list by weight: the cash buffer comes off the
top, weights are renormalised to 100, any stock over `max_position_pct` is
pinned at the cap and its excess shared out, slices under the minimum order
are dropped, and amounts round to whole dollars so nothing is left idle by
accident. With `"max_position_pct": 25` and `"fractional": true`, the example
file gives AAPL $1,250 (capped), AXP $1,119, GOOGL $823, KO $708, BAC $600.
With `"fractional": false` (the example config) it buys whole shares and
needs prices (`--prices trader/prices.json`). These are plain buys with no stop: trader-risk blocks them while
`require_stop` is true and counts each one against `max_trades_per_day`. Use
a separate config (`--config`) for a long-term split.

## Rules

- Proposals only. This skill never calls a broker tool.
- Never size money the user has not said is for this. Ask for the budget and the max loss.
- Every number comes from the config, the plan or the prices. Nothing is guessed.
- No projections: never say what a trade will make. A target is a plan, not a forecast.
- Free Yahoo prices are unofficial and can lag. The broker's price is the one that fills.

## What it never does

It never places, approves or schedules an order, never raises a limit on its
own, never shrinks a stop to fit more shares, and never sizes options,
margin or short positions.

## Safety

- Education and tooling, not financial advice. A PASS is a rules check, not a recommendation.
- Paper trading by default (`"paper": true`). Going live is the user's own decision, in their own config.
- Nothing in this pack places an order except trader-broker, and only when all three hold: trader-risk
  passed that exact order today, the user typed an explicit yes for that one order in the chat, and the
  user clicked Allow once on Claude's own card because the order tool is set to "Needs approval"
  (Customize > Connectors > tool permissions). Never set an order tool to "Always allow".
- No options, margin, short selling or leverage unless the config allows it and the user confirms.
- Broker keys live in environment variables or the Claude Desktop config, never in the chat.

© Jake Schincariol · MIT · Jakeschincariol/day-trader-skill

Similar skills

All skills for Finance and business →

From the same set12

The whole set →
trader-exit trader-exit is a Claude Code skill that sets stops and profit targets before entering long day trades. Triggers automatically after trader-entry or on prompts like "where's my stop". CX Codex +1 ★ 9,067repo stars trader-pelosi trader-pelosi is a Claude Code skill that monitors stock trades disclosed by members of US Congress. It checks House Clerk PTR index files and extracts transactions from filed PDFs. CX Codex +1 ★ 9,067repo stars trader-entry trader-entry is a Claude Code skill that watches market bars and names an entry after a close above a level. It starts from requests to watch a ticker or check a breakout. CX Codex +1 ★ 9,067repo stars trader-alerts trader-alerts is a Claude Code skill that tracks stock prices, stop levels, and NYSE session times. Triggers when checking quotes, watching stops, or right after generating a trade plan. CX Codex +1 ★ 9,067repo stars trader-risk trader-risk is a Claude Code skill that inspects proposed orders against risk limits before passing them to the broker. It blocks entries lacking stops or exceeding daily loss caps. CX Codex +1 ★ 9,067repo stars trader-timemachine trader-timemachine is a Claude Code skill that replays a trade against 5-minute stock bars and prior setups. It runs before position sizing. CX Codex +1 ★ 9,067repo stars trader-scanner trader-scanner is a Claude Code skill that scans US stock charts for setups before the bell and intraday. It writes matched candidates to trader/watchlist.json. CX Codex +1 ★ 9,067repo stars trader-broker trader-broker is a Claude Code skill that sends approved orders to a broker after two user confirmations. It activates for buy, sell, and position-close requests. CX Codex +1 ★ 9,067repo stars

Project sponsors

Companies that keep this analytics open