Large-language-model (LLM) work has evolved far beyond single-shot interactions and now looks more like complex origami paper art. Each fold (a prompt, an evaluation, a recursion) turns the previous result into something stronger, more interesting, and more valuable. Also like origami, experienced practitioners hold in their toolboxes certain patterns of folds that let them achieve apparent miracles quickly.
Let’s take a look at a few common patterns where origami-like LLM interactions can have a big impact.
Prompt Chaining: Small Steps, Clear Hand-offs
Prompt chaining is the practice of breaking a job into a series of prompts, where the output of one prompt becomes the input to the next. The idea is simple: guide the model through a controlled path instead of hoping for a perfect answer in one shot.
Example 1 – support ticket triage
Start by summarizing the raw ticket to one sentence. Then classify the summary into bug, feature request, or question. Then route based on class and urgency. Each prompt has one job, so we can test and tune it in isolation.
Example 2 – marketing copy
Start with a short product description. Prompt A turns it into five benefit bullets. Prompt B rewrites the bullets as a headline. Prompt C checks length and tone. The team changes only the step that misses the mark.
Example 3 – data cleanup pipeline
A first prompt converts messy CSV rows into JSON. The next prompt validates field types and flags errors. A third prompt writes a concise error report. The chain replaces manual spreadsheet work and keeps every transformation explicit.
LLM as a Judge: Letting Models Validate the Work
LLM-as-a-judge uses one model to grade the output of another against clear criteria—accuracy, completeness, style, or any rubric you define. It replaces brittle string-match tests with fast, consistent reviews.
Example 1 – Q&A quality gate
A retrieval-augmented system proposes an answer. A judge prompt checks factual alignment with the retrieved context and assigns a score from 0 to 5. Answers scoring < 4 trigger an automatic rewrite. The human team reviews only the rewrites.
Example 2 – code-generation review
A generator writes a unit test. The judge compiles the test in a sandbox and rates readability, naming, and coverage. Poor scores return to the generator with pointed feedback. Over time, both prompts improve through the same feedback loop.
At the LangChain Interrupt 2025 conference, speakers noted that judge prompts need their own health checks—bias drift, prompt creep, and scoring inflation all show up if you do not track judge scores the same way you track model outputs.
Recursive Prompting: Solving Problems Larger Than One view
Recursive prompting feeds a model’s partial answer back into itself (or another instance) to go deeper or handle more data than fits in one go. The approach borrows the divide-and-conquer pattern we use in code.
Example 1 – long-form policy summarization
Split a 50-page policy into sections. Prompt A summarizes each section. Prompt B combines ten section summaries into a chapter summary. Prompt C merges chapter summaries into a two-page brief. Each recursion keeps context small and the final answer coherent.
Example 2 – multi-step math proof
Prompt A breaks the problem into sub-goals. Prompt B solves the first sub-goal and hands the result back. The loop continues until all sub-goals resolve, then assembles the proof. Recursive calls prevent token overflow and expose errors early.
Example 3 – progressive research planning
A high-level question spawns narrower questions. Each answer spawns the next layer until the plan reaches actionable tasks. The recursion stops when tasks are specific enough to assign.
Bonus: Push earlier in your workflow
I used to jump into ad-hoc tasks using LLMs with a plan to get quick answers. That didn’t always pan out, and it was usually my fault for not providing enough context. That’s when I would let out a big sigh and start typing harder, faster, trying to get it all out into the prompt window. At least I did until I started pushing LLM use earlier into a more robust interaction sequence. Here are a few ways that help create the context you need to get the right information.
- Talk, don’t type. Use text transcription to record your thoughts as you talk. Talking is faster, and we tend to self-edit less when speaking, making it easier to get context into a usable form. Be verbose and let later summarization steps take care of the editing.
- Ask the LLM to summarize your request and context.
- Ask the LLM to help you craft a prompt that will be suitable for your purpose. And then ask it for feedback on that prompt, like identifying areas that were missed, areas where more detail might help create a predictable result, or other resources that might help answer the question or accomplish the task.
The key is to use the LLM as a partner, often folding its responses back in to get to the ultimate result.
LLM Interactions with More Value
Treat prompts like functions: small, named, and unit-tested. Chain them to guide work, ask a model to judge the results, and recurse when the task is bigger than one view. Craft your result one fold at a time, and you’ll be pulling off miracles in no time.