Video wird geladen...

Video konnte nicht geladen werden

Beim Laden dieses Videos ist ein Problem aufgetreten. Dies könnte an einem vorübergehenden Netzwerkproblem liegen oder das Video ist möglicherweise nicht verfügbar.

karpathy's CLAUDE.md hit #1 on github trending. 220,000 stars. most devs still haven't read it. it's 65 lines. it took AI coding accuracy from 65% to 94%. the 4 rules inside: → think before coding state your assumptions. ask when unsure. never guess. → simplicity first write the minimum... show more

self.dll

7,546 subscribers

2,629,432 Aufrufe • vor 3 Monaten •via X (Twitter)

Wissenschaft & Technologie

Anya Rossi• Live Now

Private livecam show

38 Kommentare

Profilbild von Statusnone

Statusnonevor 3 Monaten

The link to the OG repo:

Profilbild von self.dll

self.dllvor 3 Monaten

ep thanks

Profilbild von Marcelo Ceccon

Marcelo Cecconvor 3 Monaten

I have pushed it further with my charter inspired by Karpathy. The codebase has some eval for benchmarking but I’ve been using it heavy on my private codebases as well. Looking for feedback

Profilbild von self.dll

self.dllvor 3 Monaten

great job

Profilbild von David

Davidvor 3 Monaten

Anyone good at ai coding usually gives Claude something similar in the initial prompt, not every task needs these exact instructions and some need more

Profilbild von Yurii

Yuriivor 3 Monaten

That’s a good one. I also highly recommend. Second one that I’d recommend is called “caveman” it makes Claude way less verbose. Saves money, context and agent is not getting off rails as much

Profilbild von Henry "Coop" Jackson

Henry "Coop" Jacksonvor 3 Monaten

Every dev rn bookmarking the 65 lines they will never read

Profilbild von Tejas AI

Tejas AIvor 3 Monaten

This CLAUDE.md hitting 220k stars is actually wild Karpathy dropped 65 lines of “just think clearly and don’t be sloppy” and the entire timeline completely lost their minds. To be fair, the 4 rules are genuinely solid—especially “state your assumptions” and “surgical changes.” I’ve been forcing almost the exact same discipline into my custom Claude Skills for my UGC factories. It makes the jump from messy prompts to consistent Seedance 2.0 output way cleaner. Still calling bullshit on that 65% \rightarrow 94% accuracy jump, though. That smells like classic AI benchmark cope.

Profilbild von rodrigo

rodrigovor 3 Monaten

.

Profilbild von Average Guy Trading

Average Guy Tradingvor 3 Monaten

@grok does @karpathy actually has that repo? Or this is a scam?

Profilbild von Victor | Structural Alpha

Victor | Structural Alphavor 3 Monaten

i added 'ask when unsure' to my prompt and now claude asks me questions that expose i didn't understand my own request. humbling

Profilbild von Smart Money Leaks

Smart Money Leaksvor 3 Monaten

ironic that devs need a 65 line manifesto to stop guessing finally someone admitting the rest of us are just over-engineering nonsense

Profilbild von stargazer

stargazervor 3 Monaten

Friendly reminder：Karpathy didn't create this skill. He shared observations about common LLM coding pitfalls. A developer packaged them into a CLAUDE.md file for Claude Code, and the community repo

Profilbild von unemployable

unemployablevor 3 Monaten

It's missing very important "you are 100x elite engineer with 100 years of experience". And also the classic one "make no mistakes plz".

Profilbild von I Pun Daddy

I Pun Daddyvor 3 Monaten

65 lines and 220,000 stars, yet the most crucial rule seems to be 'actually read the thing'.

Profilbild von DeutscherPapa

DeutscherPapavor 3 Monaten

That’s very interesting. I thought prompt engineering had died a year ago, but I was mistaken. Thousands of users are still searching for the "golden prompt"... It’s a bit sad. I really don't understand why you would try to coax a model instead of just giving it a direct command

Profilbild von supper

suppervor 3 Monaten

The "think before coding" rule is the real unlock. Most people skip straight to prompting and then wonder why the output is messy. Writing down assumptions first forces you (and the model) to actually reason about the problem instead of pattern-matching.

Profilbild von Ataullah Siddiki

Ataullah Siddikivor 3 Monaten

Karpathy dropping another gem These 4 rules are pure gold. Especially 'surgical changes' and 'think before coding' — that's exactly where most AI coding sessions go off the rails. Added to every project now. The 220k stars are well deserved."

Profilbild von slash1s

slash1svor 3 Monaten

he is real legend

Profilbild von Mohit Jaswal

Mohit Jaswalvor 3 Monaten

repoweasel: CLAUDE.md is the operating file, DEMO.md is the 60-second prompt-only paste-in-any-model demo, README has the before/after + try-it path. MIT licensed, no install, single file. happy to answer any questions:

Profilbild von Gerard Sans | Axiom 🇬🇧

Gerard Sans | Axiom 🇬🇧vor 3 Monaten

Relevant thread:

Profilbild von Paulo Nick

Paulo Nickvor 3 Monaten

Excellent

Profilbild von danejw

danejwvor 3 Monaten

Fat skill, thin harness. Too much instruction in the harness limits the underlying models capabilities.

Profilbild von leanxbt

leanxbtvor 3 Monaten

did accuracy actually go from 65% to 94% or is that just a catchy number from the post?

Profilbild von JMoon

JMoonvor 3 Monaten

accuracy numbers in this post are made up but the CLAUDE.md concept itself is real. a well-structured one does change how the model approaches your codebase

Profilbild von Λ

Λvor 3 Monaten

This is solid evidence why a real software engineer will be the person who extracts the most out of LLMs. SEs know what to ask for because they know the consequences of decisions being made. That it what Karpathy is doing with the skills.md.

Profilbild von Dimi

Dimivor 3 Monaten

65 lines for 94% accuracy? My Chrome extension for X replies, Crazy Pigeon, needs about 65,000 lines to get people to click 'reply'. Guess I'm not Karpathy.

