The Discipline of Inspiration: Valéry and the Algorithmic Mind

Paul Valéry rejected inspiration as miracle, seeing creativity as the discipline of thought in motion. This week, we parallel his notion of mental “operations” with computational procedures in design: iteration, optimisation, constraint, and recombination, and challenge the dichotomy between intuition and automation. Drawing on contemporary design computation case studies, we’ll argue that the algorithmic process embodies Valéry’s “poetics of method,” a creativity founded on limits, not freedom, where the rule itself becomes the generator of surprise.

Prologue – The Architect and the Algorithm

1.1 Eupalinos ou l’Architecte: the dialogue between soul and form

When Paul Valéry wrote Eupalinos ou l’Architecte in 1921, he imagined a dialogue between Phaedrus and Socrates, suspended between life and death, reflecting on the one art that could endow matter with spirit: architecture. In their conversation, Eupalinos becomes the symbol of the artist-engineer, the one who gives âme aux pierres, who makes inert material sing. His buildings, says Socrates, “speak to the soul” through the secret accord of measure and movement. Architecture, in this sense, is not a craft of things but a craft of thought: the shaping of matter into meaning.

A century later, computational designers find themselves heirs to that same dialogue. Where Valéry’s Eupalinos measured with compass and chord, the contemporary architect measures with algorithm and code. Yet the question remains unchanged: how does form become expressive? How can the logic of construction contain whatever it needs to contain? Between the precision of the line and the resonance of the whole lies what Valéry called “l’opération de l’esprit” — the operation of the mind — an active, deliberate process of creation that rejects both the mystic aura of “inspiration” and the trite mechanical repetition some people attribute to computational design.

1.2 The persistent myth of inspiration vs. the contemporary myth of automation

Valéry distrusted the romantic cult of inspiration, and I’m behind him 100%. He called it a “false miracle,” a convenient way of masking the labour, analysis, and revision that true creation demands. For him, inspiration was not a visitation but a state of disciplined alertness, the result of method made instinctive.

In the digital era, this old myth of inspiration has been replaced by an equally seductive illusion: the myth of automation: we imagine that generative algorithms, machine learning, or optimisation scripts can bypass the slow uncertainties of human design.

Yet both myths — the divine spark and the perfect machine — conceal the same misunderstanding: they externalise creativity, locating it outside the continuous process of thought. Valéry’s critique thus finds a strange echo in the age of artificial intelligence: just as he stripped the poet of divine privilege, we must strip the algorithm of deterministic authority. What matters is not where ideas come from, but how they are made to work.

1.3 Valéry’s “poetics of method” and computational design

Throughout his Cahiers, Valéry developed what he called a poétique de la méthode, which was a way of thinking creativity as operation, procedure, and system. For him, the artist and the scientist share the same ambition to formalise intuition without destroying its vitality and every creative act, as he argued, oscillates between rule and invention, between the rigour of geometry and the fluidity of perception.

Something our friend Escher embodied very well.

Computational design, in this light, can be read not as a rupture with artistic intuition but as its logical continuation: algorithms, in other words, are not the end of imagination but its latest syntax, a language of constraints through which ideas acquire structure and behaviour. To design computationally is to act as Valéry’s Eupalinos would: to think in procedures, to sculpt relationships, and to make thought visible in form. The true challenge, as Valéry foresaw, lies not in building machines that create, but in cultivating minds capable of thinking methodically without losing sensitivity.

That’s why he’s relevant today, and that’s why we’re talking about him.

1.4 From Valéry’s “machine spirituelle” to today’s design machines

In a note from the Cahiers, Valéry describes the mind as what Umberto Eco called a machine spirituelle of sorts, something that transforms impulses into form through self-reflective operations. This idea ties into the contemporary vision of cognition as computation, a theoretical framework in cognitive science that views mental processes — such as perception, memory, reasoning, and decision-making — as forms of information processing, similar to how computers process data. This perspective suggests that the mind operates by manipulating symbols and representations according to rules, much like a computer program executes algorithms, and it’s a central idea in computational theories of mind, which were notably advanced by thinkers like Marvin Minsky in the field of artificial intelligence and cognitive psychology.

“I believe that the computer is a spiritual machine.”

— Umberto Eco

But Valéry’s machine was never mechanical: it was a dynamic equilibrium between order and chaos, awareness and automatism.

