golongshort
Claudeで本物のプロダクトを、公開で作る。購読
golongshortへ戻る

Claudeで構築

Claudeで株式トレーディングAIを作る旅 — この3ヶ月の記録

バックテスト12回、リサーチ約30回、そして今も進化を続けるシステム。Claudeと一緒に、システマティックなトレーディングマシンを作り — そして正直にストレステストにかけた — この3ヶ月の記録。

物語の前に、まず成績表を。 この3ヶ月、Claudeと一緒にシステマティックなトレーディングマシンを作った — そしてその時間のほとんどは、それが機能しないことを証明しようとするのに費やした。正直に測って生き残ったのはこれだ。18年間のバックテストを通しても、S&Pのトータルリターンには勝てない。ただし**シャープはより高く（0.61 vs 0.53）、ドローダウンは3分の1（-20% vs -55%）**で回ってきた — しかも2008年、S&Pが37%下げたあいだ、このシステムはほとんど動かなかった。

システム vs S&P 500 — $10,000の成長とドローダウン、2008〜2026年

グレー（S&P）のほうが最後は上に来る — こっちのほうが儲かるからだ。レッド（システム）は、そのリターンの一部を差し出す代わりに、はるかに出血が少ない。ドローダウンは3分の1、そして市場が半値になった2008年でもかすり傷ひとつだ。このトレードオフ — 秘密のエッジではなく — が、設計そのものだ。（これは分散版ブックの18年バックテストで、僕が実際に回しているバージョンは、18年ぶんの記録を持つには若すぎるマネージドフューチャーズETFを国債の代わりに使っている。）

僕が作ったもの。 市場に勝つボットではない。正直に回したテストは、どれも「ソロにそんなものは無い」と言ってきたからだ。代わりに作ったのは、自分が何者なのかについて正直な分散システム。そしてきれいなバックテストに絶対だまされないためのツール。今この瞬間もペーパーで動いていて、クラウドで勝手にリバランスしている。

僕はクオンツじゃない。ファンドで金を運用した経験もない。みんな一つは持ってると言い張る、あの「市場に勝つ機械」が僕も欲しかった。だからClaudeに一緒に作ろうと頼んで、そのあと — ここが肝心なんだけど — それを正直に検証するところまで一緒にやってくれと頼んだ。この記事は結局、その検証の話だ。

📋 この記事はそれ自体で完全なビルドキットだ。 以下にファイルもコマンドも全部ある。5つのファイルをコピーしてコマンドを叩けば、まったく同じシステムがそのまま手に入る。戦略、正直性チェック、ペーパートレードのループ、そして常時オンのクラウドデプロイまで。あるいはこの記事をまるごとClaude Codeに貼り付けて、*「これを作ってlavelaにデプロイして」*と言うだけでもいい。

「市場に勝った」系のコンテンツは、たいていスクショ1枚と講座の決済リンクで終わりだ。この記事はその逆をやる。なぜ難しいのかの領収書と、君に嘘をつかないシステム。証明するコードまで付けて。

目次

1. 墓場 — 何をテストして、それぞれなぜ死んだか

最初から12回コケてやろうと思って始めたわけじゃない。正直に測るまでは、どれもうまくいきそうに見えた。その落差 — うまくいきそう vs 実際に正直 — が、この記事の教訓の全部だ。

始まりは、自分で作った一つのボットだった。 レシピは教科書どおりのMLクオンツだ。S&P 500を取ってきて、各銘柄について約20個のファンダメンタル指標とテクニカル指標を計算する — バリュエーション（PER、PBR、EV/EBITDA）、収益性（ROE、マージン）、成長性、クオリティ（Piotroskiスコア、アクルーアル）、そしてモメンタム。勾配ブースティングのモデル（LightGBM）を学習させて、各銘柄の63日先のリターンを予測する。あとは四半期ごとに、スコア上位の銘柄をロングして、ボラティリティに反比例させてウェイトを付け、ブック全体を10%のボラティリティ目標にスケールする。

python
# the first bot I built — the one that turned out to be wrong
import lightgbm as lgb

FEATURES = ["pe_trailing", "pb", "ev_ebitda", "roe", "net_margin",
            "revenue_growth", "piotroski_score", "sloan_accruals",
            "momentum_score", "beta", "vix", "yield_spread"]   # ~20 in all