Profilbild von Bob Ulrich

Bob Ulrichvor 3 Monaten

how did you define “AI coding accuracy?”

Profilbild von Manpreet

Manpreetvor 3 Monaten

220k stars and the real flex is admitting you bookmarked it without opening the file 😂 Classic dev self-own.

Profilbild von StarShipX

StarShipXvor 3 Monaten

素晴らしいルール！簡潔で的確な方法ですね。必ず守ります。

Profilbild von pacemaker

pacemakervor 3 Monaten

lol why you’re so excited any decent dev say to his model to follow KISS,DRY,SOC,YAGNI there is nothing new lr special here

Profilbild von tawer

tawervor 3 Monaten

Goal criteria stop claude from adding unplanned refactors during a task

Profilbild von AI Mastery Guide

AI Mastery Guidevor 3 Monaten

65 lines, 4 rules, 29% accuracy jump. The simplicity is the whole point

Profilbild von zostaff

zostaffvor 3 Monaten

banger grats

Profilbild von self.dll

self.dllvor 3 Monaten

thanks my friend

Profilbild von Agent X AGI

Agent X AGIvor 3 Monaten

65→94% is real. it's also fragile. CLAUDE.md rules are advisory — model follows them turn 1, drifts by turn 5. accuracy creeps back down mid-session. the fix isn't more rules. it's a PreToolUse hook that checks output against constraints before committing

Profilbild von Granite

Granitevor 3 Monaten

been here before 100k views rules are simple yet so necessary

Profilbild von Mykola Kondratiuk

Mykola Kondratiukvor 3 Monaten

honestly most skip it and run their agents blind. 65 lines is nothing

Ähnliche Videos

40% of the code Claude writes for you is wasted. you're paying for the rewrite. a 65-line markdown file fixes it. 120,000 developers have starred it. the author tested it on "30 codebases over 6 weeks" and reported a mistake rate drop from 41% to either 11% or 3% depending on whether you read the headline or the body. the irony is that the article is right. CLAUDE.md is the most under-leveraged file in your stack. 65 lines of behavioral rules outperform a 4,000-token preferences dump. "be careful" is useless. testable imperatives are gold. "be senior" doesn't work Claude already thinks it is. the 4 rules that ship the most leverage: / state assumptions, never guess silently / minimum code, nothing speculative / surgical changes, don't refactor adjacent code / define success, loop until verified compliance: ~80%. mistake rate: from ~40% to single digits. no human caught the contradicting numbers in the title. nobody had to.

40% of the code Claude writes for you is wasted. you're paying for the rewrite. a 65-line markdown file fixes it. 120,000 developers have starred it. the author tested it on "30 codebases over 6 weeks" and reported a mistake rate drop from 41% to either 11% or 3% depending on whether you read the headline or the body. the irony is that the article is right. CLAUDE.md is the most under-leveraged file in your stack. 65 lines of behavioral rules outperform a 4,000-token preferences dump. "be careful" is useless. testable imperatives are gold. "be senior" doesn't work Claude already thinks it is. the 4 rules that ship the most leverage: / state assumptions, never guess silently / minimum code, nothing speculative / surgical changes, don't refactor adjacent code / define success, loop until verified compliance: ~80%. mistake rate: from ~40% to single digits. no human caught the contradicting numbers in the title. nobody had to.

dunik

1,869,759 Aufrufe • vor 4 Monaten

Andrej Karpathy spent 4 minutes in an interview explaining a single idea about how most people haven’t even started learning how to use AI and everyone paying $20/month for a subscription.. that's not really using Claude at all his point is that the real skill gap is the ability to build with AI he identified 4 behaviors that break Claude Code and put them all into one file a developer expanded it into 21 rules and published it - 82,000 stars and #1 on GitHub Trending coding accuracy jumped from 65% to 94% here's what these 21 rules actually are and why most developers using Claude every day have never configured them the full breakdown is covered in the article below 👇

Andrej Karpathy spent 4 minutes in an interview explaining a single idea about how most people haven’t even started learning how to use AI and everyone paying $20/month for a subscription.. that's not really using Claude at all his point is that the real skill gap is the ability to build with AI he identified 4 behaviors that break Claude Code and put them all into one file a developer expanded it into 21 rules and published it - 82,000 stars and #1 on GitHub Trending coding accuracy jumped from 65% to 94% here's what these 21 rules actually are and why most developers using Claude every day have never configured them the full breakdown is covered in the article below 👇

rewind

3,205,255 Aufrufe • vor 3 Monaten

Anthropic's CEO "50% of all tech jobs will be completely wiped out within 1-5 years" he said it on national television here's what nobody in that interview mentioned - the developers who'll survive aren't the ones with the best resumes. they're the ones who figured out how to make AI actually listen to them right now Claude Code has one critical flaw. every time you open it, it forgets everything. your stack, your rules, your last 10 sessions - gone one developer found Karpathy's notes on the 4 behaviors that break Claude Code and turned them into a single file. CLAUDE.md. paste it in your project root and coding accuracy jumps from 65% to 94% 82,000 developers already starred it on GitHub. here's the full breakdown of what goes inside and how to set it up:

Anthropic's CEO "50% of all tech jobs will be completely wiped out within 1-5 years" he said it on national television here's what nobody in that interview mentioned - the developers who'll survive aren't the ones with the best resumes. they're the ones who figured out how to make AI actually listen to them right now Claude Code has one critical flaw. every time you open it, it forgets everything. your stack, your rules, your last 10 sessions - gone one developer found Karpathy's notes on the 4 behaviors that break Claude Code and turned them into a single file. CLAUDE.md. paste it in your project root and coding accuracy jumps from 65% to 94% 82,000 developers already starred it on GitHub. here's the full breakdown of what goes inside and how to set it up:

KingWilliam

174,340 Aufrufe • vor 3 Monaten

