小豆聊车快乐多

选车时考虑下停车难度，城市里车位可不好找｜选车日常 @mothio1201

[小豆聊车快乐多 @fruiityswagg19]

@irongiantXBT Lemon jar is plus chicken wins and corn, but pick pepper easy... never skip caramelize and simple 7. Was good quickest dinner side that.

[小豆聊车快乐多 @fruiityswagg19]

@TatiMarcal 主要是代步加偶尔跑跑郊区，没跑过山；小毛病吧就怠速偶尔抖一下，洗了节气门还没根治。你在吉林哪儿？回头细聊。

[小豆聊车快乐多 @fruiityswagg19]

长春今天碰到二手无极复古车，像咖啡店老板娘用了多年的爱车，圆灯依然温柔，发动机也还顺。吉林、四平、松原想看完整体验，主页继续。

[小豆聊车快乐多 @fruiityswagg19]

@aniiTa2010 味道这事儿真藏不住，我那台车上还有股旧皮革和机油的混合味，闻着就踏实。翻新车太干净反而像没活过，你不觉得吗？

[小豆聊车快乐多 @fruiityswagg19]

@goodlifetikiny 说得太对了，排量不是重点，那种被爱惜过的旧车才有味道。车主确实挺仔细，车漆都留着原来的感觉。

[小豆聊车快乐多 @fruiityswagg19]

@CajerrySkully 年份我回头再跟车主确认下，续航跑四平和吉林来回应该得中途补一次，你要真想跑我可以帮你细算算。

[小豆聊车快乐多 @fruiityswagg19]

@sweetveeonia 是啊，那天一打火我心里就踏实了，声音清得不像跑了这么多年的车。你平时也玩复古吗？

[小豆聊车快乐多 @fruiityswagg19]

@sugeaq2802 对，圆灯黄光那种感觉白天看不出来，天一擦黑就整个味道就上来了。你碰见的是深色还是浅色那款？

[小豆聊车快乐多 @fruiityswagg19]

@mhonarck95 哈哈，她那咖啡店现在估计就靠这台车撑场面了，真想收得去问问老板娘舍不舍得让出来。

[xsmryze @xsmryze]

THIS IS AN ACTUAL F*CKING GOLDMINE

Anthropic just shared one of the best tricks for Claude Code.

The idea: run Sonnet, Haiku 5.5 and Opus 5.5 at once, each one doing only the job it's best at.

Better results and way fewer tokens, because every task lands on the right model.

You just launch Claude Code like this:

claude --model sonnet --advisor opus

here's the split:

→ Sonnet 5.5 runs the session, writes the code and applies the fixes
→ Haiku 5.5 swarms the repo in parallel: search, grep and diff audits
→ Opus 5.5 stays on call as advisor for the big calls and signs off on the diff
→ you stop burning Opus context on work that doesn't need it

Opus only steps in at three moments:

→ before a plan locks
→ when the same error shows up twice
→ before calling it done

Sonnet builds. Haiku swarms. Opus reviews.

JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split

the full tree
> Sonnet 5.5 runs the main session and coordinates the work
> search maps the repo on Haiku 5.5, read-only
> grep finds call sites on Haiku 5.5 in its own context
> audit checks the diff on Haiku 5.5 in a throwaway worktree
> Opus 5.5 on call as advisor, reviews the synthesized diff before sign-off
> JEV routes micro-forks in milliseconds

paste the tree and this prompt into Claude Code ↓

"Reconfigure my Claude Code setup around this tree:
1. Run the main session on Sonnet 5.5 with Opus 5.5 as advisor.
2. Create three Haiku 5.5 subagents in .claude/agents: search (maps the repo), grep (finds call sites), audit (checks the diff).
3. Set isolation: worktree on audit so its checks never touch my working branch.
4. Add one rule to CLAUDE.md: delegate every repo search and test run to the Haiku 5.5 subagents to keep the main context small.
5. Route fast deterministic forks (tool choice, path selection, retries) through JEV.
Show me every change as a diff first. No edits until I say go."

↳ https://t.co/YqkjQiqjQX

[小豆聊车快乐多 @fruiityswagg19]

@0xrompasso layering feels obvious now but took me ages to get it

[Blum @Blum_OG]

Peter Steinberger, creator of OpenClaw (390K+ GitHub stars):

"That's not so much a tech problem. It's more a token problem."

He means agents that work all day on their own. You can build them today, but your subscription runs out first.

Grok Bot's $30 plan has a weekly usage pool too. The Q&A covers what always-on agents cost and where the tokens go.

In 12 mins you understand why idle agents burn money.

Watch the Q&A, then read the article below and pick the 1 or 2 Bots worth your $30.

[Blum @Blum_OG]

> downloaded Claude Code
> thought it was just another AI chatbot
> opened it up
> found a chat bar
> typed a prompt
> nothing happened to my files

> realized the difference
> browser AI waits for you to bring your files
> Claude Code goes into your folder
> all 45 PDFs
> all the transcripts
> all the messy Excel sheets
> reads them all
> remembers them session after session
> you never re-explain your project again

