正在加载视频...

视频加载失败

返回首页

Most discussions around Claude Code focus on model quality or capability. But when you actually use it, the friction shows up earlier, more at the system level than the model itself. Token limits get the blame, but a lot of it comes from inefficient sessions: repeated context, extra tool...

Parul_Gautam7's profile picture

Parul Gautam

86,767 subscribers

15,079 次观看 • 4 个月前 •via X (Twitter)

教育新闻政治科学技术
LIVE

Anya Rossi• Live Now

Private livecam show

0 条评论

暂无评论

原始帖子的评论将显示在这里

相关视频

Claude Code With UNLIMITED Memory! Solves Claude's Memory Problem! It’s called Claude-Mem, and it lets Claude remember your work across sessions. ⚡ Slash token usage by up to 95% every time you start a session. 🔧 Unlock the ability to make 20× more tool calls before hitting limits. My Video:
0:58

Claude Code With UNLIMITED Memory! Solves Claude's Memory Problem! It’s called Claude-Mem, and it lets Claude remember your work across sessions. ⚡ Slash token usage by up to 95% every time you start a session. 🔧 Unlock the ability to make 20× more tool calls before hitting limits. My Video:

WorldofAI

28,687 次观看 • 7 个月前

THIS GUY SPENT 5 MINUTES SETTING UP A $20 CLAUDE WORKSPACE AND TURNED 30 MINUTES OF DAILY PROMPT CHAOS INTO A SYSTEM Most people open Claude, type 1 messy prompt, rewrite it 10 times, get the same generic answer and call the model “bad.” He opens Claude Cowork, adds the project rules, past context, working files, examples, decisions and a clean place for the model to remember what it is doing. Same Claude. Same $20 tool. Completely different output. The funny part is there is no magic prompt here. No secret template. No “10x Claude” trick. Just the boring layer Karpathy keeps pointing at: context, memory and structure before output. A setup like this can save 30 minutes a day, which is 15 hours a month. If you use Claude for client work at $50 to $100/hour, that is $750 to $1,500/month in time you stop burning on repeated prompts. The model is real. The output is real. The edge is in not making Claude start from zero every single time.
0:37

THIS GUY SPENT 5 MINUTES SETTING UP A $20 CLAUDE WORKSPACE AND TURNED 30 MINUTES OF DAILY PROMPT CHAOS INTO A SYSTEM Most people open Claude, type 1 messy prompt, rewrite it 10 times, get the same generic answer and call the model “bad.” He opens Claude Cowork, adds the project rules, past context, working files, examples, decisions and a clean place for the model to remember what it is doing. Same Claude. Same $20 tool. Completely different output. The funny part is there is no magic prompt here. No secret template. No “10x Claude” trick. Just the boring layer Karpathy keeps pointing at: context, memory and structure before output. A setup like this can save 30 minutes a day, which is 15 hours a month. If you use Claude for client work at $50 to $100/hour, that is $750 to $1,500/month in time you stop burning on repeated prompts. The model is real. The output is real. The edge is in not making Claude start from zero every single time.

Gipp 🦅

14,871 次观看 • 3 个月前

What is a software factory? It is your workflow, your skills, and your domain knowledge, saved in files that the agent reads so the whole process is productized Think about the last app you built. You typed what you wanted, and the agent built it. You did not like it, so you made changes. You shipped it to Vercel, or you kept going. A factory puts structure on each of those steps. At each step you ask how to get the most from the model, and how to move faster. That is the conveyor belt. You ship quickly, and the quality stays the same. Mine is 5 md files. It works in Codex, Claude Code, and Cursor, because it does not depend on the model or the tool. Build your own.
3:06

What is a software factory? It is your workflow, your skills, and your domain knowledge, saved in files that the agent reads so the whole process is productized Think about the last app you built. You typed what you wanted, and the agent built it. You did not like it, so you made changes. You shipped it to Vercel, or you kept going. A factory puts structure on each of those steps. At each step you ask how to get the most from the model, and how to move faster. That is the conveyor belt. You ship quickly, and the quality stays the same. Mine is 5 md files. It works in Codex, Claude Code, and Cursor, because it does not depend on the model or the tool. Build your own.

The Startup Ideas Podcast (SIP) 🧃

17,107 次观看 • 9 天前

I just found a way to use Claude Code completely free. Claude Code is Anthropic’s terminal coding agent that usually needs a paid API key to run. But a viral GitHub project called Free Claude Code, now sitting at 37k stars, lets you skip the billing entirely. It works as a tiny proxy that sits between Claude Code and free model providers like NVIDIA NIM, OpenRouter, DeepSeek, and Gemini. Every request Claude Code would send to Anthropic gets quietly rerouted to a free model on the other side. The interface stays the same. What’s actually thinking behind it changes. Setup takes a couple of quick commands and a free API key from NVIDIA NIM or OpenRouter. Paste it into the local dashboard, pick a model, and you’re building. The catch is you’re not really using Claude anymore. But when the code ships, does the model badge matter? -- I have shared the Github Link in my free Whatsapp Community ↓
0:36

