Showing posts with label Andrej Karpathy. Show all posts
Showing posts with label Andrej Karpathy. Show all posts

5.4.26

I'm Stealing This AI Researcher's Workflow for My Own Projects

Karpathy doesn't use a fancy app to manage his research. He uses a folder, Obsidian, and an AI — and I want to copy it.

He posted about it last week. The short version: he dumps raw material — articles, notes, papers, images — into a folder, then lets a large language model (LLM — the AI brain behind tools like Claude or ChatGPT) build a wiki from it automatically. The LLM writes the summaries, creates the links between ideas, organizes everything into categories. He barely touches the wiki himself. When it gets big enough, he asks it questions and gets answers pulled from his own research.


I've been sitting with this for a few days, thinking about what it would look like for my work.


---


What My Work Actually Looks Like


I build things. Agents, content apps, Claude Code workflows, automation scripts. A lot of what I do involves figuring something out — what tool does what, how to wire two things together, what prompt pattern produces the right output, what broke last time and why.

Most of that knowledge lives in my head, or in scattered notes, or in past conversations I can't find anymore.


That's the problem. Every time I start something new, I spend time re-learning things I already know. What flags to use in Claude Code. What agent structure works for what kind of task. What API response format caused everything to break last month.


Karpathy's idea is simple: stop keeping that knowledge in your head. Dump it in a folder. Let the AI organize it. Ask it back when you need it.



The Specific Thing I Keep Thinking About


He mentioned that his wiki grows and gets more useful with every question he asks. He asks something, the AI goes through his notes and answers it — and then he saves that answer back into the wiki. So every session adds something. Nothing gets lost.


That hit me because the opposite is true for how I work right now. Every build session ends and most of the small things I figured out just disappear. The next session starts almost from scratch on some of the same ground.


If I had a knowledge base for my Claude Code workflows alone — prompts that worked, structures that didn't, patterns I figured out, error fixes — and an AI that could surface the right piece when I needed it, I'd stop repeating myself.



The Part That Actually Excited Me


He also runs "health checks" on his wiki. He asks the AI to find gaps, spot inconsistencies, and find connections between ideas he hadn't noticed yet. The AI suggests new things to look into.


That's the part I can't stop thinking about.


Not just a system that stores what I know. A system that notices what's missing. For someone building content automation apps, that means the system isn't just remembering what tools I've used — it's noticing when two things I built separately could be connected. It's pointing to the next piece.


That changes how building feels. Less like starting from zero every time, more like picking up a thread.


What I'm Going to Test

I'm starting with one folder. My Claude Code workflows — the scripts, prompts, notes, fixes, things that broke and how I solved them.


I'll ask Claude to read through everything and build an index: summaries of each file, links between related ideas, a map of what I already know.


From there, I'll ask it questions mid-project. "What pattern did I use last time for a multi-step agent?" "What was the issue I kept hitting with streaming output?" Instead of digging through old files or trying to remember, I just ask.


I'm not building the full Karpathy setup yet. I'm testing whether the core idea holds: does having a searchable, AI-organized version of my own work actually save time and reduce the re-learning?

19.6.25

Andrej Karpathy Declares the Era of Software 3.0: Programming in English, Building for Agents, and Rewriting the Stack

 Andrej Karpathy on the Future of Software: The Rise of Software 3.0 and the Agent Era

At a packed AI event, Andrej Karpathy—former Director of AI at Tesla and founding member of OpenAI—delivered a compelling address outlining a tectonic shift in how we write, interact with, and deploy software. “Software is changing again,” Karpathy declared, positioning today’s shift as more radical than anything the industry has seen in 70 years.

From Software 1.0 to 3.0

Karpathy breaks down the evolution of software into three stages:

  • Software 1.0: Traditional code written explicitly by developers in programming languages like Python or C++.

  • Software 2.0: Neural networks trained via data and optimized using backpropagation—no explicit code, just learned weights.

  • Software 3.0: Large Language Models (LLMs) like GPT-4 and Claude, where natural language prompts become the new form of programming.

“We are now programming computers in English,” Karpathy said, highlighting how the interface between humans and machines is becoming increasingly intuitive and accessible.

GitHub, Hugging Face, and the Rise of LLM Ecosystems

Karpathy draws powerful parallels between historical shifts in tooling: GitHub was the hub for Software 1.0; Hugging Face and similar platforms are now becoming the repositories for Software 2.0 and 3.0. Prompting an LLM is no longer just a trick—it’s a paradigm. And increasingly, tools like Cursor and Perplexity represent what he calls partial autonomy apps, with sliding scales of control for the user.

In these apps, humans perform verification while AIs handle generation, and GUIs become crucial for maintaining speed and safety.

AI as Utilities, Fabs, and Operating Systems

Karpathy introduced a powerful metaphor: LLMs as a new form of operating system. Just as Windows or Linux manage memory and processes, LLMs orchestrate knowledge and tasks. He explains that while LLMs operate with the reliability and ubiquity of utilities (like electricity), they also require the massive capex and infrastructure akin to semiconductor fabs.

But the most accurate analogy, he claims, is that LLMs are emerging operating systems, with multimodal abilities, memory management (context windows), and apps running across multiple providers—just like early days of Linux vs. Windows.

Vibe Coding and Natural Language Development

Vibe coding—the concept of programming through intuition and natural language—has exploded, thanks in part to Karpathy’s now-famous tweet. “I can’t program in Swift,” he said, “but I built an iOS app with an LLM in a day.”

The viral idea is about empowerment: anyone who speaks English can now create software. And this unlocks massive creative and economic potential, especially for young developers and non-programmers.

The Next Frontier: Building for AI Agents

Karpathy argues that today’s digital infrastructure was designed for humans and GUIs—not for autonomous agents. He proposes tools like llm.txt (analogous to robots.txt) to make content agent-readable, and praises platforms like Vercel and Stripe that are transitioning documentation and tooling to be LLM-native.

“You can’t just say ‘click this’ anymore,” he explains. Agents need precise, machine-readable instructions—not vague human UX metaphors.

He also showcases tools like Deep Wiki and Ingest to convert GitHub repos into digestible formats for LLMs. In short, we must rethink developer experience not just for humans, but for machine collaborators.

Iron Man Suits, Not Iron Man Robots

Karpathy closes with a compelling analogy: most AI applications today should act more like Iron Man suits (human-augmented intelligence) rather than fully autonomous Iron Man robots. We need GUIs for oversight, autonomy sliders to control risk, and workflows that let humans verify, adjust, and approve AI suggestions in tight loops.

“It’s not about replacing developers,” he emphasizes. “It’s about rewriting the stack, building intelligent tools, and creating software that collaborates with us.”


Takeaway:
The future of software isn’t just about writing better code. It’s about redefining what code is, who gets to write it, and how machines will interact with the web. Whether you’re a developer, founder, or student, learning to work with and build for LLMs isn’t optional—it’s the next operating system of the world.




Karpathy doesn't use a fancy app to manage his research. He uses a folder, Obsidian, and an AI — and I want to copy it. He posted about ...