Explain code

The function that outgrew its name

Most functions start out doing one clear thing, named accordingly, and then accumulate an edge case here, a retry branch there, a conditional someone added under deadline pressure, until the name no longer describes the behavior and the logic requires actually reading it line by line to understand. That's a normal way for code to evolve, but it leaves behind exactly the kind of function that slows down a review or trips up whoever touches it next. dev.code_explain reads through that accumulated complexity and states plainly what the code actually does now, not what its name suggests it should do.

From source to summary

POST /dev/code-explain with the function, method or code block you want explained, and the call returns a task_id while it's analyzed in the background. The explanation, delivered by signed webhook or a signed link valid for 24 hours, covers what the code does, the logic it follows, and notable behavior like error handling, side effects or edge cases, in language that doesn't require re-reading the code to make sense of.

Reading code has always been harder than writing it

The observation that programmers spend far more time reading code than writing it goes back decades in software engineering literature, and it's part of why disciplines like literate programming and self-documenting code emerged as explicit responses to the same problem: intent gets lost the moment code changes hands or time passes since it was written. Comments explaining why a function exists tend to survive; comments explaining exactly what each line does tend to rot, because they fall out of sync the first time the logic changes and nobody updates the prose next to it. An explanation generated on demand, from the code as it exists right now, doesn't have that decay problem.

Where it changes how a team actually works

In code review, a reviewer unfamiliar with a module gets a plain-language summary before diving into the diff, which turns review from line-by-line archaeology into checking whether the described behavior is actually what should happen. In onboarding, a new hire can explain unfamiliar files in a legacy codebase instead of pulling a senior engineer away from their own work to narrate it out loud. And for documentation, generating explanations for every public function in a library produces a first draft of API docs that a human only needs to edit, not write from nothing. Billed per request plus per thousand words of code, the cost scales with how much there actually is to explain, and a failed explanation is never charged.