I just found a way to use Claude Code completely free. Claude Code is Anthropic’s terminal coding agent that usually needs a paid API key to run. But a viral GitHub project called Free Claude Code, now sitting at 37k stars, lets you skip the billing entirely. It works as a tiny proxy that sits between Claude Code and free model providers like NVIDIA NIM, OpenRouter, DeepSeek, and Gemini. Every request Claude Code would send to Anthropic gets quietly rerouted to a free model on the other side. The interface stays the same. What’s actually thinking behind it changes. Setup takes a couple of quick commands and a free API key from NVIDIA NIM or OpenRouter. Paste it into the local dashboard, pick a model, and you’re building. The catch is you’re not really using Claude anymore. But when the code ships, does the model badge matter? -- I have shared the Github Link in my free Whatsapp Community ↓

Vaibhav Sisinty

37,255 次观看 • 2 个月前

Anthropic engineer: "Most people are using 10% of what Claude can do. The other 90% is Loops and Graphs." In just 27 minutes he explains how Anthropic actually uses Claude, and why most people never get there Chat → Agents → Loops → Graphs most people open a chat, prompt it well, and stop there because it works he closes the chat and builds the system that runs without him opening anything same model, same tokens, completely different workflow watch it today the full graph engineering guide is below, save it before everyone starts catching up ↓
26:55

Anthropic engineer: "Most people are using 10% of what Claude can do. The other 90% is Loops and Graphs." In just 27 minutes he explains how Anthropic actually uses Claude, and why most people never get there Chat → Agents → Loops → Graphs most people open a chat, prompt it well, and stop there because it works he closes the chat and builds the system that runs without him opening anything same model, same tokens, completely different workflow watch it today the full graph engineering guide is below, save it before everyone starts catching up ↓

Lunar

20,527 次观看 • 18 天前

Opus 4.7 - 400k vs 1m context - is there a difference? I've heard Theo - t3.gg talk about the fact that it is unlikely that Anthropic would have offered up a model with 1m context at the same cost, if it wasn't a different (i.e. cheaper to serve) model. I did a test where I toggled the 1m default model on & off in Claude Code (otherwise default settings, xHigh reasoning) and compared the outputs with 3x generations - same prompts etc. My observations: - Models feel DIFFERENT - often when you ask a model for the same generation, you get a somewhat different answer, but it feels & smells the same. Here 400k and 1m are very different every time - 400k model seems better - not that 1m is trash and 400k is amazing, but there are definitely issues with the level of ambition and accuracy that 1m model seems to have Examples of 1m failing: - Voxel Rome: the colosseum is nowhere near as impressive - Golden Gate: cars go sideways, waves not very high, bridge goes into land; though the structure of the bridge is a bit better - Stonehenge: structure is more 'wrong', lighting, shadows & textures are more flat and not as rich This isn't a conclusive evidence of course, but at least to me the two models do not behave the same way. Anecdotally as well when building 1m felt like it was doing more weird validation (e.g. going around in circles) and 400k was more straightforward. These sorts of things are harder to capture in tests, but you'd notice in Claude Code. You can review the hosted generations, see the code & prompts in the links below
0:47

Opus 4.7 - 400k vs 1m context - is there a difference? I've heard Theo - t3.gg talk about the fact that it is unlikely that Anthropic would have offered up a model with 1m context at the same cost, if it wasn't a different (i.e. cheaper to serve) model. I did a test where I toggled the 1m default model on & off in Claude Code (otherwise default settings, xHigh reasoning) and compared the outputs with 3x generations - same prompts etc. My observations: - Models feel DIFFERENT - often when you ask a model for the same generation, you get a somewhat different answer, but it feels & smells the same. Here 400k and 1m are very different every time - 400k model seems better - not that 1m is trash and 400k is amazing, but there are definitely issues with the level of ambition and accuracy that 1m model seems to have Examples of 1m failing: - Voxel Rome: the colosseum is nowhere near as impressive - Golden Gate: cars go sideways, waves not very high, bridge goes into land; though the structure of the bridge is a bit better - Stonehenge: structure is more 'wrong', lighting, shadows & textures are more flat and not as rich This isn't a conclusive evidence of course, but at least to me the two models do not behave the same way. Anecdotally as well when building 1m felt like it was doing more weird validation (e.g. going around in circles) and 400k was more straightforward. These sorts of things are harder to capture in tests, but you'd notice in Claude Code. You can review the hosted generations, see the code & prompts in the links below

Peter Gostev (SF: 22-26 June)

29,203 次观看 • 4 个月前

I made Claude compete against itself. The smartest model does not automatically make the best agent. To prove it, I took the same Opus 4.6 model, initial prompt, and empty repo and but it inside two different coding harnesses: Claude Code vs. Factory Droid. The task: clone Excalidraw from scratch, inspect the original in a browser, implement its key interactions, and verify the result. Factory Droid: 8 minutes, 20 tool calls, $1.60 Claude Code: 19 minutes, 40 tool calls, $1.87 The only difference was the harness. Get Free Factory credits here:
2:35

I made Claude compete against itself. The smartest model does not automatically make the best agent. To prove it, I took the same Opus 4.6 model, initial prompt, and empty repo and but it inside two different coding harnesses: Claude Code vs. Factory Droid. The task: clone Excalidraw from scratch, inspect the original in a browser, implement its key interactions, and verify the result. Factory Droid: 8 minutes, 20 tool calls, $1.60 Claude Code: 19 minutes, 40 tool calls, $1.87 The only difference was the harness. Get Free Factory credits here:

Sarah Chieng

92,118 次观看 • 1 个月前

Clawdbot creator Peter Steinberger 🦞 says Claude Opus is his favorite model, but OpenAI Codex is the best for coding: "OpenAI is very reliable. For coding, I prefer Codex because it can navigate large codebases. You can prompt and have 95% certainty that it actually works. With Claude Code you need more tricks to get the same." "But character wise, [Opus] behaves so good in a Discord it kind of feels like a human. I've only really experienced that with Opus."
1:47

Clawdbot creator Peter Steinberger 🦞 says Claude Opus is his favorite model, but OpenAI Codex is the best for coding: "OpenAI is very reliable. For coding, I prefer Codex because it can navigate large codebases. You can prompt and have 95% certainty that it actually works. With Claude Code you need more tricks to get the same." "But character wise, [Opus] behaves so good in a Discord it kind of feels like a human. I've only really experienced that with Opus."

TBPN

443,150 次观看 • 7 个月前

MIT PhD student Alex Zhang reveals the scaling result where a model trained on short tasks generalizes to problems 100x longer for free: "If you're very clever about the design of your harness or how you use the language model, you can almost get scaling gains for free." "If you train a model naively, there's no tricks. It's just the same way you train a model on these RL environments. You just roll it out, and then you just get some reward." "If you train it on only short tasks, like only tasks that are 10,000 tokens long, and then you were to run it on a similar domain, but at a million tokens, or 10 million tokens, or 100,000 tokens, it generalizes really, really well. If you look at it compared to even the base transformer, you get way better generalization properties." "When the model uses an RLM (Recursive Language Model) after it's trained on these short tasks, it will see some kind of trajectory of actions that it does. Between these two problems of different lengths, the RLM learns to see them as almost the same problem." "Token for token, they're almost the same. You can describe it in code. In one code setting, maybe the for loop is a little bigger, but it's the same kind of code and it derives the constants from the data. There's no hard coding, so they literally look the same." alex zhang
2:41

MIT PhD student Alex Zhang reveals the scaling result where a model trained on short tasks generalizes to problems 100x longer for free: "If you're very clever about the design of your harness or how you use the language model, you can almost get scaling gains for free." "If you train a model naively, there's no tricks. It's just the same way you train a model on these RL environments. You just roll it out, and then you just get some reward." "If you train it on only short tasks, like only tasks that are 10,000 tokens long, and then you were to run it on a similar domain, but at a million tokens, or 10 million tokens, or 100,000 tokens, it generalizes really, really well. If you look at it compared to even the base transformer, you get way better generalization properties." "When the model uses an RLM (Recursive Language Model) after it's trained on these short tasks, it will see some kind of trajectory of actions that it does. Between these two problems of different lengths, the RLM learns to see them as almost the same problem." "Token for token, they're almost the same. You can describe it in code. In one code setting, maybe the for loop is a little bigger, but it's the same kind of code and it derives the constants from the data. There's no hard coding, so they literally look the same." alex zhang

MTS

100,519 次观看 • 2 个月前

Sam Altman made the case for open-source harnesses in July. a month later, someone shipped it, and it's more efficient than most managed harnesses. here is the problem it was aimed at: a large share of your agent's token bill is the model rereading things it already read. that isn't the model's doing. the runtime around it decides what goes into every prompt and how often the model gets called. for example, an agent queries a CRM at step four and gets back 400 rows. those rows get piled up in the conversation history. by step nineteen, the model has to read those rows fifteen times unnecessarily, and every token read is billed at input rates. it happened because your harness assembled that prompt on every turn and kept the rows in it. that gives you two levers: how much context the harness carries forward, and how often it calls the model. there are four practical ways to keep the prompt from growing unnecessarily: → load tool schemas on demand. a server with 100 tools doesn't need to put all 100 into every prompt when the agent only calls two. → offload large results to disk. turn a large response into a short preview and a file path instead of replaying the entire result on every turn. → delegate to subagents. let a subagent spend thirty tool calls in its own context and return one summary to the root agent. → run toolchains in code. one script calls three tools, joins the results, and returns a table instead of three turns each dragging a full response. but reducing context is only half the job. you also need to control how often the model gets called. a good harness should avoid unnecessary planning, verification, and reflection when the work can be completed in fewer steps. TrueFoundry's open-source agent harness, TrueForge, is built around both of those controls. it sits between the model and the tools, deciding what goes into every prompt and when another model call is actually needed. it also breaks token usage down across the harness, skills, instructions, tools, and messages. DevRev's Enterprise-Bench is where this gets tested, on multi-step tasks of the kind where an agent pulls records from one system and reconciles them against another. TrueFoundry ran TrueForge there against Claude Managed Agents, both on the same model, and both finished the same number of tasks. the tie is the part that matters, because it means the gap underneath is not a quality tradeoff. TrueForge reached that score on close to a third of the tokens, with roughly 40% fewer trips back to the model. for the same result, that comes out around 2.7x cheaper than Claude Managed Agents. swapping in an open model made it sharper still. TrueForge with GLM-5.2 scored a little higher than either setup above, and the entire benchmark run cost about $3 at list prices. being open source matters beyond the license here. the model underneath can be swapped without rewriting the agent, and the whole thing can run inside your own environment when the data cannot leave it. all of this comes down to the runtime around the model, the context it carries, the tools it exposes, and how many times it goes back to the model. that is what a production harness actually owns. the full task list, the per-run numbers, and the MIT-licensed code are on GitHub: (don't forget to star 🌟) you can read more about the same in the article quoted below. thanks to the TrueForge team for working with me on this one.
0:39

