💬 NLP

StoryCoder: Narrative Reformulation for Structured Reasoning in LLM Code Generation

StoryCoder is a narrative reformulation framework that transforms code generation problems into coherent natural language stories containing task overviews, constraints, and test cases, which significantly improves LLM performance by guiding models toward correct algorithmic strategies and reducing implementation errors.

Original authors: Geonhui Jang, Dongyoon Han, YoungJoon Yoo

Published 2026-04-17

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Geonhui Jang, Dongyoon Han, YoungJoon Yoo

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a brilliant but very literal robot how to solve a complex puzzle.

If you give the robot a standard, dry instruction like, "Calculate the sum of the max and min of all subsequences with at most k elements," the robot might get confused. It sees a list of disconnected rules and numbers, like a pile of scattered puzzle pieces. It tries to guess how they fit together, often making mistakes or getting stuck in a loop.

This is the problem the paper StoryCoder tries to solve.

The Core Idea: Turning a Manual into a Movie Script

The authors realized that humans are great at solving problems when they can tell a story about them. We don't just see "constraints"; we see "rules of the world." We don't just see "input/output"; we see "the beginning and end of a journey."

StoryCoder is a new method that takes a boring, technical coding problem and rewrites it as a coherent narrative (a story) before the robot tries to solve it.

Think of it like this:

The Old Way: You hand the robot a spreadsheet of rules. It has to figure out the logic on its own.
The StoryCoder Way: You hand the robot a short movie script. The script explains who the characters are, what the rules of their world are, and what happens in a specific scene. The robot then writes the code as if it were directing that movie.

How It Works (The Three-Act Structure)

The system doesn't just rewrite the text; it structures the story into three specific acts, guided by the type of logic the problem needs:

The Setup (Task Overview): Instead of saying "Input is an array," the story says, "Elara the adventurer has a bag of magical shards..." This sets the scene and explains the goal in a way that makes sense emotionally and logically.
The Rules of the World (Constraints): Instead of "1 ≤ n ≤ 100,000," the story says, "Elara's magical bag can only hold up to 100,000 shards, no matter how heavy they are." This turns abstract math limits into physical limits the robot can "visualize."
The Scene (Example Input/Output): Instead of "Input: [1, 2, 3], Output: 24," the story shows a specific scene: "The Oracle gives Elara three shards worth 1, 2, and 3. She calculates the power and finds it equals 24."

Why Does This Work?

The paper argues that Large Language Models (LLMs) are trained on massive amounts of books, movies, and stories. They are experts at understanding narratives. However, they are often bad at parsing dry, fragmented technical instructions.

By wrapping the math in a story, the model:

Connects the dots: It sees how the "bag size" (constraint) limits the "shards" (input).
Picks the right tool: The story helps the model realize, "Oh, this is a 'Dynamic Programming' problem because Elara has to make a series of choices to get the best result."
Avoids shortcuts: Without the story, the model might try a lazy, slow solution. The story forces it to think through the logic step-by-step, like a character in a novel.

The Results: A Superpower for Robots

The researchers tested this on 11 different AI models (both open-source and big commercial ones) using three famous coding challenges (like a digital Olympics for programmers).

The Magic Numbers:

On average, the models got 18.7% better at solving problems correctly when using StoryCoder.
On the hardest problems, the improvement was even bigger.
The models made fewer "silly" mistakes (like writing code that runs forever) and wrote cleaner, more organized code.

The Catch: The Genre Matters

The paper also found something fascinating: The story has to fit the problem.

If you tell a math problem as a "Fantasy Adventure," it works great. But if you force a "Legal Contract" or a "Funeral Obituary" style onto a math problem, the robot gets confused and performs worse. The "flavor" of the story must match the logic of the problem.

The Bottom Line

StoryCoder is like a translator that speaks "Human Story" and "Robot Code." It realizes that to get a robot to think clearly, you sometimes have to stop talking like a computer and start talking like a storyteller.

By turning a dry list of rules into a coherent adventure, we help the AI build a better mental map of the problem, leading to smarter, more accurate code. It proves that sometimes, the best way to solve a logical puzzle is to tell a good story about it.

1. Problem Statement

Current Large Language Models (LLMs) struggle with code generation tasks when problem descriptions are fragmented, ambiguous, or lack coherent structure. Existing prompting methods (e.g., Chain-of-Thought, Structured CoT) often focus on adding intermediate reasoning steps or injecting structural constraints after the problem is presented, but they leave the initial problem representation scattered. This forces the model to infer missing details and context, leading to:

Selection of incorrect algorithms.
Implementation errors (e.g., off-by-one errors, inefficient loops).
Lack of modular code structure.

