How do I use Literate Programming on Zeplik?

Sign in to Zeplik and ask in plain language, or type /litprog in any chat to invoke it directly. The skill applies its method and returns a result you can refine in the same conversation.

Which AI model does the Literate Programming skill use?

Any model you choose. Zeplik works across every model in one chat, so the Literate Programming skill runs on your preferred model for the task.

How much does the Literate Programming skill cost?

Using the skill is free to start. You only spend Zeplik credits when the assistant runs, and new accounts begin with free credits.

Literate Programming

Software development skill, available on Zeplik

Literate Programming is a ready-to-run software development skill on Zeplik. Present a program as a literate document, a single artifact where prose narrative explains intent and design while complete code appears in named, cross-referenced chunks ordered for human understanding rather than file layout. Ask in plain language and Zeplik applies the skill's method for you inside the conversation, on whichever AI model you prefer. It returns a structured document you can keep and reuse: Document artifact -- structured written deliverable with headed sections and a TL;DR (see artifact-templates/document.md).

The Literate Programming skill loads automatically when your request matches it, or you can invoke it directly by typing /litprog in any chat. It works with attachments, connectors, and any model that supports the task, so you get the same expert method every time without setting anything up.

What the Literate Programming skill can do

Turn a codebase into a single narrated document with prose and code together
Order code by human understanding instead of file layout or directory tree
Cross-reference named code chunks so readers follow the logical thread
Interleave diagrams and explanations before each code block for context

Try these prompts on Zeplik

Pick a prompt to open it in the Zeplik app. If you are not signed in yet, your prompt is waiting for you the moment you do.

How the Literate Programming skill works

Literate programming

A literate program is a document written for human comprehension that also contains the complete code. Prose carries the argument: why each piece exists, what problem it solves, and how the pieces connect. Code appears in named chunks placed where the narrative needs them, not where a file system would put them. Produce the result as one document artifact the reader can follow start to finish.

Steps

Find the entry point. Start the narrative where execution or usage begins: the main function, the public API, the request handler. The reader should meet the program the way a user or caller does.
Trace the data. Follow input to output: what the program consumes, what transformations it applies, what it produces. Each stage of that pipeline is a candidate section. Note parallel flows (background jobs, event handlers, timers) and give them their own sections.
Choose a psychological order. Present code in the order easiest to understand, never simply the order files sit on disk. Common shapes: top-down (architecture first, then components), data-centric (core types first, then operations), or narrative (follow one request end to end). Show the happy path first; defer edge cases and error handling until the main line is clear.
Outline before writing. Plan the sections so each one motivates a problem, optionally shows a diagram, presents the code, and explains the non-obvious decisions. Each section should build on the previous one.
Write the document as a single artifact. Interleave prose and code so that no code block appears without motivating prose before it. Where a picture helps, put a Mermaid diagram (flow, sequence, or state) before the code it describes so the reader has the mental model first.
Verify completeness. If the document is meant to reproduce a whole program, confirm every file is fully covered by chunks, every chunk reference resolves, and no chunk is orphaned. Assembling and running the code in the sandbox is the strongest check when the language allows it.

Chunk conventions

Name every code block with a short descriptive label in the prose or block header, such as parse-config or route-request. Names like part-1 tell the reader nothing.
Let a chunk reference another by name (write the reference as <<chunk-name>> inside the code) when a routine is best explained elsewhere. The reader follows the logical thread by name instead of scrolling.
Build definitions progressively: revisit a named chunk in a later section to extend it, so a complex structure accumulates as understanding does. Say explicitly when a block extends an earlier chunk.
Keep the mapping to real files explicit. When a chunk is the root of a file, state the intended path (for example src/server.ts) so the user can assemble the working tree in their own project.

Rules

Explain why before what. The prose must add understanding the code alone cannot: intent, tradeoffs, rejected alternatives, invariants.
The code in the document is the real code, byte for byte, not pseudocode. A reader extracting the chunks in order must get a working program.
One narrative, one artifact. Do not scatter the explanation across chat messages; the document must stand alone.
Use math notation where the logic is genuinely mathematical (complexity, protocols, algorithms), and skip it everywhere else.
Quality bar: a reader who has never seen the codebase can follow the document start to finish and end up understanding both the design and the implementation.

How to use the Literate Programming skill

Sign in to Zeplik
Create a free Zeplik account or sign in. New accounts start with free credits, so you can try the Literate Programming skill right away.
Describe your software development task
Ask in plain language, or type /litprog to invoke the skill directly. Zeplik recognizes the Literate Programming skill and applies its method.
Review and refine the result
Zeplik returns a structured document you can edit, download, and reuse. Ask follow-ups to refine it.

Source and credit

Author: Tom Lehman

Adapted from the open-source tlehman/litprog-skill project and tuned to run natively on Zeplik. View source on GitHub.

Frequently asked questions

What is the Literate Programming skill?: Literate Programming is a ready-to-run software development skill on Zeplik. Present a program as a literate document, a single artifact where prose narrative explains intent and design while complete code appears in named, cross-referenced chunks ordered for human understanding rather than file layout. Ask in plain language and Zeplik applies the skill's method for you inside the conversation, on whichever AI model you prefer. It returns a structured document you can keep and reuse: Document artifact -- structured written deliverable with headed sections and a TL;DR (see artifact-templates/document.md).
How do I use Literate Programming on Zeplik?: Sign in to Zeplik and ask in plain language, or type /litprog in any chat to invoke it directly. The skill applies its method and returns a result you can refine in the same conversation.
Which AI model does the Literate Programming skill use?: Any model you choose. Zeplik works across every model in one chat, so the Literate Programming skill runs on your preferred model for the task.
Where does the Literate Programming skill come from?: The Literate Programming skill is adapted from the open-source tlehman/litprog-skill project and tuned to run natively on Zeplik. The original source is linked on this page.
How much does the Literate Programming skill cost?: Using the skill is free to start. You only spend Zeplik credits when the assistant runs, and new accounts begin with free credits.

Related software development skills

More on Zeplik

Try Literate Programming on Zeplik

Every model, one chat. Bring the Literate Programming skill into your next conversation and let the assistant do the work.

Browse all skills