Andrej Karpathy's October 2, 2026 post makes one claim worth acting on: when intelligence and code are abundant, the right answer to many questions is a custom piece of software you will throw away. His wording: "as intelligence and code are increasingly abundant, you can ask for large, custom, discardable software artifacts (e.g. web apps, video explainers) that would have never made sense to create before." This post unpacks that idea, shows how to apply it this week, and flags where discardable software goes wrong.
A sourcing note: we could not open the post directly from our environment (X is blocked here), so the wording above and the format ladder below come from search-result summaries of it. The embed below shows the original. If the thread contains more than the summaries describe, check it and tell us what we missed.
TL;DR: what the post says and what to do
| Question | Answer |
|---|---|
| What is the claim? | Code and intelligence are abundant, so large, custom, throwaway artifacts are now worth requesting |
| What changed? | The price of building, not model capability |
| Which formats? | Prose, then diagrams and images, then interactive HTML pages, then bespoke explainer videos |
| Favorite example? | A 3Blue1Brown-style explainer with ElevenLabs narration |
| What should I do? | Ask for an app or video instead of an essay when the answer is visual, numeric, or interactive |
| Main risk? | Unverified output that looks authoritative |
| Do I keep the artifact? | Usually no. That is the point |
What does "discardable software" actually mean?
For decades, software had a fixed cost structure. Writing an app took days, so you only wrote apps that would be used many times. Anything one-off, like a small tool to inspect a single dataset, got a spreadsheet or a script at best.
Karpathy's argument is that agents moved that cost so far down that the old threshold no longer applies. He has described vibe coding entire ephemeral apps just to find a single bug, "because why not," since code is "free, ephemeral, malleable, discardable after single use." That framing goes beyond what vibe coding means as a way of building products. It treats generated code as a communication medium, closer to a whiteboard sketch than to a deliverable.
The same instinct showed up in his Opus 5 Three.js world experiment, where a model wrote thousands of lines of procedural code from one paragraph, something no human would hand-author for a single viewing.
The format ladder: prose, diagrams, HTML, video
The part of the post that is easiest to use is the progression of output formats, each described as "even better" than the last:
- Prose. The default answer, fine for facts.
- Diagrams and images. Better when structure matters.
- Interactive HTML pages. Better still when you want to poke at parameters, sort data, or see a model run.
- Bespoke explainer videos. The format he is most bullish on, in the style of 3Blue1Brown with narration from a voice model like ElevenLabs.
The logic is learning efficiency. A concept like attention or gradient descent is far easier to absorb through an animation you can pause than through three paragraphs. What used to need a production team becomes a prompt plus a few minutes of generation.
How do I try this today?
A practical recipe that works with any coding agent or artifact-capable chat tool:
- Pick a question with a visual or interactive answer. "How do these three pricing plans compare at my usage?" beats "explain pricing."
- Give the agent the raw material. Paste the data, document, or repo path.
- Specify the container. "A single self-contained HTML file with no network calls" keeps it portable and safe.
- Say it is throwaway. This prevents over-engineering: no tests, no framework, no auth.
- Verify against the source. Spot-check three numbers by hand.
- Delete it. Or keep it in a scratch folder if it was genuinely useful.
Example prompt:
Read the attached CSV of my API usage. Build one self-contained HTML file with
an interactive chart: cost per day, filterable by model, with a total and a
projected monthly figure. No external requests. This is a throwaway artifact,
so keep the code simple and put the assumptions at the top of the page.
Tools that already lean this way include Claude Code artifacts, Google Antigravity's interactive generative UI, and Meta's vibe-coded gizmos. For a deeper look at prompting for rich outputs, see thin prompts, thick artifacts.
What are the limits and risks?
Abundant code does not mean abundant correctness.
| Risk | What goes wrong | Mitigation |
|---|---|---|
| Confident but wrong | A polished chart shows miscalculated numbers | Spot-check against the source data |
| Security | Generated code embeds keys or calls external endpoints | Run locally, no secrets, no network calls |
| Skill erosion | You stop understanding how the thing works | Keep the artifacts for learning, not for decisions |
| Cost | Long video or app generations burn tokens | Set a budget, as in the Opus 5 experiment |
| Scope creep | A throwaway becomes production | If it matters, rebuild it properly |
There is also the cultural cost. The vibe coding nightmares we have documented almost all come from keeping and shipping what should have been discarded. Karpathy's framing is a useful guardrail: if it is discardable, treat it as one. If you start depending on it, promote it to real software with review. The AI psychosis and vibe coding discussion and the agentic fatigue piece cover the human side.
Questions people are asking
Does this mean developers are obsolete?
No. The post is about what you can ask for, not about who reviews it. Someone still has to decide what question is worth an artifact and verify the result. Karpathy's earlier English as the new programming language argument points the same direction: the interface changes, the judgment stays.
Why video explainers specifically?
Because explanation is where the cost drop is most dramatic. A narrated animation took a studio; now it is a prompt plus a voice model and a rendering library. If you teach, onboard people, or write docs, this is the format to experiment with first.
Is Karpathy still the right person to listen to here?
He has been a consistent voice on this, and he now works at Anthropic on pre-training, per our coverage of his move. Treat this as one informed practitioner's observation about economics, not a roadmap.
Worked examples: when a throwaway artifact beats a text answer
The idea gets concrete when you match the question to the format. These are the cases where we would reach for an artifact before writing an essay:
| Situation | Text answer | Discardable artifact |
|---|---|---|
| Choosing between three LLM plans | A table of prices | An HTML calculator where you enter your monthly tokens and see the cheapest plan |
| Debugging a flaky log | A summary of suspicious lines | A tiny viewer that filters, groups, and highlights the failing request path |
| Teaching attention to a new hire | Three paragraphs and a diagram | A short narrated animation of queries, keys, and values moving |
| Reviewing a long contract | Bullet list of clauses | A page that highlights obligations by party and date, linked back to the source text |
| Planning a migration | A checklist | An interactive dependency graph you can click through |
Each of these used to fail the cost test. Nobody would build a calculator for one decision or an animation for one onboarding. When the build costs a few minutes of agent time, the test flips: the artifact is cheaper than the confusion it removes.
How this changes the way you prompt
The shift is from asking for an answer to asking for an instrument. Three habits help:
- Name the decision, not the topic. "Help me decide whether to move to the annual plan given my usage" produces something you can operate. "Explain pricing" produces prose.
- Put the assumptions on screen. A throwaway artifact is only trustworthy if you can see and change the inputs it assumed.
- Ask the agent to show its sources inside the artifact. A chart with a visible link back to the row it came from is far easier to verify than a clean picture with no provenance.
This also changes how you evaluate tools. If you are comparing agents for this style of work, the useful questions are how quickly they can produce a single-file artifact, whether they can run it for you, and whether they let you inspect what they built. Our agent comparison covers always-on agents on those terms.
Honest limitations of this post
- We could not open the original post, so the quote and format ladder come from search summaries. Verify against the tweet above.
- Specific products (such as ElevenLabs narration) are examples from the reported post, not endorsements.
- We have not benchmarked how reliably current agents produce correct explainer videos end to end.
What to do this week
- Pick one question you would normally answer with a doc and answer it with a single-file HTML artifact instead.
- Try one short explainer video of a concept you teach.
- Write down which artifact you wished you could keep. That one deserves real engineering.
- Never paste secrets into a throwaway app.
Follow @explainx_ai for more on building with agents.
Related reading
- What is vibe coding? A 2026 explainer
- Karpathy's Opus 5 Lord of the Rings world
- English as the programming language: Karpathy's view
- Claude Code artifacts and shareable sessions
- Thin prompts, thick artifacts
- Google Antigravity interactive generative UI
- Vibe coding nightmares and how to avoid them
- Andrej Karpathy joins Anthropic
Details are accurate as of October 2, 2026 and based on search summaries of Karpathy's post.