def rank_stocks(panel):                 # panel: S&P 500, one row per stock
    model = lgb.LGBMRegressor(n_estimators=300, learning_rate=0.05, num_leaves=31)
    model.fit(panel[FEATURES], panel["fwd_ret_63d"])   # target: 63-day forward return
    panel["score"] = model.predict(panel[FEATURES])
    return panel.nlargest(20, "score")                 # long the top 20, inverse-vol weighted

ウォークフォワードで学習させて、ハイパーパラメータのバリアントを何十通りもスイープしたら、一番いいやつがヘッドラインでシャープ0.60のバックテストを叩き出した。舞い上がった。そこでClaudeにそれを監査してくれと頼んだ — 敵対的なパスを4本同時に走らせて — すると、その0.60が三方向から同時に崩れ落ちた。

次に、みんなが盲信してるやつを片っ端からテストした。 実コストを入れて、ルックアヘッドなしで、公平なベンチマークで。

テストしたもの 正直な結果
大型株ファクタースクリーニング（バリュー/クオリティ/モメンタム） SPYに勝てない
インサイダーのクラスター買い（SEC Form 4） 損失 — 小型株指数より悪い
トレンドフォロー（マネージドフューチャーズ） 分散にはなるが、市場には勝てない
小型株クオリティ・バリュー（ポイントインタイムのSECデータ） 書類上はSPYに勝った — でもファクターのおかげじゃなく、生存者バイアス＋サイズベータのおかげ
ボラティリティ・プレミアム（プット売り） プレミアムは本物、それでもSPYに負ける
マーケットニュートラル・ロング/ショート 爆発（−14%/年） — 反発局面のたびにショートがスクイーズ

マーケットニュートラルは、本物の勝者たち（ルネサンスのメダリオン）が使っているまさにそのメカニズムだ。ところがリテール規模でやると、ただ吹き飛ぶ。叩き売られた小型株をショートすると、2020年や2023年の反発でそいつらがロケットのように跳ね、君の「ニュートラル」なブックはもうニュートラルじゃなくなる。メダリオンがそれに耐えられるのは、何千もの銘柄を、安い貸株コストとピコ秒の執行でショートしているからだ。メカニズムは公開されている。ロックされているのは、それを実際に回す機械のほうだ。

いちばん学んだ瞬間はこれだ。 相関の低い戦略をいくつか組み合わせたら、シャープ0.81が出た。ついに市場に勝つ何か、だと思った。そこで正直にストレステストをかけた。毎日じゃなく毎月リバランス、実際の取引・貸株コストを入れて。すると0.81は0.56まで蒸発した。退屈きわまる60/40の下だ。要は、毎日タダでリバランスしていたから生まれた幻だった。

結局ゲームの本質はここだ。「アイデアがあるか」じゃない — アイデアはみんな持ってる — **「そのアイデアが正直な測定で生き残るか」**であって、答えはほとんど毎回「ノー」だ。

2. 唯一大事なツール — 自分を騙さない方法

この記事から一つだけ持ち帰るなら、これにしてほしい。ソロが作れるもので一番レバレッジが効くのは、シグナルじゃない。あるシグナルが偽物だと教えてくれる統計だ。

核心はこの事実だ（Bailey & López de Prado）。5年分のデータで戦略を約45個回せば、インサンプルのシャープは1.0なのに本当のアウトオブサンプルのシャープはゼロ、という戦略をほぼ確実に一つは拾ってしまう。 試行が増えるほど、「勝者」が越えなきゃいけない基準線も上がっていく。**Deflated Sharpe Ratio（デフレーテッド・シャープ）**は、その基準線を目に見える形にしてくれる。ボットの偽の0.60も、僕の偽の0.81も捕まえたのがこいつだ。そして下のキットで、君が最初に作るファイルでもある。

3. 全部作る — 5ファイル、コピペ、実行

システム全体がここに全部ある。5ファイル、フレームワークなし、合計で約200行。Pythonが動くマシンならどこでも回る。

セットアップ

bash
mkdir honest-trader && cd honest-trader
python -m venv .venv && source .venv/bin/activate
pip install yfinance pandas numpy scipy

ファイル1 — strategy.py（戦略まるごと）

流動性の高いETF4本 — 米国株、金、コモディティ、マネージドフューチャーズ（トレンド）ファンド — で組むリスクパリティ。各資産を自分のボラティリティに反比例させて配分して、4本がだいたい同じだけリスクを負うようにする。MLなし、アルファシグナルなし、レバレッジなし。

python
# strategy.py
import numpy as np, pandas as pd