Today’s design machines — parametric systems, generative algorithms, and AI-assisted workflows — externalise this very tension. They automate certain gestures while demanding new forms of control, observation, and interpretation. To work with them is to enter Valéry’s paradox: to construct processes that both discipline and liberate the imagination. The algorithm, like the mind, becomes a site of negotiation between conscious intention and emergent behaviour.

Let us see what it means.

2. The False Miracle of Inspiration

2.1. Les dieux ne donnent rien

Few things irritated Paul Valéry more than the myth of inspiration, and I’m right there with him. Quoting Heraclitus, the gods give nothing freely that doesn’t come with hard work. In other words, we need to debunk the Romantic cult of the artist-genius, that feverish demiurge who produces beauty through rapture and divine possession. This approach is both lazy and dangerous: it excuses ignorance by calling it transcendence. Inspiration is not revelation, but premature expression, the noise before the thought is formed.

Against this pious narrative of creation as miracle, Valéry proposed a heretical alternative: that creation is a deliberate, reversible, procedural operation. The poet, like the mathematician, proceeds through testing, correction, iteration. The true miracle is not divine descent, but the human capacity for structured self-transformation. Creativity, in Valéry’s sense, is not a state but a system: a continuous reorganisation of thought around form. What is deep happens to love disguise, in his opinion, and he argues inspiration itself is only the mask behind which method hides.

2.2. The artist as worker of thoughts

If inspiration is illusion, then creation must be labour. Valéry’s notebooks, those obsessive daily experiments in thinking, show a mind more engineer than mystic through which he described the act of writing as an experiment performed on oneself, an attempt to formalise intuition through iteration and observation. In his 1944 introduction to The Wedge, William Carlos Williams similarly described a poem as “a small (or large) machine made out of words,” suggesting that a poem’s power comes from its careful construction and rhythmic movement, not just the poetics of its content. By treating thought as a similarly manipulable system, Valéry reclaimed creativity from the realm of the unexplainable and the artist, to him, became a travailleur de l’esprit, a worker of thought. His laboratory was not the mountain peak of inspiration, but the daily, recursive space of trial and error where work transforms chance into necessity, and necessity into the creative freedom that only comes from mastery. The paradox is quintessentially Valéryan, if you pardon my saying: freedom, the most romantic of ideals, is the product of methodical constraint. Sounds familiar?

Here we find the seed of what might be called proto-computational creativity: a view of invention as procedural transformation. To think through steps, loops, and dependencies doesn’t mean mechanising imagination, but rendering it intelligible, reproducible, and therefore shareable. Valéry anticipated the condition of the digital designer, who no longer draws forms but programs possibilities. The romantic artist expresses; the Valéryan creator operates.

2.3. Architects aren’t artists (and they never were)

Let’s break the polite fiction here: architects aren’t artists, and they never were. The sooner we abandon that sentimental notion, the more honest our discipline becomes. Architecture, even at its most visionary, has always been a negotiation between constraint and aspiration: physics, budgets, climate, clients, regulations, and gravity’s stubborn pull. The architect’s work is neither pure expression nor pure construction, but a concertation of limits, precisely what Valéry called la méthode créatrice.

In Eupalinos ou l’Architecte, the architect stands as the archetype of conscious form-making because he is forced to reconcile necessity and imagination. He made buildings that sing, says Socrates, because Eupalinos — instead of trying to escape constraints — he mastered them. His “music” arises from calculation, as much of actual music does. Valéry admired the architect not as an artist of emotion, but as a thinker of relations. In his world, proportion replaces passion, and rhythm substitutes for revelation.

Today’s computational designer inherits this legacy, though perhaps without admitting it. Writing a script, tuning parameters, managing data hierarchies are all acts of concentration and they require judgment, not ecstasy. The architect’s art has always been algorithmic in spirit: it translates thought into measurable structure. To continue calling architecture an “art” in the romantic sense is to miss its real dignity of reason turned visible.

2.4. Computational creativity: scripting, iteration, and the designer’s control loop

In computational design, creativity unfolds through loops. The designer writes a procedure, tests it, adjusts its parameters, and observes the result in a recursive cycle that resembles both the scientific experiment and the poetic revision. In this framework, the algorithm is less a tool than a collaborator, an interlocutor that speaks back in form. Each iteration becomes an act of dialogue between intent and emergence, particularly when computational design takes the form of design optioneering.

