Writing the Algorithmic Narrative
How do we make the invisible world of code legible, shareable, and even beautiful?
Architects have long relied on drawings, models, and words to communicate their ideas. But today, much of architecture unfolds in a space that resists easy visualisation or narration: the algorithmic layer. As computation becomes central to design, a new challenge emerges - how do we talk about, draw, and critique code-driven processes?
This post explores the art of narrating algorithmic design - not just for fellow coders or technologists, but for a broader audience who still expects architecture to tell a story.
From Geometry to Logic
The shift from manual drawing to parametric modelling changed more than just tools; it changed how we think and what we need to express. Instead of fixed lines and forms, we now deal with: Rules, Relationships, Dependencies, Flow of data
A single surface might be the result of hundreds of variables interacting under a logic defined in code. But this logic is often invisible, tucked behind sliders, scripts, or optimisation processes, making it legible is both a technical and narrative act.
The Problem of the Black Box
Computation can be alienating. When we say a form was ‘generated’ or ‘optimised,’ it risks sounding ambiguous, even authoritarian. We may ask: Who made the decisions? What were the trade-offs? Why this form and not another?
If we can’t explain the design process in clear, compelling ways, we risk reducing architecture to a technical artefact, stripping it of authorship, meaning, and critique.
Narrating algorithms isn’t just an academic issue - it’s about restoring agency, opening the process, and inviting discourse.
Strategies for Narration
To communicate computational design, we need to develop new forms of representation - ones that reveal intent, process, and outcome. Some effective strategies include:
- Visual scripting maps: diagrams that show how data flows through a parametric model (e.g., in Grasshopper).
- Design evolution timelines: tracking how forms change over generations in an Interactive Genetic Algorithm.
- Annotated code blocks: human-readable snippets that explain logic and choices.
- Performance overlays: showing how environmental or structural data shaped form decisions.
- Design stories: simple narratives that link concept, computation, and outcome in relatable terms.
These tools allow us to reclaim narrative space within a highly technical design process.
Beyond Explanation: Critique and Reflection
Narration isn’t just about explanation - it’s about opening the door for critique. When we narrate our algorithmic decisions, we allow others to question them:
- Did the performance improvement justify the aesthetic trade-off?
- Did the optimisation respect social, cultural, or ecological contexts?
- Were the parameters inclusive of diverse values?
A rich algorithmic narrative makes space for reflection, accountability, and even improvisation - all essential to creative practice.
Examples: Snowflake and Co-Design Feedback Loops
In tools like Snowflake, where Interactive Genetic Algorithms let designers co-evolve solutions with the system, the narrative becomes not only what was chosen, but why.
- Each generation carries a story of selection - what the designer saw, preferred, rejected.
- Each fitness value reflects a moment of judgement, an expression of taste or intention.
- Over time, these decisions trace a path - a narrative arc - that connects data with desire.
These feedback loops aren’t just functional - they’re expressive. They’re where design logic meets human imagination.
Conclusion: From Code to Culture
If we want algorithmic design to become part of architectural culture - not just technique - we must learn to write its story.
- Make the logic visible.
- Make the decisions debatable.
- Make the process shareable.
Only then can we build not just smart buildings, but meaningful ones.
