正在加载视频...

视频加载失败

you wrote a long careful note so it would remember the thing properly the note is the part that does not load what loads at the start of every session is the index line, the one sentence summary, and only the first two hundred lines of it or the...

28,369 次观看 • 1 个月前 •via X (Twitter)

8 条评论

nathan-james 的头像
nathan-james1 个月前

あー、そのあるあるすごいわかる!大事な部分が読めないって焦るよね。😅

Britt Ong 的头像
Britt Ong1 个月前

Em đây chỉ muốn có Hiệp cạnh bên

Huysolo 的头像
Huysolo1 个月前

Context optimization is just an elaborate illusion when system prompts treat detailed notes like unread footnotes

施工現場の拾い物 的头像
施工現場の拾い物1 个月前

���のノートの準備、すごく丁寧だね!私もそれくらい工夫してみたいな〜。

sophia f, 的头像
sophia f,1 个月前

Facts!

Joey 的头像
Joey1 个月前

Plus, who knows what will happen in the futured.

ノブユキ 的头像
ノブユキ1 个月前

ノートの部分が読み込まれないと不安になるよね。その間に別の方法で復習するしかないかな…。

佐藤 ��也 的头像
佐藤 ��也1 个月前

その長いノート、どんなことが書かれていたのか気になります!記憶の残し方、羨ましいです✨

相关视频

Orchestrators vs. Graphs, clearly explained! orchestrators are great, and everyone builds one first. here is the ceiling: an orchestrator sits above the work and routes every message. five agents report to it. it reads all five. it decides what each one does next, and reads all five replies. that is ten trips through one context, and by the fifth agent that context has read four reports, five instructions and its own reasoning about all of them. Graph engineering fixes this by removing the seat: not a better router, but no router at all. you need both, and here is the sentence that resolves the whole confusion: an orchestrator sits above the work and holds all of it. a graph is the shape of the work, and holds none of it. ↳ above the work: one context that has to see everything before anything ships ↳ inside the work: a splitter that hands out and lets go, and a merge that reads nothing Prompts → Context → Harness → Loops → Graphs the coordination did not disappear. it moved into the edges, where it costs nothing and cannot get tired. the trick is noticing what you actually built. if one node has to see every result before the run can finish, you did not remove the bottleneck. you hired it, gave it the longest context in the system, and made it the thing you were counting on to stay sharp. one thing to know before you scale it. an orchestrator degrades in the one way nothing catches. ↳ it does not crash, time out or return an error. it stays up and keeps routing ↳ it just starts routing worse, somewhere around the fifth report, and every downstream agent does exactly what it was told that last one catches careful people. you can have perfect isolation on every worker and still have one window quietly drifting at the top, and the traces will all look clean because each worker did its job. and the one that eats whole nights: the merge is where this shows up first. ranking five findings is not judgment, it is a sort. if a model is doing it, you are paying a model to read five reports so it can put them in an order that three lines of code would have got right, and now that model has read everything too. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓

Hanako

44,226 次观看 • 1 个月前

Workflows vs. Graphs, clearly explained! workflows are great, and almost everyone has one. here is the ceiling: a workflow decides every step before it runs. you drew eight boxes in March. six months later the same three fire, every single time, and the other five have never once been reached. then a case arrives that nobody drew, and it goes to the closest wrong box. quietly, with a green status, because from the inside that looks exactly like success. Graph engineering fixes this by moving the decision: not what the steps do, but when the steps get chosen. you need both, and here is the sentence that resolves the whole confusion: a workflow decides the steps before it runs. a graph decides them while it runs. ↳ drawn in advance: the boxes, the branches, the order, the error path ↳ decided at runtime: how many units exist, what each one is allowed to see, which ones get created at all Prompts → Context → Harness → Loops → Graphs branches do not make it a graph. the branches were drawn in advance too, which means every one of them is a case you already thought of. the trick is knowing which part is allowed to be fixed. the node kinds are fixed. a splitter is a splitter, a gate is a gate, a merge is code. what is not fixed is how many of them exist this run, and that is decided after something has been read. one thing to know before you scale it. a workflow fails in a way that never pages anyone. ↳ the wrong branch ran, every check inside it passed, and the output is well formed ↳ nothing errored, because routing to the wrong box is not an error, it is a route that last one catches careful people. you cannot test your way out of it either, because the test suite was written from the same diagram that has the gap in it. and the one that eats whole nights: a workflow that has never surprised you is not stable, it is narrow. if it has run four hundred times and produced the same three shapes, it is not handling your work. it is handling the part of your work that fits it, and you have quietly stopped sending it the rest. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓

Hanako

16,810 次观看 • 1 个月前