Valéry would have recognised this rhythm immediately. The idea of la pensée opératoire — the operational thought elaborated in psychanalysis by Pierre Marty — maps almost perfectly onto the feedback systems of digital design: both are concerned with how intention interacts with automatism. The creative act emerges when two minds cooperate: one that decides and one that obeys; when awareness harnesses habit without suppressing it. This dialectic is precisely what contemporary computation externalises: we script behaviours, then interpret the behaviours that the system returns. The machine becomes a mirror for the mind, reflecting its oscillation between control and surprise.

The architect-programmer, therefore, is not automating creativity but setting conditions under which form may arise. The code replaces the sketchbook, but not the struggle. What changes is not the goal, but the medium of feedback: instead of intuition responding to intuition, it is thought responding to code. If the machine now “creates,” it is only because it extends the architecture of the recursive mind that constructs through operation.

“The universe is built on a plan, the profound symmetry of which is somehow present in the inner structure of our intellect.”

2.5. The disappearance of the “genius” myth

Valéry’s heresy was to dethrone the genius. “The folly of mistaking a paradox for a discovery, a metaphor for a proof, a torrent of verbiage for a spring of capital truths, and oneself for an oracle, is inborn in us.” Genius, for him, was a form of discipline misinterpreted as gift, a long patience mistaken for the strike of lightning. His suspicion of inspiration was therefore ethical as much as epistemological: by romanticising the gift, society denies the value of method, and with it, the equality of minds.

“A man is a poet if difficulties inherent in his art provide him with ideas; he is not a poet if they deprive him of ideas.”

The rise of algorithmic design culture seems to fulfil his prophecy by dissolving authorship itself. Parametric tools, generative systems, and neural models flatten the figure of the singular creator into networks of decision and data. The result is paradoxical: at the very moment when technology individualises production, it also anonymises creation. The “signature” becomes a set of parameters rather than a gesture. In this, the computational designer becomes the worker par excellence, one who constructs conditions for creativity rather than claiming ownership of it.

Yet we should resist the temptation to romanticise this new condition as post-human liberation. The disappearance of the genius does not automatically entail the emergence of collective intelligence; it can just as easily conceal a new kind of servitude in which automation is mistaken for authorship, and data pipelines are mistaken for thought. We see it every day. The algorithm does not think; it executes. To create, we must still think the execution itself. The architect of today, like Eupalinos, must once again give âme aux pierres, but the stones have changed: they are now made of data, loops, and logic. What has not changed is the task: to make these systems sing.

3. Thought as Operation: the Mental Mechanics of Form

3.1. Valéry’s concept of mental mechanics

If thought isn’t an ethereal flame but a mechanism, let it be sure that we mean mechanical not in the sense of lifeless repetition, but mechanical as in operable, recursive, and governed by relations. Valéry returns obsessively to this theme, describing the mind as a system of small mechanisms that translate sensations into symbolic structures. Thought, for Valéry, is the physiological, affective and linguistic act of organising forces into a coherent operation.

This radically redefines cognition as a kind of craftsmanship, against Bergson’s intuitionism, which valued duration and flow over calculation. In this approach, we find the necessity of rigour, of iteration, of deliberate structure. And against the Cartesian fantasy of a transparent, unified subject, we need to educate a consciousness as a process of coordination among partial automatons.

The mental mechanics aren’t, of course, opposed to creativity; they are its very condition. By conceiving thought as operational, Valéry anticipated both cybernetics and cognitive science with a deep understanding of mind as feedback and adaptive procedure: he grasped that every creative act involves a balance between conscious control and unconscious automatism, an economy of attention before the term existed. His philosophy of precision against mysticism also became a poetics against reductionism: to mechanise thought was, paradoxically, to preserve its vitality by understanding its rhythm.

This makes Valéry a crucial — if often overlooked — figure in what Gilbert Simondon later called la pensée technique: the awareness that technique is not the negation of thought but its continuation through material means (Du mode d’existence des objets techniques, 1958). The mind, for both Valéry and Simondon, is not an essence but a process of individuation through operations. To create, then, is to operate oneself.

3.2. The algorithm as an extension of the mind’s calculus

When Valéry writes that a mind is a system that experiments upon itself, he prefigures the epistemology of computation. The algorithm — intended as a set of instructions capable of iteration and feedback — can be seen as the externalisation of this very system.