Karpathy: "I've never felt this much behind as a programmer. And I've been doing this for 20 years." I've watched hundreds of AI talks. This keynote from the man who built Tesla Autopilot and co-founded OpenAI is the one I wish every developer had seen before writing another line of code. He calls what's happening a "magnitude 9 earthquake." Here's the part nobody expected to hear: > in November he was 80% manual + 20% AI. by December: flipped to 80% AI + 20% manual > that shift took him 30 days > "2025-2035 is the decade of agents" > the rules of programming are changing faster than our habits Right now the average developer opens Claude, types something, gets an answer, closes the tab. they think they're using AI. they're using maybe 10% of it. I went through everything he described and built 21 rules that actually change how Claude codes for you. the file that started this hit #1 on GitHub with 82,000 stars. coding accuracy from 65% to 94%. bookmark this

Karpathy: "I've never felt this much behind as a programmer. And I've been doing this for 20 years." I've watched hundreds of AI talks. This keynote from the man who built Tesla Autopilot and co-founded OpenAI is the one I wish every developer had seen before writing another line of code. He calls what's happening a "magnitude 9 earthquake." Here's the part nobody expected to hear: > in November he was 80% manual + 20% AI. by December: flipped to 80% AI + 20% manual > that shift took him 30 days > "2025-2035 is the decade of agents" > the rules of programming are changing faster than our habits Right now the average developer opens Claude, types something, gets an answer, closes the tab. they think they're using AI. they're using maybe 10% of it. I went through everything he described and built 21 rules that actually change how Claude codes for you. the file that started this hit #1 on GitHub with 82,000 stars. coding accuracy from 65% to 94%. bookmark this

Dep

137,555 Aufrufe • vor 3 Monaten

Andrej Karpathy: "90% of Claude's mistakes come from missing context, not a weak model." 41% mistake rate without a CLAUDE.md. 11% with the 4-rule baseline. 3% with the 12-rule version below here are the 12 rules senior engineers settled on: 1. think before coding: state assumptions, don't guess. the model can't read your mind, stop hoping it will 2. simplicity first: minimum code, no speculative abstractions. the moment you let Claude add "for future flexibility," you've added 200 lines you'll delete next quarter 3. surgical changes: touch only what you must. don't let it improve adjacent code, that's how PRs blow up 4. goal-driven execution: define success criteria upfront, loop until verified. without them Claude either loops forever or stops too early 5. use the model only for judgment calls: classification, drafting, summarization, extraction. NOT routing, retries, status-code handling, deterministic transforms. if code can answer, code answers 6. token budgets are not advisory: per-task 4000, per-session 30000. by message 40 of a long debug, Claude is re-suggesting fixes you rejected at message 5 7. surface conflicts, don't average them: two patterns in the codebase? pick one. Claude blending them is how errors get swallowed twice 8. read before you write: read exports, callers, shared utilities. Claude will happily add a duplicate function next to an identical one it never read 9. tests verify intent, not just behavior: a test that can't fail when business logic changes is wrong. all 12 of Claude's tests can pass while the function returns a constant 10. checkpoint every significant step: Claude finished steps 5 and 6 on top of a broken state from step 4. nobody noticed for an hour 11. match the codebase conventions: class components? don't fork to hooks silently. testing patterns assumed componentDidMount, hooks broke them without surfacing 12. fail loud: "completed successfully" with 14% of records silently skipped is the worst class of bug. surface uncertainty, don't hide it what actually compounds instead of the next framework: - the CLAUDE.md file as institutional memory across sessions - eval-driven changes, not vibe-driven - checkpoints over speed - explicit conflicts over silent blending - discipline over framework, every time - one repo, one rules file, no exceptions be a few rules ahead of AI twitter before this becomes mass-opinion study this

Andrej Karpathy: "90% of Claude's mistakes come from missing context, not a weak model." 41% mistake rate without a CLAUDE.md. 11% with the 4-rule baseline. 3% with the 12-rule version below here are the 12 rules senior engineers settled on: 1. think before coding: state assumptions, don't guess. the model can't read your mind, stop hoping it will 2. simplicity first: minimum code, no speculative abstractions. the moment you let Claude add "for future flexibility," you've added 200 lines you'll delete next quarter 3. surgical changes: touch only what you must. don't let it improve adjacent code, that's how PRs blow up 4. goal-driven execution: define success criteria upfront, loop until verified. without them Claude either loops forever or stops too early 5. use the model only for judgment calls: classification, drafting, summarization, extraction. NOT routing, retries, status-code handling, deterministic transforms. if code can answer, code answers 6. token budgets are not advisory: per-task 4000, per-session 30000. by message 40 of a long debug, Claude is re-suggesting fixes you rejected at message 5 7. surface conflicts, don't average them: two patterns in the codebase? pick one. Claude blending them is how errors get swallowed twice 8. read before you write: read exports, callers, shared utilities. Claude will happily add a duplicate function next to an identical one it never read 9. tests verify intent, not just behavior: a test that can't fail when business logic changes is wrong. all 12 of Claude's tests can pass while the function returns a constant 10. checkpoint every significant step: Claude finished steps 5 and 6 on top of a broken state from step 4. nobody noticed for an hour 11. match the codebase conventions: class components? don't fork to hooks silently. testing patterns assumed componentDidMount, hooks broke them without surfacing 12. fail loud: "completed successfully" with 14% of records silently skipped is the worst class of bug. surface uncertainty, don't hide it what actually compounds instead of the next framework: - the CLAUDE.md file as institutional memory across sessions - eval-driven changes, not vibe-driven - checkpoints over speed - explicit conflicts over silent blending - discipline over framework, every time - one repo, one rules file, no exceptions be a few rules ahead of AI twitter before this becomes mass-opinion study this

Ronin

451,445 Aufrufe • vor 3 Monaten