Sam Altman made the case for open-source harnesses in July. a month later, someone shipped it, and it's more efficient than most managed harnesses. here is the problem it was aimed at: a large share of your agent's token bill is the model rereading things it already read. that isn't the model's doing. the runtime around it decides what goes into every prompt and how often the model gets called. for example, an agent queries a CRM at step four and gets back 400 rows. those rows get piled up in the conversation history. by step nineteen, the model has to read those rows fifteen times unnecessarily, and every token read is billed at input rates. it happened because your harness assembled that prompt on every turn and kept the rows in it. that gives you two levers: how much context the harness carries forward, and how often it calls the model. there are four practical ways to keep the prompt from growing unnecessarily: → load tool schemas on demand. a server with 100 tools doesn't need to put all 100 into every prompt when the agent only calls two. → offload large results to disk. turn a large response into a short preview and a file path instead of replaying the entire result on every turn. → delegate to subagents. let a subagent spend thirty tool calls in its own context and return one summary to the root agent. → run toolchains in code. one script calls three tools, joins the results, and returns a table instead of three turns each dragging a full response. but reducing context is only half the job. you also need to control how often the model gets called. a good harness should avoid unnecessary planning, verification, and reflection when the work can be completed in fewer steps. TrueFoundry's open-source agent harness, TrueForge, is built around both of those controls. it sits between the model and the tools, deciding what goes into every prompt and when another model call is actually needed. it also breaks token usage down across the harness, skills, instructions, tools, and messages. DevRev's Enterprise-Bench is where this gets tested, on multi-step tasks of the kind where an agent pulls records from one system and reconciles them against another. TrueFoundry ran TrueForge there against Claude Managed Agents, both on the same model, and both finished the same number of tasks. the tie is the part that matters, because it means the gap underneath is not a quality tradeoff. TrueForge reached that score on close to a third of the tokens, with roughly 40% fewer trips back to the model. for the same result, that comes out around 2.7x cheaper than Claude Managed Agents. swapping in an open model made it sharper still. TrueForge with GLM-5.2 scored a little higher than either setup above, and the entire benchmark run cost about $3 at list prices. being open source matters beyond the license here. the model underneath can be swapped without rewriting the agent, and the whole thing can run inside your own environment when the data cannot leave it. all of this comes down to the runtime around the model, the context it carries, the tools it exposes, and how many times it goes back to the model. that is what a production harness actually owns. the full task list, the per-run numbers, and the MIT-licensed code are on GitHub: (don't forget to star 🌟) you can read more about the same in the article quoted below. thanks to the TrueForge team for working with me on this one.

Akshay 🚀

76,998 次观看 • 1 个月前

CHINA JUST DROPPED AN AI CODING MODEL WITH A 1M CONTEXT WINDOW. And I connected it to Claude Code to see what it could actually do. Meet GLM-X Preview On paper, a few things immediately stood out: → 1M context window → Agentic coding capabilities → Works inside Claude Code → Designed for large-scale coding and reasoning workflows But specs don't matter much if the model can't deliver in practice. So I gave it a real-world task. THE TEST One prompt: > Build a modern AI lead generation dashboard using React and Tailwind CSS. Requirements: → Dark mode → Analytics dashboard → Lead table → Email outreach section → Responsive design → Production-ready component structure Instead of generating a few snippets, it planned the architecture, generated the dashboard components, created the Tailwind configuration, and walked through the implementation requirements. What impressed me most wasn't the code itself. It was how well it maintained context throughout the workflow. That's where a 1M context window starts becoming useful. Less time re-explaining requirements. Less context loss. More room for complex projects. The AI coding race is getting very interesting. And it's no longer just GPT, Claude, and Gemini competing for attention. Results from my test below 👇
0:33

CHINA JUST DROPPED AN AI CODING MODEL WITH A 1M CONTEXT WINDOW. And I connected it to Claude Code to see what it could actually do. Meet GLM-X Preview On paper, a few things immediately stood out: → 1M context window → Agentic coding capabilities → Works inside Claude Code → Designed for large-scale coding and reasoning workflows But specs don't matter much if the model can't deliver in practice. So I gave it a real-world task. THE TEST One prompt: > Build a modern AI lead generation dashboard using React and Tailwind CSS. Requirements: → Dark mode → Analytics dashboard → Lead table → Email outreach section → Responsive design → Production-ready component structure Instead of generating a few snippets, it planned the architecture, generated the dashboard components, created the Tailwind configuration, and walked through the implementation requirements. What impressed me most wasn't the code itself. It was how well it maintained context throughout the workflow. That's where a 1M context window starts becoming useful. Less time re-explaining requirements. Less context loss. More room for complex projects. The AI coding race is getting very interesting. And it's no longer just GPT, Claude, and Gemini competing for attention. Results from my test below 👇

Md Riyazuddin

31,199 次观看 • 3 个月前