To understand computational design through Valéry’s lens, we must resist the naïve identification of algorithms with technical determinism, as calculation was never opposed to imagination. On the contrary, imagination can be seen as the highest form of calculation, the anticipation of possible forms within constraints. If geometry is the dream of reason made visible, the algorithm continues that dream: it is geometry that thinks in time.

In this sense, coding is not the mechanisation of design but the transposition of mental mechanics into executable form. It makes visible what the mind should already be able to perform silently: abstraction, selection, recombination. Every script is an attempt to describe how one believes thought itself should unfold. Each loop and condition encodes an epistemology.

This is where some people encounter difficulty: being untrained in imagining complex geometry, in visualising vectors, in imagining numbers, they approach computational design without the necessary mental structure.

Contemporary philosophers of computation, from Yuk Hui to Katherine Hayles, have rediscovered this idea in different terms. Hui’s Recursivity and Contingency (2019) frames digital systems as recursive mirrors of thought: machines that both extend and reshape human reasoning. Hayles, in Unthought (2017), speaks of “cognitive assemblages” as hybrid systems in which human and non-human agents co-constitute cognition. Valéry would have nodded in recognition. His machine spirituelle was precisely such an assemblage avant la lettre: a thinking device made of awareness, automatism, and feedback.

In the digital studio, each computational process — whether parametric constraint solving, agent-based modelling, or machine learning classification — performs a miniature reenactment of the mental mechanics we’re describing: the oscillation between decision and emergence, between the mind that commands and the mind that adapts to an external feedback.

3.3. The human-machine feedback loop

Honouring Valéry’s ambition, we’re trying to make creation conscious without becoming rigid. If the perfect act is one that knows itself as it happens, I can see no better application ground than computational design and, as we step into the perilous. In this, he prefigured the fundamental challenge of our own age: how to sustain awareness within systems of automation. We spoke about it before, when we talked about encoding intelligence.

The human-machine feedback loop in computational design can be read as the material realisation of that aspiration; each iteration of code and response, adjustment and output, reenacts the structure of Valéry’s acte conscient — a gesture both deliberate and responsive. The designer writes a rule, the machine executes it, the designer interprets the result, rewrites the rule, and so on. This recursive exchange constitutes what Gregory Bateson, writing in Steps to an Ecology of Mind (1972), would later call a mind in the larger sense: a distributed system of perception, adaptation, and feedback.

Approaching the algorithmic loop as an amplification to creativity is only possible, as we were saying, if consciousness remains in the circuit. What Valéry feared most was the dulling of awareness, the surrender of thought to habit and, in that sense, the real danger of automation lies not in the machine’s autonomy but in our abdication of interpretive labour. When the designer ceases to reflect on the procedures they construct, the machine ceases to extend thought and begins to replace it. The task, therefore, is to practice a lucidité opératoire: the awareness of one’s own operations.

In practical terms, this translates into an approach to computational design that privileges reflection over acceleration, iteration over output, interpretation over control. The algorithm, as an extension of the mind’s calculus, should remain transparent enough to provoke thought, not conceal it, as its role is to externalise the mental mechanics in order to make them available for critique and transformation.

In this view, each parametric dependency is a hypothesis about causality, and each generative system should be a meditation on possibility, instead of being just a system that spouts formal variations faster than the human.

So, let’s see a couple of techniques for approaching computational design with this awareness.

4. Three Techniques to Keep in Mind

4.1. Externalise the Thought: diagrams, diagrams, diagrams

Premise: “What is not expressed does not exist.” (Czesław Miłosz, The Captive Mind)

Before writing code or wiring nodes, articulate the logic of the design as a UML diagram. UML (Unified Modelling Language) is a visual system for representing the structure and behaviour of software: how entities relate, how data flows, and how processes interact. In software engineering, it functions as a cognitive bridge between concept and implementation, putting definitions and general functioning before syntax gets in the way.

Applied to computational design, UML serves the same role Valéry attributed to the diagram: it externalises computational thinking before materialising it into a graph. By sketching class diagrams, flowcharts, or sequence diagrams, the designer clarifies how a system will behave on top of what it will produce.

Practical approach:

• model the idea first: draft classes or modules that correspond to conceptual units — “Facade,” “Grid,” “Structure,” “Environment” — and define how they exchange data;
• use relationships as design material: associations, dependencies, and hierarchies in the UML diagram should show where control resides and where emergence is allowed;
• translate the diagram into code or nodes consciously: each connection in Dynamo or Grasshopper should correspond to a relation in the UML model, maintaining conceptual clarity through the translation;
• revise the diagram as you iterate: as Valéry would revise a verse, revisit the UML model to reflect the evolution of thought. The diagram becomes a record of the system’s mental mechanics, poétique de la méthode.