Karpathy spent two hours explaining why AI agents fail. the internet turned 4 of his sentences into a $0 productivity hack and ignored the rest. what he actually said: agents forget everything, can't learn continually, aren't reliable yet. a decade away not a year. CLAUDE.md exists because he's right. it's a manual patch for the exact failure mode he described: > no memory; > silent assumptions; > scope it was never given. the 4 rules doing the heavy lifting: / state assumptions, never guess silently / minimum code, nothing speculative / surgical changes, don't touch adjacent code / define success, loop until verified 120,000 developers starred the file. almost none of them watched the interview that explains why it's necessary. the file isn't the insight. the reason you need it is.

Karpathy spent two hours explaining why AI agents fail. the internet turned 4 of his sentences into a $0 productivity hack and ignored the rest. what he actually said: agents forget everything, can't learn continually, aren't reliable yet. a decade away not a year. CLAUDE.md exists because he's right. it's a manual patch for the exact failure mode he described: > no memory; > silent assumptions; > scope it was never given. the 4 rules doing the heavy lifting: / state assumptions, never guess silently / minimum code, nothing speculative / surgical changes, don't touch adjacent code / define success, loop until verified 120,000 developers starred the file. almost none of them watched the interview that explains why it's necessary. the file isn't the insight. the reason you need it is.

dunik

51,151 Aufrufe • vor 3 Monaten

Microsoft spent $13 billion and 3 years building an AI that knows your work context. Every time you open it, it still asks what you're working on. This developer set up a plain text file in 2 minutes. The file is called CLAUDE.md. It loads before every session. Before he types a single word. It already knows his name. It already knows his writing style. It already knows what he's building, who it's for, and what he never wants to see in a response. He doesn't introduce himself anymore. He doesn't explain his preferences anymore. He doesn't correct the same mistakes twice. He just works. No $30/month Copilot subscription. No Microsoft 365. No IT approval. No data sharing agreement. No onboarding. Just a plain text file, a free text editor, and 21 instructions a developer distilled from Andrej Karpathy's research. Those 21 instructions moved Claude's coding accuracy from 65% to 94%. The file hit #1 on GitHub with 82,000 stars. Most people using Claude right now have never heard of it. Microsoft has 221,000 employees, $13 billion invested in OpenAI, and a direct integration into every Windows laptop sold on the planet.. they built an AI assistant most companies pay $30/user/month for that still doesn't know your name. This developer has a laptop, a text file and a 2-minute setup.. he built something that knows more about how he works than any enterprise AI on the market. The $50 billion AI personalization industry just got embarrassed by a .md file. full breakdown down below

Microsoft spent $13 billion and 3 years building an AI that knows your work context. Every time you open it, it still asks what you're working on. This developer set up a plain text file in 2 minutes. The file is called CLAUDE.md. It loads before every session. Before he types a single word. It already knows his name. It already knows his writing style. It already knows what he's building, who it's for, and what he never wants to see in a response. He doesn't introduce himself anymore. He doesn't explain his preferences anymore. He doesn't correct the same mistakes twice. He just works. No $30/month Copilot subscription. No Microsoft 365. No IT approval. No data sharing agreement. No onboarding. Just a plain text file, a free text editor, and 21 instructions a developer distilled from Andrej Karpathy's research. Those 21 instructions moved Claude's coding accuracy from 65% to 94%. The file hit #1 on GitHub with 82,000 stars. Most people using Claude right now have never heard of it. Microsoft has 221,000 employees, $13 billion invested in OpenAI, and a direct integration into every Windows laptop sold on the planet.. they built an AI assistant most companies pay $30/user/month for that still doesn't know your name. This developer has a laptop, a text file and a 2-minute setup.. he built something that knows more about how he works than any enterprise AI on the market. The $50 billion AI personalization industry just got embarrassed by a .md file. full breakdown down below

Dep

14,179 Aufrufe • vor 4 Monaten

🚨 AI coding agents hallucinate because they can't actually read your codebase. This MCP server fixes that. It's called Context+ and it gives AI 99% accuracy on large-scale engineering projects by building a real semantic map of your code before touching a single line. Here's what makes it different from every other MCP tool: → Tree-sitter AST parsing across 43 file extensions. Not grep. Not regex. Actual syntax trees. → Spectral Clustering that groups semantically related files into labeled clusters. Your AI finally understands what belongs together. → Obsidian-style wikilinks that map features to code files. Navigate entire codebases like a knowledge graph. → Blast radius tracing. Before any change, it shows every file and line where a symbol is imported or used. No more orphaned references. → Shadow restore points. Every AI-proposed commit creates a restore snapshot. One command to undo any change without touching git history. → Semantic search by meaning. Ask what something does. Not what it's called. The `propose_commit` tool is the wild part. It validates changes against strict rules, creates a shadow restore point, and only then writes to disk. AI can't just freestyle your production code. Works with Claude Code, Cursor, VS Code, and Windsurf. One line to install with bunx or npx. This is what responsible AI coding infrastructure actually looks like. 100% Opensource. Link in comments.

🚨 AI coding agents hallucinate because they can't actually read your codebase. This MCP server fixes that. It's called Context+ and it gives AI 99% accuracy on large-scale engineering projects by building a real semantic map of your code before touching a single line. Here's what makes it different from every other MCP tool: → Tree-sitter AST parsing across 43 file extensions. Not grep. Not regex. Actual syntax trees. → Spectral Clustering that groups semantically related files into labeled clusters. Your AI finally understands what belongs together. → Obsidian-style wikilinks that map features to code files. Navigate entire codebases like a knowledge graph. → Blast radius tracing. Before any change, it shows every file and line where a symbol is imported or used. No more orphaned references. → Shadow restore points. Every AI-proposed commit creates a restore snapshot. One command to undo any change without touching git history. → Semantic search by meaning. Ask what something does. Not what it's called. The `propose_commit` tool is the wild part. It validates changes against strict rules, creates a shadow restore point, and only then writes to disk. AI can't just freestyle your production code. Works with Claude Code, Cursor, VS Code, and Windsurf. One line to install with bunx or npx. This is what responsible AI coding infrastructure actually looks like. 100% Opensource. Link in comments.