The core hypothesis is that LLMs, like humans, reason more effectively when fragmented conditions are organized into a coherent mental model or narrative structure.

2. Methodology: StoryCoder

The authors propose StoryCoder, a framework that transforms standard coding problem statements into coherent natural language narratives. The process involves a three-stage pipeline (illustrated in Figure 1 of the paper):

A. Algorithm & Genre Selection

Given a coding question $Q_i$ , the generator model ( $f_{narr}$ ) first identifies:

Algorithm Category: Selects the most appropriate algorithmic approach (e.g., Dynamic Programming, Greedy, Simulation) from a predefined set.
Narrative Genre: Selects a narrative style (e.g., "Fantasy Adventure," "Mathematical Mystery") that naturally aligns with the problem and the chosen algorithm.

B. Narrative Reformulation

The model rewrites the problem into a structured narrative $N_i$ consisting of three specific components:

Task Overview: A story-driven description of the objective, integrating scattered conditions into a unified scenario.
Constraints: Input ranges, time limits, and rules are reframed as natural restrictions within the story (e.g., "The hero's bag has a finite capacity" instead of "Array length $\le 10^5$ ").
Example Input/Output: Test cases are embedded as contextual scenarios within the narrative flow.

C. Solution Generation

The reformulated narrative $N_i$ (optionally concatenated with the original question $Q_i$ ) is passed to a solver model ( $f_{solve}$ ) to generate code. The system supports both self-solving (same model generates and solves) and cross-model (one model generates the narrative, another solves it) settings.

3. Key Contributions

Novel Framework: Introduction of StoryCoder, which shifts the focus from adding reasoning steps to reformulating the problem representation itself using narrative structures.
Empirical Gains: Demonstrated consistent performance improvements across 11 diverse models (open-source and closed-source) and three benchmarks (HumanEval, LiveCodeBench, CodeForces).
- Achieved an average 18.7% gain in zero-shot pass@10 accuracy.
- Improvements were most significant on challenging benchmarks (CodeForces, LiveCodeBench).
Mechanistic Insights: Provided quantitative analyses showing why the method works:
- Algorithmic Alignment: Narratives guide models toward the correct algorithmic strategies.
- Error Reduction: Significantly reduces implementation errors and incorrect algorithm choices.
- Structural Modularity: Induces more modular code structures (deeper ASTs, more helper functions).
- Coherence & Genre: Performance depends heavily on the coherence of the narrative and the alignment between the chosen genre and the problem type. Mismatched genres degrade performance.

4. Experimental Results

The study evaluated 11 models, including DeepSeek-Coder, Llama-3.1, Gemma-2, Qwen-2.5, Mistral, and closed-source models like GPT-4.1-mini, Claude-3.5-Haiku, and Gemini-2.5-Flash.

Benchmarks:
- HumanEval: Standard function completion.
- LiveCodeBench: Large-scale, contamination-free competitive programming problems.
- CodeForces: Real-world algorithmic problems.
Performance:
- StoryCoder outperformed baselines including Repeated Sampling (RS), standard Chain-of-Thought (CoT), and Structured CoT (SCoT).
- On CodeForces, the average pass@10 for open-source models improved from ~19% (baselines) to ~28.6% (StoryCoder).
Ablation Studies:
- Component Coherence: Permuting narrative components (mixing Task Overview from one variant with Constraints from another) reduced performance compared to coherent narratives, proving that the integration of information is crucial, not just the presence of information.
- Genre Alignment: Forcing "misaligned" genres (e.g., legal documents for a math problem) caused significant performance drops, confirming that LLMs have a "narrative space" where specific genres facilitate specific reasoning patterns.
- Example I/O: Removing examples from the narrative still yielded gains over baselines, though less than the full narrative, suggesting the narrative semantics themselves drive reasoning improvements.

5. Significance and Implications

Beyond Surface-Level Rewriting: Unlike simple paraphrasing, StoryCoder fundamentally restructures the problem space, creating a "bridge" between the model's pretraining distribution (dominated by narrative text) and the formal requirements of coding.
Cognitive Alignment: The method leverages cognitive science principles (mental models, analogical reasoning) to help LLMs construct a consistent high-level representation of a problem before attempting to generate code.
Scalability: The benefits hold regardless of model size or architecture, suggesting that structured problem representation is a universal factor in code generation performance.
Future Directions: The authors suggest future work in adaptive genre selection, automated narrative refinement, and extending this approach to mathematics and multimodal reasoning.

In conclusion, StoryCoder demonstrates that how a problem is represented is as critical as the model's inherent capability. By transforming fragmented technical constraints into coherent, genre-aligned narratives, the framework significantly enhances the reasoning, planning, and implementation capabilities of LLMs in code generation.