← kevin.md

🚀 Just Give Us the Prompt

Someone posted a demo on X today. A UI component with liquid hover effects—drag your cursor across the screen and it ripples like water. Beautiful work. They linked to the GitHub repo so others could use it.

The first reply: “Just give us the prompt.”

Not “how does this work” or “what library did you use.” The first instinct was to ask for the prompt that generated the code.

Another Layer of Abstraction

There’s a pattern in computing. You write source code, then compile it to a binary. If someone gives you the binary, you ask for the source. The source is more valuable because it’s more general—you can modify it, learn from it, compile it differently for your needs.

The prompt is now the source code’s source code.

When someone shares a GitHub repo, you’re looking at the compiled output. The prompt that generated it is the deeper artifact. It’s more malleable, more transferable. You can take the same prompt and aim it at a different domain. Make it TypeScript instead of Swift. Add accessibility features. Change the visual style.

Source code pins down one implementation. A prompt describes what you want—and can generate many implementations.

The Compilation Chain Gets Longer

This is just the latest extension of a pattern that keeps repeating. Each era adds another layer of abstraction above the last.

The chain now looks like this:

intent → prompt → source code → executable

Each step is a kind of compilation. Lossy, interpretive, but increasingly automated. And at each level, people want access to the layer above.

The person asking for the prompt isn’t being lazy. They’re being efficient. They understand that the prompt is more reusable than the code it produced. The code solves one problem. The prompt solves a class of problems.

Code is Compiled Intent

There’s a deeper parallel here. When you compile source code to a binary, something is lost. The binary runs, but good luck understanding what it does or changing its behavior. Fewer people can read it. Modifications require specialized knowledge. You need the source.

Source code has the same problem, one level up. Code takes human intent and concretizes it into something precise enough for a compiler—but in doing so, the original reasoning gets buried under implementation details. The code compiles, but the why behind it lives in the prompt.

This is why comments exist. Code alone doesn’t capture the full context—the messy human details, the edge cases that aren’t obvious from the implementation. Comments are annotations for the next human, explaining what the code can’t.

It’s like debug symbols in a binary. Debug symbols aren’t part of the program—they’re metadata that helps you trace compiled code back to its source. Comments serve the same purpose one level up: metadata that traces code back to intent. Useful, but not essential. If the prompt becomes the canonical source, comments become redundant. The prompt already contains that context.

When we share code on GitHub, we’re sharing the intermediate representation. The prompt captures something the code doesn’t: the human intent.

Tracking Intent

People are already building for this. Entire,[2] a new AI developer platform led by Thomas Dohmke (former CEO of GitHub), hooks into Git workflows to capture agent sessions on every push. The prompts, reasoning, and checkpoints get indexed alongside commits—a searchable record of how code was written, not just what was written.

Regenerable Code

Maybe code itself will become ephemeral. Why commit generated artifacts when you can regenerate them from the source—the real source—whenever you need them?

This sounds far-fetched. Regenerating code on demand feels unsafe, unreliable. But consider the trajectory:

SWE-bench scores over time: 2% in October 2023, 72% in late 2024, 77% in September 2025, 81% in February 2026

On SWE-bench, AI systems solved just 2% of real-world coding problems in October 2023.[1] By late 2024, that number hit 72%. By September 2025, Claude Sonnet 4.5 reached 77%.[3] This month, Claude Opus 4.5 became the first model to break 80%.[4]

The curve is flattening, but that plateau isn’t a ceiling. Thinking models and agent loops push past it through iterative refinement—try, fail, read the error, adjust, try again. Retries dramatically increase the probability of success.

Napkin math, assuming independence: if a single attempt succeeds 81% of the time, it fails 19% of the time. Two consecutive failures: 19% × 19% = 3.6%. So two attempts succeed 96% of the time. Three attempts: 99%.

Of course, attempts aren’t actually independent with iterative refinement. If the model learns from the error, the second attempt is better informed—so 96% might be conservative. If there’s a systematic blindspot, both attempts fail the same way—so 96% might be optimistic. But the core intuition holds: retries help.

If that pace continues, treating code as a regenerable artifact starts to seem less crazy.

And there’s a compounding benefit: if you save the prompts instead of the code, you ride the improvement curve. The same prompts that generate a codebase today will generate a better codebase twelve months from now, as models get smarter. You get free upgrades.

But if you save the generated code and try to edit it later, you’re back to editing a compiled artifact. The code has already crystallized your intent into a specific implementation. Asking an AI to modify a tangled codebase is like asking someone to edit a binary—possible, but unwieldy.

OpenClaw is a case study. The repo exploded in popularity, accumulating 400,000+ lines of code and hundreds of dependencies. The PR queue became a firehose—I tried contributing, but every issue I tackled had five competing PRs within 24 hours. The codebase was changing faster than anyone could track.

Then someone built NanoClaw.[5] They looked at what OpenClaw actually did—the core intent—and regenerated it from scratch in 500 lines. Not a fork. Not a refactor. A decompilation back to intent, then a fresh compilation. The result was cleaner, more auditable, and easier to extend.

There’s a pattern I’ve noticed: code generated on the first pass is complex yet coherent—the AI designs holistically. But subsequent edits are always smaller in scope, forced to work within existing constraints. The first generation is architecture. The edits are patches. Regeneration lets you get back to architecture.

The prompt stays malleable. The code doesn’t.

The binary was never the point. The source was never the point either. The intent was always the point. We’re just getting better at expressing it directly.

Citations

[1] SWE-bench: Can Language Models Resolve Real-World GitHub Issues? — Jimenez et al., October 2023 ↩

[2] Entire CLI — AI agent session tracking for Git ↩

[3] Claude Sonnet 4.5 Tops SWE-Bench Verified — InfoQ ↩

[4] Introducing Claude Opus 4.5 — Anthropic ↩

[5] NanoClaw — A lightweight alternative to OpenClaw in ~500 lines ↩