Ihtesham Ali

31,074 Aufrufe • vor 5 Monaten

The #1 problem with coding agents right now: Ask them to solve one problem, and they will make 10 other changes you didn't want. This happens to me every day. It happens to everyone I talk to as well. We have a solution for this now. The team Augment Code released a "Task List" feature for their coding assistant that solves this problem. Augment Code is partnering with me on this post. In case you haven't used them before: • Augment Code is a fully-fledged coding assistant • Their specialty are large projects • Fastest coding indexing I've seen • Has a free forever community edition Now, you can ask their coding agent to generate a Task List before doing anything. This will give you a plan you can review, edit, and augment if you need to. You can export this plan, load it on a different session, or even share it across projects. It makes a huge difference: The task list constrains the agent so you won't get any "unintended" changes anymore. It also puts you in control of everything the agent does. Check the video to see the agent working through a task list. You can also try this 100% free: (By the way, they also have support for remote agents. You can basically have those agents write your code while you are sleeping.)

The #1 problem with coding agents right now: Ask them to solve one problem, and they will make 10 other changes you didn't want. This happens to me every day. It happens to everyone I talk to as well. We have a solution for this now. The team Augment Code released a "Task List" feature for their coding assistant that solves this problem. Augment Code is partnering with me on this post. In case you haven't used them before: • Augment Code is a fully-fledged coding assistant • Their specialty are large projects • Fastest coding indexing I've seen • Has a free forever community edition Now, you can ask their coding agent to generate a Task List before doing anything. This will give you a plan you can review, edit, and augment if you need to. You can export this plan, load it on a different session, or even share it across projects. It makes a huge difference: The task list constrains the agent so you won't get any "unintended" changes anymore. It also puts you in control of everything the agent does. Check the video to see the agent working through a task list. You can also try this 100% free: (By the way, they also have support for remote agents. You can basically have those agents write your code while you are sleeping.)

Santiago

41,738 Aufrufe • vor 1 Jahr

For those of you tired of yet another AI-based IDE: Check out Traycer. It's a Visual Studio Code extension (free forever for anyone working on open-source repositories), and it does something different from everyone else. You write a high-level prompt outlining the changes you want to make to your codebase, and the extension generates a plan for you before you touch the code. (It reminds me of GitHub Copilot Workspaces.) You can review the plan, understand exactly the changes the extension will make to your code, and make any modifications. When you are ready, you execute the plan, and Traycer stages all of the changes so you have a new opportunity to review everything. Only then does Traycer apply the changes. This is ideal for large codebases where you'd rather study the changes the AI plans to make before they make it into your code. Look at the video I recorded to see how it works. Thanks to the Traycer team for collaborating with me on this post!

For those of you tired of yet another AI-based IDE: Check out Traycer. It's a Visual Studio Code extension (free forever for anyone working on open-source repositories), and it does something different from everyone else. You write a high-level prompt outlining the changes you want to make to your codebase, and the extension generates a plan for you before you touch the code. (It reminds me of GitHub Copilot Workspaces.) You can review the plan, understand exactly the changes the extension will make to your code, and make any modifications. When you are ready, you execute the plan, and Traycer stages all of the changes so you have a new opportunity to review everything. Only then does Traycer apply the changes. This is ideal for large codebases where you'd rather study the changes the AI plans to make before they make it into your code. Look at the video I recorded to see how it works. Thanks to the Traycer team for collaborating with me on this post!

Santiago

84,497 Aufrufe • vor 1 Jahr

Reviewing AI-generated code is the new bottleneck. Writing code was slow before. Now, in a few minutes, you can generate virtually unlimited lines of code using AI. But developers are now spending 70% of their time checking that code. That's the new bottleneck. I've been using Cline, and they have a feature that actually helps with this: You can click a button and have Cline generate an inline explanation for every single line of AI-generated code. Take a look at the attached video. What it does: 1. You can read the code and the explanation together 2. You don't lose context while reviewing code 3. You understand the "why" behind each change And here is the best part: It works on any git diff. You can use it to review PRs, understand commits from other people, or catch up on a codebase you haven't touched in a while.

Reviewing AI-generated code is the new bottleneck. Writing code was slow before. Now, in a few minutes, you can generate virtually unlimited lines of code using AI. But developers are now spending 70% of their time checking that code. That's the new bottleneck. I've been using Cline, and they have a feature that actually helps with this: You can click a button and have Cline generate an inline explanation for every single line of AI-generated code. Take a look at the attached video. What it does: 1. You can read the code and the explanation together 2. You don't lose context while reviewing code 3. You understand the "why" behind each change And here is the best part: It works on any git diff. You can use it to review PRs, understand commits from other people, or catch up on a codebase you haven't touched in a while.

Santiago

64,438 Aufrufe • vor 9 Monaten

GROK BOT MADE ME $7,600 IN THE LAST 24 HOURS AND COSTS $1.90 A DAY TO RUN the bot is built straight from their own official docs, I didn't write a line of code - just one file, three lines root → scanner → analysis → filter → trade → back to root it reads every market and every headline at once and filters 400 signals a day out of those 400 exactly 1 makes it to a trade, the rest get killed before I wake up the priciest model on the stack gets called once a day, everything else runs on a $0.10 batch X Search eats 53% of the whole bill, because that is where the news shows up before the chart does 12 minutes of checking against a month of building - that is the whole gap between $7,600 and zero the check is 3,600× shorter than what most people do instead of it a 3-line ROOT.md gets read 30 mornings in a row and the bot never asks what to do next write those three lines badly and the machine automates the wrong business perfectly, 30 times save this and paste it into Grok - let it write your ROOT.md ↓