MOST PEOPLE USE CLAUDE CODE LIKE CHATGPT WITH A TERMINAL That is why they only get 30% of the value. They paste a task, wait for an answer, then keep explaining the same rules again when the context gets messy. The real power starts when you stop treating it like a chatbot and start treating it like an operating system for work. The useful commands are not flashy. They just remove the parts that quietly waste hours: > /init builds the project memory > /memory edits the rules Claude should keep > /clear resets the chat without losing the setup > /compact compresses a long session before quality drops > /context shows where your tokens are going > /rewind rolls back when an edit breaks the direction > /plan forces a blueprint before execution > /model matches the brain to the task > /goal lets it work toward a clear finish line This is the difference between asking AI for help and actually managing an AI worker. One mode gives you random useful answers. The other gives you memory, boundaries, checkpoints, context control and repeatable execution. Most people are still trying to write better prompts. The better move is building a better system around the model. save this
1:05

MOST PEOPLE USE CLAUDE CODE LIKE CHATGPT WITH A TERMINAL That is why they only get 30% of the value. They paste a task, wait for an answer, then keep explaining the same rules again when the context gets messy. The real power starts when you stop treating it like a chatbot and start treating it like an operating system for work. The useful commands are not flashy. They just remove the parts that quietly waste hours: > /init builds the project memory > /memory edits the rules Claude should keep > /clear resets the chat without losing the setup > /compact compresses a long session before quality drops > /context shows where your tokens are going > /rewind rolls back when an edit breaks the direction > /plan forces a blueprint before execution > /model matches the brain to the task > /goal lets it work toward a clear finish line This is the difference between asking AI for help and actually managing an AI worker. One mode gives you random useful answers. The other gives you memory, boundaries, checkpoints, context control and repeatable execution. Most people are still trying to write better prompts. The better move is building a better system around the model. save this

Asteri

15,347 次观看 • 2 个月前

inspired by SDPO, i made continualcode -- a minimal claude code that learns from your corrections in real-time, built on tinker. when you deny a diff, the model uses your correction as context to teach itself, takes a gradient step on LoRA, and retries with updated weights. claude code but it updates the model weights!
1:35

inspired by SDPO, i made continualcode -- a minimal claude code that learns from your corrections in real-time, built on tinker. when you deny a diff, the model uses your correction as context to teach itself, takes a gradient step on LoRA, and retries with updated weights. claude code but it updates the model weights!

Surya Dantuluri

83,452 次观看 • 7 个月前

Qwen3.8-Flash-Next is still going strong at 364.7K tokens of context on an M5 Max. And this isn’t just a static long-context test. The model was reasoning about how to speed up its own workflow while using tools, and the tool calls kept working without misses. Setup: • Qwen3.8-Flash-Next • M5 Max • 128GB unified memory • MLX-Serve PR #363 • OpenCode 2 • 364.7K context The interesting part isn’t simply getting hundreds of thousands of tokens into memory. It’s what happens once the context gets this large. Long-context inference usually comes with a painful tradeoff. As the KV cache grows, memory pressure increases and generation can slow down. But this setup is still pushing through 364K tokens while maintaining a usable agent workflow. The model can reason, call tools, inspect results, continue working, and keep the session moving. And the tool calls reportedly haven’t missed so far. That’s important for agentic coding. A huge context window is only useful if the model can actually operate reliably inside it. A 400K-token context that constantly breaks tool calls isn’t very useful. A 364K session that can keep reasoning and executing tools is a different story. And the test isn’t finished yet. The current run is approaching 400K tokens, with the expectation that it can keep going. This is also another interesting example of why Apple Silicon keeps showing up in local LLM experiments. The M5 Max’s unified memory gives a large model and its growing KV cache access to one shared memory pool. With MLX-Serve continuing to improve, these machines are becoming surprisingly capable long-context inference boxes. The bigger takeaway: Context length is becoming a workload, not just a model specification. Running a model at 256K is one thing. Keeping an agent alive at 300K+ while it reasons and uses tools is much more interesting. And Qwen3.8-Flash-Next is showing that this can be pushed surprisingly far on a single 128GB Mac. 364.7K and counting. Next stop: 400K.
0:33

Qwen3.8-Flash-Next is still going strong at 364.7K tokens of context on an M5 Max. And this isn’t just a static long-context test. The model was reasoning about how to speed up its own workflow while using tools, and the tool calls kept working without misses. Setup: • Qwen3.8-Flash-Next • M5 Max • 128GB unified memory • MLX-Serve PR #363 • OpenCode 2 • 364.7K context The interesting part isn’t simply getting hundreds of thousands of tokens into memory. It’s what happens once the context gets this large. Long-context inference usually comes with a painful tradeoff. As the KV cache grows, memory pressure increases and generation can slow down. But this setup is still pushing through 364K tokens while maintaining a usable agent workflow. The model can reason, call tools, inspect results, continue working, and keep the session moving. And the tool calls reportedly haven’t missed so far. That’s important for agentic coding. A huge context window is only useful if the model can actually operate reliably inside it. A 400K-token context that constantly breaks tool calls isn’t very useful. A 364K session that can keep reasoning and executing tools is a different story. And the test isn’t finished yet. The current run is approaching 400K tokens, with the expectation that it can keep going. This is also another interesting example of why Apple Silicon keeps showing up in local LLM experiments. The M5 Max’s unified memory gives a large model and its growing KV cache access to one shared memory pool. With MLX-Serve continuing to improve, these machines are becoming surprisingly capable long-context inference boxes. The bigger takeaway: Context length is becoming a workload, not just a model specification. Running a model at 256K is one thing. Keeping an agent alive at 300K+ while it reasons and uses tools is much more interesting. And Qwen3.8-Flash-Next is showing that this can be pushed surprisingly far on a single 128GB Mac. 364.7K and counting. Next stop: 400K.