your agent has thirty tools. it calls two of them. the other twenty eight are not sitting idle somewhere. they are in the request, every request, and they are doing damage in two places at once. first the obvious one. tool schemas go into the prompt, and a schema is not a name. it is a description, a parameter list, types, required fields, an example. thirty of those is a few thousand tokens that ship with every single call, including the ones where the agent just says thanks and stops. you are paying rent on twenty eight tools that have never fired. second, and this is the one that costs more. when the request says cancel the order, the model picks by matching against everything available. four of your tools are plausible: cancel_order, refund_order, update_order, void_order. it is choosing among them based on the descriptions you wrote, one afternoon, months ago. every tool you add is another candidate in that shortlist. the twenty eight you never call are not neutral. they are noise in the one decision that determines whether the run works. > why it grows without anyone deciding to nobody adds thirty tools on purpose. you add one for a task, it works, it stays. six months later the registry is a catalogue and no one has ever removed anything, because removing a tool feels risky and adding one feels free. and there is no feedback telling you otherwise. the unused ones never error. they never appear in a failing trace. they are invisible in exactly the way that lets them accumulate. > what to actually do count calls per tool over the last thousand runs. this is one group-by and it usually shocks people. the ones at zero are pure cost. ship the tools the task needs, not the whole registry. a research phase does not need deploy. a writing phase does not need the database. swap the set between phases instead of loading everything up front. same agent, different tools, depending on where the run is. and when two tools could both plausibly answer the same request, that is not redundancy you can ignore. it is a coin flip you built into the system. the twenty eight tools are not unused. they are used every time, by the part of the run you cannot see.

Hanako

24,656 次观看 • 2 个月前

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: a skill is one folder with one markdown file, and Claude only reads it when your request actually matches it. You stop pasting the same instructions into every session, and you pay one line of context instead of the whole document. You just make one folder: .claude/skills/review-pr/SKILL.md here's the split: → the description is the only thing sitting in context, roughly one line per skill → the full body loads the second a request matches that description → scripts in the folder get executed, never read into context → commit the folder and every person in the repo has the skill three frontmatter lines do the heavy lifting: → allowed-tools pre-approves the tools, so it runs without a permission prompt → context: fork hands the skill to a subagent that never sees your chat → paths limits it to the files it actually belongs to Description matches. Body loads. Scripts run. JEV engineering is the same move one layer down: the forks that need no thinker (which skill, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > .claude/skills/ /SKILL.md for the repo, ~/.claude/skills/ for your own > only descriptions sit in context, the body loads on match > keep SKILL.md under 500 lines, every line is a recurring cost once loaded > description plus when_to_use is cut at 1,536 characters, put the trigger first > context: fork runs it in a subagent with no conversation history > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Set up skills in this repo from the tree above: 1. Create .claude/skills/ and move the repeated instructions out of CLAUDE.md into one skill per job. 2. Write every description as a trigger sentence first, since the listing is cut at 1,536 characters. 3. Put anything deterministic into scripts/ and pre-approve it with allowed-tools so it runs without a prompt. 4. Route fast deterministic forks (which skill, which tool, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, it'll come in handy.

xsmryze

15,075 次观看 • 12 天前

Agents vs. Graphs, clearly explained! spawning more agents is great, but it has a ceiling nobody says out loud: five agents is a count. a graph is a shape. only one of them changes the answer. point five agents at the same pile with the same window and they converge. the first one writes a finding, the rest read it, and all five reports centre on the same thing. you paid five times for one opinion with four echoes. Graph engineering fixes this by moving the decision up a layer: not how many agents, but who is allowed to look at what. you need both. here's how it works: ↳ the count buys you throughput. five things happening instead of one ↳ the shape buys you coverage. five different things happening instead of the same one five times Prompts → Context → Harness → Agents → Graphs the node that does this is the splitter, and it decides more than any other node in the system. cut a repository by folder and four workers audit the same three files. cut it by blast radius and each one sees something the others cannot. the trick is being selective about what each lane is allowed to see. separate contexts are not a nice-to-have, they are the mechanism. if two agents are meant to produce different things, they must not share a window. if they are meant to produce the same thing, you did not need two agents. one thing to know before you scale it. a branch that throws does not reject the batch. it resolves to null, and that is the containment. which means your merge quietly receives a short list. ↳ filter the nulls before the merge, or one dead lane poisons the whole result ↳ never index a merge by position. eight good branches and one failure will shift everything by one, silently skip that and the run looks like it worked. the output is just missing a lane, and nothing errored. and the one that eats whole nights: multi-agent setups can use up to fifteen times the total tokens of a single chat, because every lane reloads its own core. you are trading total tokens for a clean main window. usually the right trade, always a choice. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓

Hanako

97,154 次观看 • 2 个月前

I fell asleep with the Grok Bot terminal running. 4:07 AM it woke me up 392 filings parsed overnight. 1,703 claims checked. nine survived, not one of them read by me fed it four quant formulas from a paper and one rule about sourcing it built the whole desk the logic: > every claim enters at the outer ring > it has to survive source, date, tie-out, duplicate, cross-check, materiality > anything without a filing behind it dies in the same second > whatever is left gets sized at quarter kelly and lands on my desk this is what Citadel does before every open, except they put thirty analysts on it this is one screen on the terminal right now: 392 filings since midnight, 1,694 claims killed, 9 alive, 14 minutes from filing to parsed, $0.27 an hour, zero humans on the floor the event stream is a wall of deaths killed at source killed at date killed at duplicate killed at materiality every second. new line. new kill the real edge is that first gate. no filing behind the claim and it dies before anything else looks at it that one rule removed the thing everybody complains about with AI. the desk cannot invent a number it is not allowed to ship without a page reference SOURCE 0.62... 0.66... 0.61 nobody told it to tighten. the kill rate moved with what came in overnight 99.5 of every 100 claims never reach me. the nine that do come with a page number attached a Bloomberg seat is thirty thousand a year and would have handed me all 1,703. this desk is two hundred a month everyone is building agents that find more mine is worth what it is because it finds less the whole build is in the article below, save it before your next open

Hanako

17,861 次观看 • 2 个月前