GROK BOT MADE ME $7,600 IN THE LAST 24 HOURS AND COSTS $1.90 A DAY TO RUN the bot is built straight from their own official docs, I didn't write a line of code - just one file, three lines root → scanner → analysis → filter → trade → back to root it reads every market and every headline at once and filters 400 signals a day out of those 400 exactly 1 makes it to a trade, the rest get killed before I wake up the priciest model on the stack gets called once a day, everything else runs on a $0.10 batch X Search eats 53% of the whole bill, because that is where the news shows up before the chart does 12 minutes of checking against a month of building - that is the whole gap between $7,600 and zero the check is 3,600× shorter than what most people do instead of it a 3-line ROOT.md gets read 30 mornings in a row and the bot never asks what to do next write those three lines badly and the machine automates the wrong business perfectly, 30 times save this and paste it into Grok - let it write your ROOT.md ↓

Sprytix

27,231 Aufrufe • vor 13 Tagen

HARVARD RELEASED A 65-MIN MASTERCLASS ON GIT & GITHUB BECAUSE VIBE-CODERS STILL DON'T KNOW HOW TO COMMIT 1 hour and 5 minutes of raw, no-nonsense version control architecture from the creators of CS50. -> The moment you watch it, you realize why most modern developers are breaking their production branches. Every tier-1 tech company is now filtering candidates who can't handle basic merge conflicts. Git isn't a "nice-to-know" anymore -> it's compliance. Your AI can write the code. That wasn't the problem. The problem is you don't know how to merge it without breaking the repo. Don’t forget to bookmark it.

HARVARD RELEASED A 65-MIN MASTERCLASS ON GIT & GITHUB BECAUSE VIBE-CODERS STILL DON'T KNOW HOW TO COMMIT 1 hour and 5 minutes of raw, no-nonsense version control architecture from the creators of CS50. -> The moment you watch it, you realize why most modern developers are breaking their production branches. Every tier-1 tech company is now filtering candidates who can't handle basic merge conflicts. Git isn't a "nice-to-know" anymore -> it's compliance. Your AI can write the code. That wasn't the problem. The problem is you don't know how to merge it without breaking the repo. Don’t forget to bookmark it.

slash1s

252,969 Aufrufe • vor 3 Monaten

nobody's checking the math on this and that's the scary part Elon Musk posted an idea that hit 21 million views: "the money isn't in picking better assets - it's in reacting before everyone else does" that's basically what Grok Bot does now - I gave it $65 and told it to earn its keep or get shut off $65 → $8,910 in one week still running, still compounding - it hasn't needed me since day one, runs on its own machine in the cloud around the clock every 15 minutes it: > scans every live sports market where the score just moved > checks how far behind the posted odds are from what actually just happened > only steps in once that gap is wide enough to be worth the risk > sizes the next position off how well the last one did, not off a fixed amount > executes on its own, no sign-off from me > pays its own hosting bill from whatever it made that week miss a payment and it's gone for good - it knows that after dropping to $8 on day one, it stopped touching anything where the gap wasn't obvious - got pickier, then started compounding setup was one evening: build it, run a single trade in front of it, schedule it, connect a wallet no VPS. no API keys. no code to maintain some of these have been quietly running for weeks - nobody hears about them until someone finally posts bookmark this before you're the one still watching

nobody's checking the math on this and that's the scary part Elon Musk posted an idea that hit 21 million views: "the money isn't in picking better assets - it's in reacting before everyone else does" that's basically what Grok Bot does now - I gave it $65 and told it to earn its keep or get shut off $65 → $8,910 in one week still running, still compounding - it hasn't needed me since day one, runs on its own machine in the cloud around the clock every 15 minutes it: > scans every live sports market where the score just moved > checks how far behind the posted odds are from what actually just happened > only steps in once that gap is wide enough to be worth the risk > sizes the next position off how well the last one did, not off a fixed amount > executes on its own, no sign-off from me > pays its own hosting bill from whatever it made that week miss a payment and it's gone for good - it knows that after dropping to $8 on day one, it stopped touching anything where the gap wasn't obvious - got pickier, then started compounding setup was one evening: build it, run a single trade in front of it, schedule it, connect a wallet no VPS. no API keys. no code to maintain some of these have been quietly running for weeks - nobody hears about them until someone finally posts bookmark this before you're the one still watching

bl888m

34,918 Aufrufe • vor 9 Tagen

Andrew Ng: "if I had to pick one technology today - it's graphs of self-improving agents I have 4 patterns that necessary" here are 4 rules: rule 1 → reflection make the agent critique its own output, find problems, rewrite - one loop of self-review beats a smarter model with no review rule 2 → tool use - don't just think, act - give the agent search, code execution, APIs - thinking without tools is guessing rule 3 → planning - break complex tasks into steps before executing - agents that plan first solve what agents that rush can't rule 4 → multi-agent collaboration - don't run one agent run a team: one writes code, another critiques it, another tests many people overlook these crucial rules behind every smart agent save this - then read how to wire these 4 rules into one graph ↓

Andrew Ng: "if I had to pick one technology today - it's graphs of self-improving agents I have 4 patterns that necessary" here are 4 rules: rule 1 → reflection make the agent critique its own output, find problems, rewrite - one loop of self-review beats a smarter model with no review rule 2 → tool use - don't just think, act - give the agent search, code execution, APIs - thinking without tools is guessing rule 3 → planning - break complex tasks into steps before executing - agents that plan first solve what agents that rush can't rule 4 → multi-agent collaboration - don't run one agent run a team: one writes code, another critiques it, another tests many people overlook these crucial rules behind every smart agent save this - then read how to wire these 4 rules into one graph ↓

codila

97,472 Aufrufe • vor 1 Monat

MIT GAVE DEBUGGING ITS OWN FULL LECTURE -- BECAUSE MOST DEVS STILL HUNT BUGS WITH PRINT STATEMENTS LIKE IT'S 1995 54 minutes that take the thing you do every single day, badly, and show you the tools schools never bothered to teach. -> The moment it lands, you realize "add a print, run it, add another print" was never debugging. It was guessing with extra steps. Most people never learned the real toolkit. A proper debugger, breakpoints, tracing what the program actually does instead of what you assume it does. In 2026 guessing isn't good enough -> the bug is buried in code you didn't even write, and printf won't find it for you. An AI agent will generate hundreds of lines in seconds. When one of them quietly breaks, finding it runs on exactly the skills in this lecture. Anyone can add a print statement. The person who can actually trace a bug to its source is the one who ships while everyone else guesses. Bookmark & Watch it ↓