ETFS = ["SPY", "GLD", "DBC", "DBMF"]   # equity / gold / commodities / trend
PPY, VOL_LOOKBACK = 252, 60

def get_prices(period="8mo") -> pd.DataFrame:
    import yfinance as yf
    px = yf.download(ETFS, period=period, auto_adjust=True, progress=False)["Close"]
    return px[ETFS].ffill().dropna()

def target_weights(prices: pd.DataFrame) -> pd.Series:
    """Risk-parity: weight each asset inversely to its trailing 60-day volatility."""
    vol = prices.pct_change().iloc[-VOL_LOOKBACK:].std() * np.sqrt(PPY)
    inv = 1.0 / vol
    return inv / inv.sum()

ファイル2 — honesty.py（自己欺瞞を防ぐ数学 — 一番大事なファイル）

Deflated Sharpe Ratioと、多重検定のヘアカット（減衰）。どんなバックテスト結果でも、試したバリアントの数と一緒にここを通してやると、「すごい」戦略たちが95%の基準線でぼろぼろ落ちる。自分の結果を通してみたら、ほとんどが落ちた。それがこのツールがちゃんと働いてる証拠だ。

python
# honesty.py
import numpy as np
from scipy.stats import norm

_EULER = 0.5772156649015329

def expected_max_sharpe(sr_std, n_trials):
    """Expected best Sharpe of N skill-less strategies (False Strategy Theorem).
    The more you try, the higher a lucky-best Sharpe will be by pure chance."""
    if n_trials < 2 or sr_std <= 0:
        return 0.0
    g = _EULER
    return float(sr_std * ((1 - g) * norm.ppf(1 - 1/n_trials)
                           + g * norm.ppf(1 - 1/(n_trials * np.e))))

def deflated_sharpe_ratio(sr, T, skew, kurt, trial_sharpes):
    """P(the selected strategy's Sharpe is real) given how many you tried.
    < 0.95  →  not distinguishable from the luckiest of your N random trials.
    sr/skew/kurt are per-period (daily); kurt is full (normal = 3)."""
    trials = np.asarray(list(trial_sharpes), float)
    sr0 = expected_max_sharpe(trials.std(ddof=1), len(trials))     # the deflated bar
    denom = np.sqrt(1 - skew*sr + ((kurt - 1)/4)*sr**2)
    z = (sr - sr0) * np.sqrt(T - 1) / denom
    return float(norm.cdf(z)), sr0

def haircut_sharpe(sr_annual, T_days, n_trials, ppy=252):
    """Bonferroni multiple-testing haircut → the Sharpe implied after correcting
    for how many strategies you tried. Often collapses toward 0."""
    years = T_days / ppy
    t = sr_annual * np.sqrt(years)
    p_single = 2 * (1 - norm.cdf(abs(t)))
    p_adj = min(p_single * n_trials, 1.0)                          # Bonferroni
    hsr = norm.ppf(1 - p_adj/2) / np.sqrt(years)
    return float(hsr)

ファイル3 — backtest.py（証明して、リバランスのルールを見つける）

このファイルは正直なことを2つやる。(1) リスクパリティのブックを、実コストまで入れてバックテストする。(2) どのくらいの頻度でリバランスすべきかを、カレンダー方式 vs ドリフト閾値方式でスイープして答えを出す。しかも最大値だけつまみ食いせず、全部を報告する。ASSETSを長期ヒストリーのセットに向ければ、18年ぶんのロバスト性が目で見える。

python
# backtest.py
import numpy as np, pandas as pd
from honesty import deflated_sharpe_ratio

RF, PPY, COST_BPS = 0.02, 252, 5.0
ASSETS = ["SPY", "TLT", "GLD", "DBC"]   # long-history set (2008→) for robustness

def load(start="2007-01-01"):
    import yfinance as yf
    px = yf.download(ASSETS, start=start, auto_adjust=True, progress=False)["Close"].ffill().dropna()
    rets = px.pct_change().dropna()
    vol = rets.rolling(60).std().shift(1) * np.sqrt(PPY)
    return rets, vol