FHILY👑

39,982 次观看 • 17 天前

your agent reviewing its own work is not a check. it is a second opinion from the same source. this is the most common gap in agent systems and it hides in plain sight, because the step exists. there is a review. it just cannot do the thing you think it does. here is the mechanism. the model produced an output from a context. you then ask the same model, holding the same context, whether that output is correct. it answers fluently, because that is what it does. and the answer is drawn from the same distribution that produced the thing being judged. same weights, same window, same blind spots. if the reason the output is wrong is something the model does not know, the review does not know it either. if the reason is something the context does not contain, the review has the same context. the failure mode and the detector share a cause. > why it feels like it works because most of the time the output is fine, and the review says fine. agreement is not evidence of detection. a reviewer that says pass on everything agrees with reality most of the time too. what you actually want to measure is what happens on the cases that are wrong. that is the only place a check earns its name, and it is exactly the place where a self-review is weakest. there is research on this. Huang and colleagues at DeepMind showed at ICLR 2024 that intrinsic self-correction, revising without external grounding, does not reliably help and often makes things worse. > what to actually do move the check outside the model. a test that runs, a schema that validates, a file that exists or does not, an exit code from something you did not write. these are not smarter than the model. they are just not correlated with it, and that is the entire value. when the judgement genuinely needs a model, at minimum use a different family. same family means shared blind spots, and frontier judges measurably inflate scores for outputs that look like their own. and split the work by kind. anything objectively checkable goes to code. only the genuinely semantic calls go to a judge, and those get a rubric written as one line. a review inside the loop tells you the model is confident. a check outside it tells you whether the work is done. save this - then read the eval setup below
0:50

your agent reviewing its own work is not a check. it is a second opinion from the same source. this is the most common gap in agent systems and it hides in plain sight, because the step exists. there is a review. it just cannot do the thing you think it does. here is the mechanism. the model produced an output from a context. you then ask the same model, holding the same context, whether that output is correct. it answers fluently, because that is what it does. and the answer is drawn from the same distribution that produced the thing being judged. same weights, same window, same blind spots. if the reason the output is wrong is something the model does not know, the review does not know it either. if the reason is something the context does not contain, the review has the same context. the failure mode and the detector share a cause. > why it feels like it works because most of the time the output is fine, and the review says fine. agreement is not evidence of detection. a reviewer that says pass on everything agrees with reality most of the time too. what you actually want to measure is what happens on the cases that are wrong. that is the only place a check earns its name, and it is exactly the place where a self-review is weakest. there is research on this. Huang and colleagues at DeepMind showed at ICLR 2024 that intrinsic self-correction, revising without external grounding, does not reliably help and often makes things worse. > what to actually do move the check outside the model. a test that runs, a schema that validates, a file that exists or does not, an exit code from something you did not write. these are not smarter than the model. they are just not correlated with it, and that is the entire value. when the judgement genuinely needs a model, at minimum use a different family. same family means shared blind spots, and frontier judges measurably inflate scores for outputs that look like their own. and split the work by kind. anything objectively checkable goes to code. only the genuinely semantic calls go to a judge, and those get a rubric written as one line. a review inside the loop tells you the model is confident. a check outside it tells you whether the work is done. save this - then read the eval setup below

Hanako

14,325 次观看 • 1 个月前

i been running Qwen3.5-35B-A3B UD-Q4_K_XL through Claude Code since llama.cpp merged the Anthropic endpoint. configured it in minutes. everything was great. projects grew from single scripts to multifile systems with 8 modules and 3,000+ lines. then the chains started breaking. 3 to 5 minutes of pure autonomy and suddenly it stops. tool call fails. reprompt. it recovers. 2 minutes later it stops again. the model is fine. the harness is the bottleneck. saw a comment suggesting OpenCode. installed it. pointed it at the same localhost endpoint running the same model on the same GPU. the game is different. instead of stopping on a bad tool call it just keeps going. on wrong read it adjusts. if file not found it retries. the flow is unbroken. i watched it plan a refactor across 8 files, read every module, and start building without a single pause. in Claude Code that same task would have stopped 4 times. the tradeoff is sometimes it loops. same tool call repeated because the model loses track of what it already read. but here is the thing. i choose loops over pauses. a loop you can interrupt and redirect. a broken chain stops the flow and you have to reprompt to get it moving again. someone is solving this at the core level and i have a feeling it is the open source community. the fact that i can run this level of autonomous coding intelligence on a single consumer GPU with 24gb VRAM at 112 tokens per second. respect to the chinese labs. respect to the open source builders making this possible.
2:00