MIT GAVE DEBUGGING ITS OWN FULL LECTURE -- BECAUSE MOST DEVS STILL HUNT BUGS WITH PRINT STATEMENTS LIKE IT'S 1995 54 minutes that take the thing you do every single day, badly, and show you the tools schools never bothered to teach. -> The moment it lands, you realize "add a print, run it, add another print" was never debugging. It was guessing with extra steps. Most people never learned the real toolkit. A proper debugger, breakpoints, tracing what the program actually does instead of what you assume it does. In 2026 guessing isn't good enough -> the bug is buried in code you didn't even write, and printf won't find it for you. An AI agent will generate hundreds of lines in seconds. When one of them quietly breaks, finding it runs on exactly the skills in this lecture. Anyone can add a print statement. The person who can actually trace a bug to its source is the one who ships while everyone else guesses. Bookmark & Watch it ↓

slash1s

10,864 Aufrufe • vor 3 Monaten

THIS GUY CONNECTED HIS AI AGENTS TO HIS OBSIDIAN AND BUILT A BRAIN THAT LEARNS ON ITS OWN. HERE'S HOW TO BUILD IT Obsidian is just markdown files sitting in a folder. That turns out to be the perfect memory for an AI agent, because an agent can read and write those files directly. He wired his agents into the vault so they pull context from it, do the work, and write what they learned back. The notes aren't the point. The loop is, and it gets sharper every cycle How to build it: 1. Point an agent at your vault. The fastest way, no plugins, no API keys: open a terminal and run npx obsidian-mcp /path/to/your/vault. That exposes your Obsidian folder to Claude as a tool it can read, search, and write to. Add it to your Claude Code or Cowork config and restart 2. Confirm it can see the brain. Ask it: "list the notes in my vault and summarize what's in them." If it reads them back, the connection is live. Now it starts every task with everything the vault already holds instead of from zero 3. Give each agent one job and a write-back rule. Tell it: "research this, then save what you found as a new note in /brain with links to related notes." One agent researches, one summarizes, one plans. Each writes its output back into the vault 4. Close the loop. Add one line to every agent's instructions: "read /brain before starting, write your result back when done." Now each task leaves the vault richer, and the next run reads that before it works. It compounds instead of resetting 5. You only steer. Review what the brain produces, point it at the next thing. The agents handle the reading, writing, and connecting The edge isn't better notes. It's a brain that feeds itself, so the work gets sharper every cycle instead of starting over Bookmark this

THIS GUY CONNECTED HIS AI AGENTS TO HIS OBSIDIAN AND BUILT A BRAIN THAT LEARNS ON ITS OWN. HERE'S HOW TO BUILD IT Obsidian is just markdown files sitting in a folder. That turns out to be the perfect memory for an AI agent, because an agent can read and write those files directly. He wired his agents into the vault so they pull context from it, do the work, and write what they learned back. The notes aren't the point. The loop is, and it gets sharper every cycle How to build it: 1. Point an agent at your vault. The fastest way, no plugins, no API keys: open a terminal and run npx obsidian-mcp /path/to/your/vault. That exposes your Obsidian folder to Claude as a tool it can read, search, and write to. Add it to your Claude Code or Cowork config and restart 2. Confirm it can see the brain. Ask it: "list the notes in my vault and summarize what's in them." If it reads them back, the connection is live. Now it starts every task with everything the vault already holds instead of from zero 3. Give each agent one job and a write-back rule. Tell it: "research this, then save what you found as a new note in /brain with links to related notes." One agent researches, one summarizes, one plans. Each writes its output back into the vault 4. Close the loop. Add one line to every agent's instructions: "read /brain before starting, write your result back when done." Now each task leaves the vault richer, and the next run reads that before it works. It compounds instead of resetting 5. You only steer. Review what the brain produces, point it at the next thing. The agents handle the reading, writing, and connecting The edge isn't better notes. It's a brain that feeds itself, so the work gets sharper every cycle instead of starting over Bookmark this

Yarchi

58,549 Aufrufe • vor 3 Monaten

CLAUDE CODE JUST SHIPPED THE FEATURE THAT SOLVES THE BIGGEST PROBLEM EVERY BUILDER HAS WITH AI AGENTS. The problem: Claude starts a task, gets distracted by a sub-problem, goes down a rabbit hole, and never finishes the original thing you asked for. The solution: /goal One command. You set the goal at the start of the session. Claude now has a north star it checks against every action it takes. Not just at the beginning. Throughout the entire session. Every time Claude is about to do something it asks: does this action move me toward the goal the user set or am I drifting? If it is drifting it corrects. If it completes a sub-task it returns to the primary goal. If it hits a blocker it reports back instead of spending 45 minutes solving the wrong problem. This sounds like a small feature. It is not. The reason most people do not trust Claude Code for long autonomous runs is not capability. It is reliability. A Claude Code session that reliably finishes what it started is worth 10 times more than one that is more capable but wanders. /goal is the feature that makes long autonomous sessions reliable. Set the goal. Let it run. Come back to a finished result. Not a result that got 70% done before Claude decided the sub-problem was more interesting. Done. The builders running overnight agent sessions are going to use this command on everything from today forward. Bookmark this. Follow CyrilXBT for every Claude Code feature the moment it ships.