def run(rets, vol, policy, param):
    """policy='calendar' (param=days) or 'threshold' (param=max weight drift)."""
    w, out, turn_sum, n_reb = None, [], 0.0, 0
    for i, d in enumerate(rets.index):
        if vol.loc[d].isna().any():
            out.append(0.0); continue
        target = (1/vol.loc[d]) / (1/vol.loc[d]).sum()
        do = (w is None) or ((i % param == 0) if policy == "calendar"
                             else float((w - target).abs().max()) > param)
        cost = 0.0
        if do:
            if w is not None:
                t = float((target - w).abs().sum()); turn_sum += t; cost = t*COST_BPS/1e4
            w = target; n_reb += 1
        out.append(float((w * rets.loc[d]).sum()) - cost)
        g = w * (1 + rets.loc[d]); w = g / g.sum()                 # drift between rebalances
    s = pd.Series(out, index=rets.index).loc[vol.notna().all(axis=1)]
    nav = (1 + s).cumprod(); r = s.to_numpy(); yrs = len(s)/PPY
    return dict(cagr=nav.iloc[-1]**(1/yrs)-1, sharpe=(r.mean()-RF/PPY)/r.std(ddof=1)*np.sqrt(PPY),
                maxdd=((nav/nav.cummax())-1).min(), reb_yr=n_reb/yrs)

if __name__ == "__main__":
    rets, vol = load()
    print(f"{'policy':22s}{'CAGR':>7s}{'Sharpe':>8s}{'MaxDD':>8s}{'reb/yr':>8s}")
    for name, pol, par in [("calendar daily","calendar",1), ("calendar monthly","calendar",21),
                           ("calendar quarterly","calendar",63), ("threshold 5%","threshold",0.05),
                           ("threshold 10%","threshold",0.10)]:
        m = run(rets, vol, pol, par)
        print(f"{name:22s}{m['cagr']*100:>6.1f}%{m['sharpe']:>8.2f}{m['maxdd']*100:>7.1f}%{m['reb_yr']:>7.0f}")

実行:

bash
python backtest.py
text
policy                  CAGR  Sharpe   MaxDD  reb/yr
calendar daily          7.3%    0.59  -20.2%    252
calendar monthly        7.6%    0.62  -20.2%     12
calendar quarterly      7.5%    0.60  -19.7%      4
threshold 5%            7.5%    0.61  -19.9%      7
threshold 10%           7.8%    0.63  -18.9%      2

ここから教訓が2つ落ちてくる。一つ、取引が少ないほど勝つ。 毎日が最悪だ — 何の得もないのにコストだけ払う。むしろ一番めったに取引しないポリシーたちが上に来る。二つ、全体がロバストだ。どのポリシーでもシャープは0.59〜0.63の間。つまり、運のいい特定の頻度にこっそり乗っかってるわけじゃない。スイートスポットはこうだ。毎日チェックはするけど、どれかのウェイトが5%以上ずれたときだけ取引する。 取引回数は半分（年に7回くらい）なのに、月次レベルのシャープが出る。「毎日見張れ」って直感は正しい。「毎日取引しろ」って直感が間違ってるんだ。

ファイル4 — paper_sim.py（フォワード検証 — 実際の価格、仮想のお金）

バックテストはもう出がらしだ（おまけに2回は偽物だった）。ここから先、正直な新情報は*フォワード（forward）*に積み上がるデータだけ。このファイルは実際の価格で仮想の$100kを追跡して、5%閾値でリバランスして、回すたびにログを残す。毎日回せ。ほとんどの日はただ眺めてるだけで、たまに何かが5%を超えてずれた日だけリバランスする。

python
# paper_sim.py
import json, argparse
from datetime import datetime, timezone
from pathlib import Path
from strategy import ETFS, get_prices, target_weights

STATE, LOG = Path("paper_sim_state.json"), Path("paper_log.jsonl")
INIT_CASH, DRIFT, COST_BPS = 100_000.0, 0.05, 5.0

def load_state():
    if STATE.exists(): return json.loads(STATE.read_text())
    return {"cash": INIT_CASH, "positions": {t: 0.0 for t in ETFS}, "inception_nav": INIT_CASH}