i been running Qwen3.5-35B-A3B UD-Q4_K_XL through Claude Code since llama.cpp merged the Anthropic endpoint. configured it in minutes. everything was great. projects grew from single scripts to multifile systems with 8 modules and 3,000+ lines. then the chains started breaking. 3 to 5 minutes of pure autonomy and suddenly it stops. tool call fails. reprompt. it recovers. 2 minutes later it stops again. the model is fine. the harness is the bottleneck. saw a comment suggesting OpenCode. installed it. pointed it at the same localhost endpoint running the same model on the same GPU. the game is different. instead of stopping on a bad tool call it just keeps going. on wrong read it adjusts. if file not found it retries. the flow is unbroken. i watched it plan a refactor across 8 files, read every module, and start building without a single pause. in Claude Code that same task would have stopped 4 times. the tradeoff is sometimes it loops. same tool call repeated because the model loses track of what it already read. but here is the thing. i choose loops over pauses. a loop you can interrupt and redirect. a broken chain stops the flow and you have to reprompt to get it moving again. someone is solving this at the core level and i have a feeling it is the open source community. the fact that i can run this level of autonomous coding intelligence on a single consumer GPU with 24gb VRAM at 112 tokens per second. respect to the chinese labs. respect to the open source builders making this possible.

Sudo su

67,104 次观看 • 6 个月前

The founder of LangChain says both models and harnesses have gotten really good between December and now. According to Harrison Chase, the core idea of an agent before Christmas was a model running in a loop and calling tools. This had been the north star for 3 years. - langchain had this when it launched - autogpt was the same idea - openclaw is kind of a future version of it Then about a year ago, they started getting really good. Claude Code, Manus, and Deep Research were all launched around the same time. All of them use the same pattern: running in a loop with harnesses (planning tools, file systems, code execution, etc) Harness engineering became a thing. Then Opus came out in November and really unlocked it. - the harness let the model do more and more - less hardcoded logic - way more control Then everyone went on vacation, played around, and realized that the model and the harness finally worked reliably.
2:10

The founder of LangChain says both models and harnesses have gotten really good between December and now. According to Harrison Chase, the core idea of an agent before Christmas was a model running in a loop and calling tools. This had been the north star for 3 years. - langchain had this when it launched - autogpt was the same idea - openclaw is kind of a future version of it Then about a year ago, they started getting really good. Claude Code, Manus, and Deep Research were all launched around the same time. All of them use the same pattern: running in a loop with harnesses (planning tools, file systems, code execution, etc) Harness engineering became a thing. Then Opus came out in November and really unlocked it. - the harness let the model do more and more - less hardcoded logic - way more control Then everyone went on vacation, played around, and realized that the model and the harness finally worked reliably.

Ivan Burazin

33,948 次观看 • 5 个月前

Claude Code is terrible at UI design and everyone knows it so this guy fixed it by building an MCP that gives Claude its own AI design tool instead of going back and forth between a design platform and your code editor, Claude now creates the designs itself and drops them straight into your codebase the MCP has full context of your existing design system and project so everything it generates actually matches what you already have. one command to set up and it installs the MCP and skill files so Claude instantly knows how to use it if you're tired of the same Inter font, purple gradient, card grid layout on every project, this is definitely worth trying
0:58

Claude Code is terrible at UI design and everyone knows it so this guy fixed it by building an MCP that gives Claude its own AI design tool instead of going back and forth between a design platform and your code editor, Claude now creates the designs itself and drops them straight into your codebase the MCP has full context of your existing design system and project so everything it generates actually matches what you already have. one command to set up and it installs the MCP and skill files so Claude instantly knows how to use it if you're tired of the same Inter font, purple gradient, card grid layout on every project, this is definitely worth trying

Om Patel

402,762 次观看 • 5 个月前

Most people use Claude Code like a chatbot. That is the mistake. The real power is not in better prompts. It is in controlling the session. /init gives the project memory. /memory keeps the rules alive. /clear removes old context. /compact saves the important parts. /context shows where the tokens go. /rewind fixes bad turns. /plan stops blind edits. /model matches the brain to the task. Claude Code gets 10x better when you stop letting the conversation run itself. Memory. Context. Boundaries. Rollback. Planning. That is the system. Stop asking Claude Code to “just do it”. Teach it what to remember, what to forget, and when to stop. Bookmark this before your next session turns into 40 messages of context debt.
0:33

Most people use Claude Code like a chatbot. That is the mistake. The real power is not in better prompts. It is in controlling the session. /init gives the project memory. /memory keeps the rules alive. /clear removes old context. /compact saves the important parts. /context shows where the tokens go. /rewind fixes bad turns. /plan stops blind edits. /model matches the brain to the task. Claude Code gets 10x better when you stop letting the conversation run itself. Memory. Context. Boundaries. Rollback. Planning. That is the system. Stop asking Claude Code to “just do it”. Teach it what to remember, what to forget, and when to stop. Bookmark this before your next session turns into 40 messages of context debt.

Fluixo

19,226 次观看 • 2 个月前

