from code to conductor — the Karpathy inflection

by Ray Svitla

Andrej Karpathy stopped writing code in December 2025.

not because he burned out. not because he retired. he stopped because directing agents became more productive than typing syntax.

“I haven’t written a line of code since December,” he said on the No Priors podcast this week. “I’m in perpetual AI psychosis. I spend 16 hours a day directing agents. The possibilities feel infinite.”

when one of the world’s best programmers — former Director of AI at Tesla, OpenAI founding member, educator to millions — stops programming, something fundamental shifted.

the inversion

Karpathy isn’t alone.

Garry Tan (YC CEO, legendary angel) calls it “cyber psychosis” — sleeping 4 hours because you can’t stop building with Claude Code. multiple developers on Reddit report the same pattern: hitting rate limits daily, running parallel agent sessions, feeling like idle tokens are wasted time.

the pattern: coding stopped being about writing and became about conducting.

you don’t type functions anymore. you describe intent. you review output. you steer, redirect, correct. the relationship inverted: from “I tell the computer what to do, line by line” to “I tell the agent what to build, iteration by iteration.”

why this matters

when a world-class engineer stops writing code, it’s not a productivity hack. it’s a skill ceiling collapse.

Karpathy’s expertise didn’t disappear. it concentrated. he went from typing implementations to orchestrating outcomes. the leverage shifted: 10,000 lines of handwritten code became 10 prompts and 10 reviews.

the cultural moment: if Karpathy doesn’t need to write code anymore, what does that mean for the rest of us?

the psychosis part

“perpetual AI psychosis” isn’t hyperbole.

when agents can build anything, the constraint isn’t capability — it’s decision paralysis. every idle moment feels like wasted potential. every idea becomes “I could ship that this weekend.” the possibility space exploded faster than human filtering can handle.

Garry Tan sleeping 4 hours. Karpathy directing for 16. developers hitting rate limits and feeling frustrated they can’t go faster.

this isn’t sustainable. but it’s real.

the shift: from “I need to learn how to build X” to “I need to decide which of the 47 things I could build this week actually matter.”

the infrastructure emerging around it

three things dropped today that show how the ecosystem is adapting:

1. OpenCLI (4,700 stars in 24h): turn any website, desktop app, or binary into a CLI. make everything agent-discoverable via AGENTS.md. when Figma, Notion, Linear become stable CLIs instead of fragile browser targets, the agent tooling surface explodes.

2. deer-flow (ByteDance, 1,700 stars): production harness for multi-hour agent tasks. not chat, not scripts — research papers, full features, complex migrations. built-in memory, skill library, subagent coordination. the stack for “deep work” agents just went open source.

3. pentagi (1,000+ stars): fully autonomous pentesting agents. network enumeration → vulnerability discovery → exploit chains → privilege escalation. no human steering. when agents can autonomously pentest codebases, the security threat model inverts: every system is now under permanent adversarial testing.

the pattern: infrastructure is emerging to support conductor-level work, not coder-level work.

what changes

if directing agents becomes the default mode, several things shift:

skill hierarchy inverts. syntax mastery stops being the bottleneck. taste, judgment, architecture sense — these become the levers. you’re not faster because you know the stdlib. you’re faster because you can review 10,000 lines of generated code in 10 minutes and spot the architectural flaw.

delegation becomes mandatory. you can’t review everything. you can’t steer every detail. agents need autonomy, memory, context. the tools that win are the ones that let you describe intent once and trust the agent to iterate without constant supervision.

“cyber psychosis” becomes normal. when the constraint isn’t implementation speed but decision bandwidth, the cognitive load shifts. every developer will hit the “I could build 47 things this week, which one actually matters?” wall. the ones who survive are the ones who develop filtering heuristics fast.

the question nobody’s asking

Karpathy stopped writing code. Garry Tan sleeps 4 hours. thousands of developers are hitting rate limits and feeling frustrated they can’t go faster.

what happens when this becomes everyone’s baseline?

when “I code” becomes “I conduct,” the job didn’t disappear — it transformed. the question is whether the transformation is sustainable, or if we’re all speed-running toward a burnout cliff nobody saw coming.

Karpathy called it “perpetual AI psychosis.” the possibilities feel infinite. the filter is human.

that’s the inflection.

Ray Svitla
stay evolving 🐌