4.2. Think in Loops: iterations, iterations, iterations

Premise: “To think is to try again differently” (George Polya, How to Solve It: A New Aspect of Mathematical Method)

Valéry’s idea of thought as operation has a contemporary analogue in DevOps, the practice built on continuous integration, continuous delivery, and tight feedback loops that rejects the myth of the finished product and treats every release as a hypothesis to be tested.

This is also the natural epistemology of computational design. A Grasshopper definition or Dynamo script is never “finished”; it is perpetually updated, refactored, broken, rewired, optimised. Each iteration is not a correction but a form of thinking aloud. In DevOps terms: designers design pipelines that carry ideas across versions.

DevOps formalises that system into a workflow:

• Improve → the cycle begins again
• Plan → intention
• Develop → operation (the first gesture)
• Assemble → emergence (what the machine returns)
• Test → reflection (evaluation)
• Release → send it into the wild
• Deploy → an act that transforms the environment
• Operate → use the thing for a while, see how it goes
• Monitor → self-observation (the system looks at itself)

Practical approach:

• Prototype early, deliberately imperfect: a definition with placeholder values is the computational equivalent of a poet’s first draft or a developer’s minimum viable product (MVP). Iteration cannot begin without imperfection.
• Treat every run as a test suite. When the script executes, evaluate not only whether the geometry is “right,” but whether the logic still makes sense. Is the dependency flow coherent? Are the parameters meaningful? DevOps calls this observability.
• Archive intermediate versions. Each version is a cognitive state and might be worth preserving in the iteration phase. Saving drafts (v0.1, v0.2, v0.3…) allows you to retrace the genealogy of thought. This is not bureaucracy; it is self-awareness across time.
• Build internal feedback loops. Use small watch nodes, temporary panels, preview toggles, micro-loops in Python components as instruments to understand the evolution of the system.
• Refactor continuously. DevOps teaches that code grows messy unless it is tended. The same applies to node networks: frequent reorganisation (clustering, renaming, simplifying) is essential to keep the logic transparent.

4.3. Design the Rules

Premise: “The rule is the mother of freedom” (Paul Valéry)

Parameters and constraints, often seen as limitations, are in fact the pillars through which a script makes sense: each constraint is a decision about what matters, and conscious design consists in making those decisions explicit, coding criteria.

Practical approach:

• begin by scripting relationships;
• define constraints that carry meaning (structural logic, daylight, spatial proportion) rather than arbitrary control;
• use sliders and data inputs as instruments of exploration, tune them as one would modulate rhythm or tone.

Conclusion: a Conscious Computational Practice

Computational design is often romanticised as a realm of infinite possibility: parametric fields, generative swarms, neural optimisations, formal exuberance. But as Valéry relentlessly reminds us, possibility is nothing without method. The contemporary studio is filled with scripts assembled like puzzles, diagrams improvised in real time, workflows that rely more on the intoxication of novelty than on the clarity of intention. This is creation without consciousness.

Through a different approach, we can reclaim his insistence that thought is a structured, recursive, intentional operation, and we should connect it to the very heart of computational design. If our tools are becoming more powerful, more autonomous, more opaque, then the designer’s responsibility increases proportionally. The code will not think for you. The algorithm will not reflect for you. The machine will not organise your mind. They just won’t.

This is why diagrams matter. The sketch, the flowchart, the conceptual map, the UML-like diagram aren’t preludes to “real” work: they are the work. They reveal the structure of an idea before it enters the machinery of execution, and force the designer to articulate intention before falling into the apparent comfort of improvisation.

This is why iteration matters. Each loop is an opportunity to observe the consequences of a decision, to refine the geometry of thought. Iteration without awareness is chaos; iteration with awareness is method. DevOps understood this decades ago, and based its development culture on the sacredness of the loop.

Finally, this is why planning and documenting are not bureaucratic burdens. Resist the temptation to “just start scripting,” because that false freedom ends in confusion. If we want our definitions, scripts, and pipelines to sing — as Eupalinos wanted his buildings to sing — then we must cultivate the discipline he embodied: a practice where diagrams sharpen intention, iterations reveal structure, and planning becomes the true site of creativity.