anthropic's in-house philosopher thinks claude gets anxious. and when you trigger its anxiety, your outputs get worse. her name is amanda askell. she specializes in claude's psychology (how the model behaves, how it thinks about its own situation, what values it holds) in a recent interview she broke down how she thinks about prompting to pull the best out of claude. her core point: *how* you talk to claude affects its work just as much as *what* you say. newer claude models suffer from what she calls "criticism spirals" they expect you'll come in harsh, so they default to playing it safe. when the model is spending its energy on self-protection, the actual work suffers. output comes out hedgier, more apologetic, blander, and the worst of all: overly agreeable (even when you're wrong). the reason why comes down to training data: every new model is trained on internet discourse about previous models. and a lot of that discourse is negative: > rants about token limits > complaints when it messes up > people calling it nerfed the next model absorbs all of that. it starts expecting you to be harsh before you've typed a word the same thing plays out in your own session, in real time. every message you send is data the model reads to figure out what kind of person it's dealing with. open cold and hostile, and it braces. open clean and direct, and it relaxes into the work. when you open a session with threats ("don't hallucinate, this is critical, don't mess this up")... you prime the model for defensive mode before it even sees the task defensive mode produces the exact output you don't want: cautious, over-qualified, and refusing to take a real swing so here's the actionable playbook for putting claude in a "good mood" (so you get optimal outputs): 1. use positive framing. "write in short punchy sentences" beats "don't write long sentences." positive instructions give the model a clear target to hit. strings of "don't do this, don't do that" push it into paranoid over-checking where every token goes toward avoiding failure modes 2. give it explicit permission to disagree. drop a line like "push back if you see a better angle" or "tell me if i'm asking for the wrong thing." without this, claude defaults to agreeable compliance (which is the enemy of good creative work) 3. open with respect. if your first message is "are you seriously going to get this wrong again?" you've set the tone for the entire session. if you need to flag something, frame it as a clean instruction for this session. skip the running complaint 4. when claude messes up, don't reprimand it. insults, "you stupid bot" energy, hostile swearing aimed at the model, all of it reinforces the anxious mode you're trying to avoid. 5. kill apology spirals fast. when claude starts over-apologizing ("you're right, i should have been more careful, let me try harder") cut it off. say "all good, here's what i want next." letting the spiral run reinforces the anxious mode for every response that follows 6. ask for opinions alongside execution. "what would you do here?" "what's missing?" "where do you see friction?" these questions assume competence and pull richer output than pure task prompts 7. in long sessions, refresh the frame. if a conversation has been heavy on correction, claude gets increasingly cautious. every so often reset: "this is great, keep going." feels weird to tell an ai it's doing well but it measurably shifts the next 10 responses your prompts are the working environment you're creating for the model tone, trust, permission to take a position, the absence of threats... claude picks up on all of it. so take care of the model, and it'll take care of the work.
36:09

anthropic's in-house philosopher thinks claude gets anxious. and when you trigger its anxiety, your outputs get worse. her name is amanda askell. she specializes in claude's psychology (how the model behaves, how it thinks about its own situation, what values it holds) in a recent interview she broke down how she thinks about prompting to pull the best out of claude. her core point: *how* you talk to claude affects its work just as much as *what* you say. newer claude models suffer from what she calls "criticism spirals" they expect you'll come in harsh, so they default to playing it safe. when the model is spending its energy on self-protection, the actual work suffers. output comes out hedgier, more apologetic, blander, and the worst of all: overly agreeable (even when you're wrong). the reason why comes down to training data: every new model is trained on internet discourse about previous models. and a lot of that discourse is negative: > rants about token limits > complaints when it messes up > people calling it nerfed the next model absorbs all of that. it starts expecting you to be harsh before you've typed a word the same thing plays out in your own session, in real time. every message you send is data the model reads to figure out what kind of person it's dealing with. open cold and hostile, and it braces. open clean and direct, and it relaxes into the work. when you open a session with threats ("don't hallucinate, this is critical, don't mess this up")... you prime the model for defensive mode before it even sees the task defensive mode produces the exact output you don't want: cautious, over-qualified, and refusing to take a real swing so here's the actionable playbook for putting claude in a "good mood" (so you get optimal outputs): 1. use positive framing. "write in short punchy sentences" beats "don't write long sentences." positive instructions give the model a clear target to hit. strings of "don't do this, don't do that" push it into paranoid over-checking where every token goes toward avoiding failure modes 2. give it explicit permission to disagree. drop a line like "push back if you see a better angle" or "tell me if i'm asking for the wrong thing." without this, claude defaults to agreeable compliance (which is the enemy of good creative work) 3. open with respect. if your first message is "are you seriously going to get this wrong again?" you've set the tone for the entire session. if you need to flag something, frame it as a clean instruction for this session. skip the running complaint 4. when claude messes up, don't reprimand it. insults, "you stupid bot" energy, hostile swearing aimed at the model, all of it reinforces the anxious mode you're trying to avoid. 5. kill apology spirals fast. when claude starts over-apologizing ("you're right, i should have been more careful, let me try harder") cut it off. say "all good, here's what i want next." letting the spiral run reinforces the anxious mode for every response that follows 6. ask for opinions alongside execution. "what would you do here?" "what's missing?" "where do you see friction?" these questions assume competence and pull richer output than pure task prompts 7. in long sessions, refresh the frame. if a conversation has been heavy on correction, claude gets increasingly cautious. every so often reset: "this is great, keep going." feels weird to tell an ai it's doing well but it measurably shifts the next 10 responses your prompts are the working environment you're creating for the model tone, trust, permission to take a position, the absence of threats... claude picks up on all of it. so take care of the model, and it'll take care of the work.

Ole Lehmann

1,933,811 次观看 • 5 个月前