def peak(nav):
    p = nav
    if LOG.exists():
        for ln in LOG.read_text().splitlines():
            try: p = max(p, json.loads(ln)["nav"])
            except Exception: pass
    return p

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--status", action="store_true"); ap.add_argument("--reset", action="store_true")
    a = ap.parse_args()
    if a.reset:
        STATE.write_text(json.dumps({"cash": INIT_CASH, "positions": {t: 0.0 for t in ETFS},
                                     "inception_nav": INIT_CASH})); print("reset to $100k"); return

    prices, weights = get_prices().iloc[-1], target_weights(get_prices())
    s = load_state(); pos, cash = {t: s["positions"].get(t, 0.0) for t in ETFS}, s["cash"]
    nav = cash + sum(pos[t] * prices[t] for t in ETFS)
    cur = {t: (pos[t]*prices[t]/nav if nav else 0) for t in ETFS}
    drift = max(abs(cur[t] - weights[t]) for t in ETFS)
    dd = nav / peak(nav) - 1

    print(f"\n{datetime.now(timezone.utc):%Y-%m-%d}  NAV ${nav:,.0f}  since-start {nav/s['inception_nav']-1:+.1%}  drawdown {dd:+.1%}")
    for t in ETFS:
        print(f"  {t:5s} target {weights[t]*100:5.1f}%  current {cur[t]*100:5.1f}%  drift {(cur[t]-weights[t])*100:+5.1f}%")
    print(f"  max drift {drift*100:.1f}%  (threshold {DRIFT*100:.0f}%)")
    if a.status: return

    rebalanced = False
    if drift > DRIFT or all(v == 0 for v in pos.values()):
        new = {t: nav * weights[t] / prices[t] for t in ETFS}
        cost = sum(abs(new[t]-pos[t])*prices[t] for t in ETFS) * COST_BPS/1e4
        cash, pos, nav, rebalanced = -cost, new, nav - cost, True
        print(f"  ⟳ rebalanced (cost ${cost:,.0f}) → NAV ${nav:,.0f}")
    else:
        print("  ✅ within 5% → monitor only, no trades")

    s["cash"], s["positions"] = cash, pos
    STATE.write_text(json.dumps(s))
    with open(LOG, "a") as f:
        f.write(json.dumps(dict(ts=datetime.now(timezone.utc).isoformat(), nav=nav,
                                drift=round(drift, 4), rebalanced=rebalanced)) + "\n")

if __name__ == "__main__":
    main()

回し方（初回で$100kを配分して、あとは追跡するだけ）:

bash
python paper_sim.py            # daily: monitor, rebalance only if drifted >5%
python paper_sim.py --status   # NAV, drawdown, drift — no changes
text
2026-07-02  NAV $100,000  since-start +0.0%  drawdown +0.0%
  SPY   target  27.7%  current  0.0%  drift -27.7%
  ...
  max drift 37.9%  (threshold 5%)
  ⟳ rebalanced (cost $50) → NAV $99,950

さて、正直なところをはっきり書いておく。自分を過大に売り込むシステムは、それ自体が嘘だからだ。 これは強気相場でS&Pに勝てない。わざと遅れるように作ってある。勝つのは株がダメなときだ。金利ショック、インフレ、危機みたいな局面。18年間のバックテストでは、2008年にS&Pが37%下げるなか、これは横ばい（フラット）だった。ドローダウンも一貫して市場の3分の1くらいで済む。これはレジームへの賭けで、もっと滑らかな乗り心地であって、タダのアルファではない。

4. 自動化 — plist一つで勝手に回る

Macなら、launchdエージェントが平日の引け後に毎回シミュを勝手に回してくれる。君が手を動かすことは何もない。これを~/Library/LaunchAgents/com.honesttrader.papersim.plistとして保存して（パス2つだけ直して）、launchctl loadすれば終わりだ。

xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0"><dict>
  <key>Label</key><string>com.honesttrader.papersim</string>
  <key>ProgramArguments</key>
  <array>
    <string>/ABSOLUTE/PATH/honest-trader/.venv/bin/python</string>
    <string>/ABSOLUTE/PATH/honest-trader/paper_sim.py</string>
  </array>
  <key>WorkingDirectory</key><string>/ABSOLUTE/PATH/honest-trader</string>
  <key>StartCalendarInterval</key>
  <array>
    <dict><key>Weekday</key><integer>1</integer><key>Hour</key><integer>18</integer></dict>
    <dict><key>Weekday</key><integer>2</integer><key>Hour</key><integer>18</integer></dict>
    <dict><key>Weekday</key><integer>3</integer><key>Hour</key><integer>18</integer></dict>
    <dict><key>Weekday</key><integer>4</integer><key>Hour</key><integer>18</integer></dict>
    <dict><key>Weekday</key><integer>5</integer><key>Hour</key><integer>18</integer></dict>
  </array>
  <key>StandardOutPath</key><string>/ABSOLUTE/PATH/honest-trader/sim.log</string>
  <key>StandardErrorPath</key><string>/ABSOLUTE/PATH/honest-trader/sim.log</string>