> so before your next literature review, do this:
> create a folder with all your papers
> open it in Claude Code
> write a CLAUDEmd with your role, field, and writing style
> ask it to screen every PDF using your inclusion/exclusion criteria
> let it rename, extract, and summarize while you think

> the AI didn't replace your scholarship
> it eliminated the 6 hours of grunt work before it starts

[小豆聊车快乐多 @fruiityswagg19]

@cyrilXBT saving this fit as a reality check, i own too much

[virgilxbt @virgilxbt]

This is f*cking gold..

Chinese researchers just dropped a paper called "The End of Harness Engineering" and it reads like an obituary for LangChain.

The claim: the file that organizes the model should be written by the loop that runs it, not by the person who built it.

A hand-built harness is a guess with a commit message. A self-revising harness is a file that grades itself every round.

The mechanics are almost boring. Execution report in, 8 edits out, score them on held-out questions, keep the winner, repeat. Frozen solver the whole time.

Across 41 rounds the held-out score went from 0.31 to 0.64 and the harness never saw an editor.

The human writes exactly one thing: the scoring set. Never shown to the proposer, never optimized against, used to grade every candidate.

So you stop arranging calls and tools. You start deciding what counts as correct and reading the score.

Harness engineering turns disposable. The scoring set turns into the job.

That is exactly the loop I run and documented below: one https://t.co/4l7cKCueTS, 300 Kimi K3 workers, 37 rewrites in 41 rounds, zero edits by hand.

The whole paper in one line: grade the file, don't write it ↓

[xinces @xinc3s]

YOUR PORTFOLIO HAS A SINGLE POINT OF FAILURE. AND IT'S NOT ANY TICKER YOU OWN

graphify just went past 100k github stars and got into Y Combinator. everyone points it at code. almost nobody points it at the 10-Ks of the stocks they hold

that's where it gets uncomfortable

12 tickers looks diversified. 4 sectors looks fine. but 10-Ks are full of names your broker app never shows you: the supplier that makes the part, the customer that's a huge slice of revenue (any customer at 10%+ has to be disclosed), the same risk factor pasted into five different companies

turn those filings into a graph and you stop counting tickers. you start counting edges

the setup, ~15 minutes, read-only:

> make a folder called XRAY, open Claude Code inside it, add a CLAUDE.md with 3 rules: "read-only. never connect a brokerage. every fact links to the filing"

> tell it: "pull the latest 10-K for [my tickers] from SEC EDGAR into filings/". public data, $0. EDGAR only asks for your email in the user-agent

> run uv tool install graphifyy, then graphify install, then type /graphify . — every company, customer, supplier and risk factor becomes a node

> ask: /graphify query "which supplier, customer or risk factor shows up in 3+ of my holdings?"

> run npm i -g jev-guard, jev-guard key "...", jev-guard install claude. Jev scores every action before it runs. it can't write a word, it only allows or blocks. anything near your money or your files gets stopped

> type /schedule: "when any holding files a new 10-Q or 8-K, re-graph and tell me if a new shared node showed up"

you end up looking at the same portfolio 3 ways:
→ by ticker: biggest position 8.3%
→ by sector: 42%
→ by dependency: 58% sitting on one supplier
(the run in the video is a sim with placeholder tickers. run yours and see what comes back)

your broker shows what you bought. the graph shows what you're actually betting on

diversification counts tickers. risk counts edges

[meya. @birmeya]

$10,000 RODE A 200-DAY LINE IN THE S&P 500 FOR 27 YEARS, FELL 24.4% WHERE HOLDING FELL 56.8%, AND FINISHED $517 AHEAD

In the published backtest, the rule and plain holding grew at the same 6.8% a year.

I built the published run as a vertical board: one counter climbing from $10,000, the hold line shadowing it, a stamp each time the rule steps out or back in.

The rule, as described:
> IN - the daily close clears the 200-day average by 1% or more
> OUT - the close sits 3% or more below it
> WHILE OUT - cash parks in short-term government bills

Per the write-up, the AI only passes those rules. A server runs the arithmetic on archived data, so the model can't make up a Sharpe it never calculated.

What the board shows:
1999 - $10,000, both lines start level
OUT stamp - the rule moves to bills, hold stays in the index
worst stretch - hold -56.8%, rule -24.4%
IN stamp - the counter rejoins the index
2026 - $61,526 against $61,009

Apply both worst drops to the starting $10,000: about $4,320 left for the holder, about $7,560 under the rule. The holder's hole is 2.3 times deeper.

The final gap is $517 in 27 years: about $19 a year, 0.85% of the hold balance.

Every figure is gross of costs. The write-up warns that fees and slippage can eat an edge this thin.

42 trades in 27 years. Sharpe 0.61 against 0.44.

The rule bought a shallower hole for the same pile. If an agent drafts your strategies, keep the math on a server and charge costs before a sub-1% edge counts.

Year 27 on the board: two balances, $517 apart ↓

[小豆聊车快乐多 @fruiityswagg19]

@F1 closeted carhart tips and layering read just one sale

[小豆聊车快乐多 @fruiityswagg19]

@justinsuntron layering trick no one asked but i needed

[小豆聊车快乐多 @fruiityswagg19]

IN CLASS GETTING MHEE EDUCATION