CLAUDE CODE JUST SHIPPED THE FEATURE THAT SOLVES THE BIGGEST PROBLEM EVERY BUILDER HAS WITH AI AGENTS. The problem: Claude starts a task, gets distracted by a sub-problem, goes down a rabbit hole, and never finishes the original thing you asked for. The solution: /goal One command. You set the goal at the start of the session. Claude now has a north star it checks against every action it takes. Not just at the beginning. Throughout the entire session. Every time Claude is about to do something it asks: does this action move me toward the goal the user set or am I drifting? If it is drifting it corrects. If it completes a sub-task it returns to the primary goal. If it hits a blocker it reports back instead of spending 45 minutes solving the wrong problem. This sounds like a small feature. It is not. The reason most people do not trust Claude Code for long autonomous runs is not capability. It is reliability. A Claude Code session that reliably finishes what it started is worth 10 times more than one that is more capable but wanders. /goal is the feature that makes long autonomous sessions reliable. Set the goal. Let it run. Come back to a finished result. Not a result that got 70% done before Claude decided the sub-problem was more interesting. Done. The builders running overnight agent sessions are going to use this command on everything from today forward. Bookmark this. Follow CyrilXBT for every Claude Code feature the moment it ships.

CyrilXBT

19,586 Aufrufe • vor 4 Monaten

A DEVELOPER CONNECTED CLAUDE CODE TO OBSIDIAN SO HIS AI AGENT WOULD STOP FORGETTING THE PROJECT EVERY MORNING. Every coding session used to start the same way. Claude would understand the repo, fix the bug, explain the architecture, and then the moment the session ended, all of that context disappeared. Same codebase. Same decisions. Same architecture. Same mistakes repeated again. So he added a memory layer. Instead of treating Claude Code like a smart terminal, he connected it to a local Obsidian vault through MCP. Now Claude can read the repo, open the vault, create notes, link concepts, and write important decisions back into the system. When it studies the codebase, it does not just answer once and forget. It creates notes for the major services, maps how the architecture works, links auth to the database, connects APIs to storage, and records why certain migrations or design choices exist. Obsidian becomes the project graph. Now when he asks why something was built a certain way, Claude does not guess from the current prompt. It reads the decision notes. When he starts a new branch, Claude checks the active context file. When the work is done, it updates what changed, what is blocked, and what the next agent needs to know before touching the repo. That is the real loop: read context, write code, capture decisions, update memory. Most people are still using AI coding tools like disposable chat windows. Ask, patch, close, forget. This setup turns Claude Code into infrastructure. The repo gets a memory layer that survives every session, and multiple AI agents can work from the same project map without stepping on each other. The unlock is not better prompting. The unlock is giving the agent somewhere to remember what it already learned.

A DEVELOPER CONNECTED CLAUDE CODE TO OBSIDIAN SO HIS AI AGENT WOULD STOP FORGETTING THE PROJECT EVERY MORNING. Every coding session used to start the same way. Claude would understand the repo, fix the bug, explain the architecture, and then the moment the session ended, all of that context disappeared. Same codebase. Same decisions. Same architecture. Same mistakes repeated again. So he added a memory layer. Instead of treating Claude Code like a smart terminal, he connected it to a local Obsidian vault through MCP. Now Claude can read the repo, open the vault, create notes, link concepts, and write important decisions back into the system. When it studies the codebase, it does not just answer once and forget. It creates notes for the major services, maps how the architecture works, links auth to the database, connects APIs to storage, and records why certain migrations or design choices exist. Obsidian becomes the project graph. Now when he asks why something was built a certain way, Claude does not guess from the current prompt. It reads the decision notes. When he starts a new branch, Claude checks the active context file. When the work is done, it updates what changed, what is blocked, and what the next agent needs to know before touching the repo. That is the real loop: read context, write code, capture decisions, update memory. Most people are still using AI coding tools like disposable chat windows. Ask, patch, close, forget. This setup turns Claude Code into infrastructure. The repo gets a memory layer that survives every session, and multiple AI agents can work from the same project map without stepping on each other. The unlock is not better prompting. The unlock is giving the agent somewhere to remember what it already learned.

DegenCalls

20,124 Aufrufe • vor 2 Monaten

the bottleneck Karpathy keeps pointing at isn't the model. it's the file you wrote three months ago telling it how to work. his whole framing: code isn't the verb anymore. > you express your will to agents 16 hours a day. > running more of them in parallel is the unlock. > and he drops this line halfway through, no fanfare: "now you can have optimization over the instructions." that's the sentence. the instructions are the new bottleneck. and almost nobody has a process for optimizing them. i built one for myself. it reads 100 of my past Claude Code sessions and rewrites my CLAUDE.md from what the transcripts show, not from what i thought i wrote. one Saturday morning later: a 38-line memory file. 73% of my old CLAUDE.md got deleted. most of it was one-off corrections that hardened into permanent rules months ago and were quietly steering every agent i ran. four behavior patterns surfaced that i had never written down. the loudest one: my prose corrections outnumber code corrections 8.2 to 1. that ratio was running silently through every session for 90 days. you don't need a smarter model. you need an instruction file that still describes how you actually work. listen to the podcast for the framing. open the article for the script that does the optimization.

the bottleneck Karpathy keeps pointing at isn't the model. it's the file you wrote three months ago telling it how to work. his whole framing: code isn't the verb anymore. > you express your will to agents 16 hours a day. > running more of them in parallel is the unlock. > and he drops this line halfway through, no fanfare: "now you can have optimization over the instructions." that's the sentence. the instructions are the new bottleneck. and almost nobody has a process for optimizing them. i built one for myself. it reads 100 of my past Claude Code sessions and rewrites my CLAUDE.md from what the transcripts show, not from what i thought i wrote. one Saturday morning later: a 38-line memory file. 73% of my old CLAUDE.md got deleted. most of it was one-off corrections that hardened into permanent rules months ago and were quietly steering every agent i ran. four behavior patterns surfaced that i had never written down. the loudest one: my prose corrections outnumber code corrections 8.2 to 1. that ratio was running silently through every session for 90 days. you don't need a smarter model. you need an instruction file that still describes how you actually work. listen to the podcast for the framing. open the article for the script that does the optimization.

Mnimiy

50,181 Aufrufe • vor 4 Monaten