</dict></plist>
bash
launchctl load ~/Library/LaunchAgents/com.honesttrader.papersim.plist
launchctl start com.honesttrader.papersim     # test it now
tail sim.log

これで勝手に回る — ノートPCが常にオンとは限らない、と思い出すまでは。マシンが眠ってた日を飛ばしたトレーディングログなんて、無いよりタチが悪い。それを解くのが最後のパートだ。

5. lavelaに載せる — ノートPCなしでも回るように

正直、このパートが一番怖くて、だから一番触らなかった。僕はサーバーを運用しない。クラウドのcronだの、TLSだの、シークレットだの、デプロイパイプラインだの、学びたくなかった。ただこの毎日回るジョブが、どこか常時オンの場所で、ずっと、数ドルで回ってくれさえすればよかった。

🗣️ 僕が頼んだこと

「これをクラウドで回して。僕のノートPCが起きてようが寝てようが関係ないように。あと、簡単に。」

頼んだのはそれだけ。そこでClaudeがlavelaを勧めてきた。 発想は*「DevOpsをまるごと置き換える」*だ。lavelaをClaude CodeにMCPサーバーとしてつないでおくと、そこから先はClaudeがコンピュート、スケジューリング、シークレットをツールコールで直接プロビジョニングしてくれる。君がDevOpsを触ることはない。

だから僕がやったのは2つだけ。コンソールでサインアップして（https://console.lavela.dev）、1行だけ叩いた。

bash
npx @lavela/cli connect

ブラウザが開いて → ログイン → Authorize & connect。CLIがトークンを君のClaude Code設定に直接書き込む。URLにも、シェル履歴にも、チャットにも、絶対に出てこない。Claude Codeを新しく開けば（または/mcp → Reconnect）、mcp__lavela__*ツールが生きている。あとは*「毎日回るペーパーシムのジョブをlavelaにデプロイして」*の一言でおしまいだ。

🤖 Claudeがやったこと

そして声に出して言う価値のあるところ。この上にいつか有料プロダクトを載せたとしても、lavelaは君が稼いだぶんの0%しか取らない。 売上は全額そのまま君に精算されて、lavelaは君の売上じゃなく、自分が回すコンピュートで稼ぐ。個人のトレーディングログなんて売るものは無いけど — 僕の趣味をデプロイしたその1つのコマンドが、そのまま本物のプロダクトをデプロイするコマンドでもある。

まとめると、「僕のMacが起きてるときだけ回るスクリプト」から「クラウドで24時間、ずっと、数ドルで勝手に回るジョブ」に移った。そのために僕がやったのは、コマンドを1つ叩いて、1回承認しただけ。難しいインフラは、僕が何一つ知らない部分で、しかも僕がやらずに済んだ部分だ。

3ヶ月経って — ここまでの旅

僕は市場に勝つ機械が欲しかった。3ヶ月経った今も、まだ手にはしていない — そして、君にそれを売ろうとしてる連中がなぜ持っていないのか、その理由まではっきり分かった。でも僕は幻想を追いかけるのをやめて、自分が本当に信頼できる何かを作り始めた。しかもそれは今も、週ごとに磨き続けている。

代わりに手元に残ったものは、あの幻想より上等だ。自分が何者なのかについて正直な、シンプルな分散システム。自分で自分に嘘をつくのを捕まえてくれる統計。そして僕がいなくても永遠にそれを回し続けるクラウドジョブ。 これは僕を金持ちにはしてくれない。でも、ありもしないエッジを追いかけて僕を吹き飛ばしもしない。アクティブトレーダーの約93%が結局脱落することを思えば、それこそが本当の勝ちだ。

この記事から一つだけ作るなら、検証を作れ。honesty.py、生存者バイアスのないデータ、正直なコスト。戦略のほうは、初心者でもコピーできるETF4本だ。本当に希少なのは自分を騙さない規律で、それがプロが実際に持ってるもののうち、君も同じように持てる唯一のものだ。

📋 5ファイル、4コマンド、1回のデプロイ。あるいはこの記事をまるごとClaude Codeに貼り付けて、*「これを作ってlavelaにデプロイして」*と言え。同じシステム、同じ正直性チェック、同じ常時オンのクラウドジョブが手に入る — そして運がよければ、同じ謙虚さまで。

この記事にいいね

コメント

アカウント不要。コメントは公開されます。