Creative
Creative

Modularity as Essay Fractality: Functions and Instances

Creative Practice

Modularity as Essay Fractality: Functions and Instances

Here's a strange property of great essays. You're three sections in, and you start to anticipate the shape.
developing·concept·1 source··May 12, 2026

Modularity as Essay Fractality: Functions and Instances

The Reader Already Knows What's Coming, But In a Good Way

Here's a strange property of great essays. You're three sections in, and you start to anticipate the shape. You know how the next section will be structured even before you read it — because the previous sections all followed the same internal arc. The recognition doesn't feel mechanical. It feels like the essay is making sense.

That recognition is doing the work that hidden architecture is meant to do. Michael Deen calls this Modularity. "MODULARITY is the organization of ideas based on semantic relationships to aid in reader comprehension."1

Modularity has three sub-mechanisms:

Clustering — grouping Material so there's one unique idea per paragraph. Don't pack two ideas into one room.

Parallelism — creating similar arcs of "modules" across an essay. The same internal shape repeats across different content. Deen borrows the software vocabulary: a function is the recurring arc; an instance is the specific case the function operates on.

Fractality — compressing functions and instances and repeating them before or after their main occurrence. The whole structure can be previewed in the intro and synthesized in the conclusion. The reader gets a map at the entrance and a recap at the exit.

"This transforms a linear progression into an architecture of objects."1

What This Looks Like Operationally

The example Deen gives: a theoretical essay about technology trends. Three instances: (1) AI, (2) VR, (3) crypto. Each can follow a similar arc with 3 modules:

A: Context"spearheaded by visionaries." B: Progress"reaches technological maturity." C: Dilemma"ultimately gets hijacked by corporations who own distribution."

Each instance follows the function (A>B>C). "Without being too formulaic or predictable."1

The intro might reflect on A (visionaries) from a personal perspective, before listing the three instances (AI, VR, crypto) and giving a rapid preview of the function (A>B>C). Before diving into details, the reader has implicitly grasped the whole essay's structure. The following sections flow easier.

To close, the conclusion can synthesize 1C, 2C, 3C and reflect on what to do about C. "An essay is not just a linear arc from beginning to end; it's a series of components you loop through at different resolutions."1

This is fractality in action. The same A>B>C arc operates at three scales: within each section (as the internal logic), across the essay (as the parallel structure connecting sections), and as a meta-structure (previewed at the intro, synthesized at the close).

Why Modularity Is Resisted

The standard worry: "Won't readers get bored if you move through an A>B>C structure over and over?"1 Deen's answer: no, because the structure can be made invisible. The reader doesn't experience the framework as repetition; they experience it as clarity.

The analogy: "It's similar to a song with a repeating verse/chorus form; even though the backing chords are the same each verse, the lyrics are different each time. Once the reader starts to grasp these structural patterns, they're able to map relationships between ideas without you having to explain them."1

The reader doesn't say "oh, another A>B>C section." The reader says "I get it — this section is following the same logic as the last one." The recognition is implicit; it doesn't surface as boredom because the surface content (the instance) varies even when the structure (the function) stays.

The Subtext Layer

Modularity works through Subtext (7.3). "You don't need to explicitly list the modules of your function (A, B, C). By looping arrangements, the reader picks up the function through Subtext."1

This is critical. The writer doesn't announce: "This section will follow A→B→C, just like the last one." The writer simply runs A→B→C, and the reader picks up the pattern by repetition. After the second instance, the reader's working memory has built the model. The third instance lands as anticipated.

When the writer breaks the pattern (a deliberate variation, an exception, a non-function transition), the reader notices — and the variation lands with meaning because the pattern was established.

The Three Sub-Mechanisms in Detail

Clustering is the prerequisite for everything else. Each paragraph holds one idea. Two ideas in one paragraph and the reader has to do extra work. Deen's protocol: "Look through your paragraphs and combine or splice them so that each one represents a unique idea."1

Parallelism is where the function/instance vocabulary matters. "Look for functions (A, B, ...) that might work across multiple instances (1, 2, ...). Add or remove Material so each instance has a complete function (vary each as needed, and non-function transitions are definitely allowed)."1 The variations are the music; the structure is the chord progression underneath.

Fractality is the highest move. "Synthesize your functions and instances — at the beginning and/or end — so readers get compressed glimpses of the ideas across your components."1 The intro previews; the conclusion synthesizes. The middle runs the parallel structure. The whole essay can be understood at three resolutions simultaneously — sentence, section, and meta-structure.

The 5-Point Rubric

Deen's scoring for Modularity:

  1. Scattered ideas with poor clustering and no looping
  2. Decent paragraph grouping, no fractality or parallelism
  3. Clear units with a basic sense of modularity
  4. Parallel structures with strong synthesis in intro/outro
  5. Sophisticated organic architecture w/ multi-scale fractals1

The 5/5 bar requires multi-scale fractals — the same architecture operating at multiple resolutions simultaneously. Most essays sit at 2-3. A 4 reads as deliberately structured. A 5 reads as inevitable.

Modularity Failure Modes

No clustering: Two or three ideas per paragraph. Reader can't hold them. The fix: split paragraphs so each holds one idea.

Random sequence: Sections don't share internal shape. Reader can't build expectations. The fix: identify a function that fits at least three sections. Run it.

Over-visible structure: Reader notices the formula too explicitly. "And now I'll cover A. And now B. And now C." The fix: vary the surface even while keeping the underlying function. Different transitions, different paragraph counts per module, different tonal registers.

No fractality: The structure exists at section scale but isn't previewed in the intro or synthesized in the conclusion. The reader has to assemble the architecture themselves. The fix: add a synthesis paragraph that compresses the whole shape.

Forced uniformity: Every section follows exactly the same arc with no variation. Mechanical. The fix: allow non-function transitions. Some sections can break the pattern. The pattern still holds because of the rest.

Implementation: The Modularity Pass

Step 1 — Cluster: "Look through your paragraphs and combine or splice them so that each one represents a unique idea."1

Step 2 — Identify functions: "Look for functions (A, B, ...) that might work across multiple instances (1, 2, ...)."1 What arc do at least three of your sections share? Even partially. Name it.

Step 3 — Build out each instance: "Add or remove Material so each instance has a complete function (vary each as needed, and non-function transitions are definitely allowed)."1 Where instances are missing a module, add it. Where they have extras that don't serve the function, prune.

Step 4 — Add the fractal frame: "Synthesize your functions and instances — at the beginning and/or end — so readers get compressed glimpses of the ideas across your components."1 Intro previews; conclusion synthesizes. Both should reference the function and the instances explicitly.

Author Tensions & Convergences

Where Deen converges with Daniel Pink on watch-engineering: Pink's play-writing-as-watch-engineering page describes writing for the stage as engineering — every component fits with zero margin for error, gears clicking, debugging through live performance. Deen's Modularity treats prose like software with the same engineering bias. Both authors reach for engineering metaphors when describing structure. The shared move: writing at the structural level isn't art, it's design. The split: Pink's frame is mechanical (watches); Deen's frame is computational (software). Same underlying claim: structure is engineerable.

Where Deen extends what fiction structure has long understood: fiction has parallel-arc traditions (the trio of POV characters running parallel journeys, the seasonal-structure narrative, the family-saga generational repetition). Deen ports this to nonfiction. The convergence: Modularity isn't unique to essays. It's the same architecture that organizes great fiction. The split: fiction parallel-arcs are typically driven by character; essay Modularity is driven by argument. Different content. Same engine.

Cross-Domain Handshakes

Modularity as a concept reaches into adjacent vault territory at three specific points.

  • Eastern SpiritualityStandard Pūjā Architecture (Nyāsa to Prayer) (Selvalingam): The pūjā architecture is a fixed function — purification, invocation, offering, prayer, dismissal — applied to whatever deity is the current instance. Each pūjā is structurally identical; only the content (which deity, which mantras, which offerings) varies. This is Modularity at the level of ritual practice. The structural identity is exact: invariant function, variable instance. The split: ritual function is fixed by lineage; essay function is invented by the writer for each essay. What this reveals: ritual is the oldest known application of Modularity-style structure. Tantric tradition has known for millennia what Deen formalizes as software metaphor — variable content delivered through invariant structure produces absorption. Modern essay-craft has rediscovered the architecture.

  • Behavioral MechanicsScripted Interaction Templates (Hughes BOM): Behavior-ops practitioners use scripted interaction templates — fixed function arcs that the operator deploys across many target instances. The function is invariant (e.g., open-warm, escalate-vulnerability, close-on-commitment); the instance varies (which target, which context). Deen's essay Modularity runs the same architecture at writing scale. The structural identity: an operator-engineered function applied to multiple instances produces predictable effects. The split: scripted-interaction templates are extractive; essay Modularity is communicative. What this reveals: structured repetition produces structured cognitive effects whether deployed by influence operators or by essayists. The framework is ethically inert; the intent of the deployer determines the ethics.

  • Cross-DomainWorking Memory and Attention Budget: Cognitive science research on working memory (7±2 items) explains why Modularity works. The reader can hold a function plus a few current instances in working memory simultaneously. If you exceed the budget, you lose them. Modularity reduces cognitive load by letting the reader reuse the function-template across instances rather than rebuilding context for each new section. Every structural rule in Deen's Modularity framework can be derived from working-memory constraints. The framework is implicitly cognitive psychology applied to prose, even where Deen doesn't name it that way.

  • Creative PracticeIntegral Storytelling Framework: The vault's existing integral-storytelling-framework treats storytelling-as-tech-tree — multiple levels operating in parallel, each running the same internal architecture but at different sophistication-grades. This is Modularity at a vertical-stack scale. Deen's horizontal-instance parallelism (case 1 / case 2 / case 3 all running A>B>C) and integral-storytelling's vertical-level parallelism (level 1 / level 2 / level 3 all running the same narrative engine at different altitudes) are the same architectural move applied in different geometric directions. The handshake suggests a third move neither names: diagonal parallelism, where instances vary both horizontally (different cases) and vertically (different sophistication-grades) simultaneously. This would produce essays where 3 cases at 3 levels each create 9-cell matrices the reader can navigate.

Synthesis across the four connections: each domain has independently identified the same fact — invariant structure deployed across variable content produces absorption that variable structure cannot. Tantric ritual demonstrates this metaphysically. Scripted-interaction templates use it for influence. Working-memory research explains why it works cognitively. Integral-storytelling applies it vertically across narrative altitudes. Deen's Modularity applies it horizontally across essay instances. The mechanism is universal; the deployment varies. The deeper claim is that structural repetition isn't a writing-craft trick — it's the structural feature of every form of human meaning-making that has to fit through working-memory bottlenecks. Modularity isn't aesthetic. It's biology.

The Live Edge

The Sharpest Implication: If Modularity is engineerable and produces measurable cognitive reduction in the reader, then most analytical essays are operating at unnecessarily high cognitive load. Readers are building structure paragraph by paragraph because the writer didn't engineer parallel functions. The fix is structural — pick a function that fits at least three sections; run it consistently with variation. The compounding effect: as readers internalize the function, they read faster, retain more, and feel the essay is "well-structured" without consciously knowing why. The implication: working-memory-aware structural craft is one of the highest-leverage moves available in revision, and most writers never run a Modularity pass at all.

Generative Questions:

  • Modularity uses software metaphor (functions/instances). Where does the metaphor break down? Software functions are isolated and testable; essay modules are not. Is there a way to test essay-module integrity in isolation, or does prose's coupling defeat the engineering analogy?
  • The 5/5 bar requires "multi-scale fractals." But fractals in mathematics have an infinitely recursive property. Essay structure doesn't actually recurse to infinity (we don't have intra-sentence modules running A>B>C). What's the maximum number of nested scales at which Modularity actually operates in practice — three, four, five? At what point does adding scales stop producing benefit?
  • Deen's example uses A>B>C as the function. Most parallel-structure pedagogy assumes three modules. Why three? Could you build a four-module or seven-module function? At what point does the function become too complex for the reader to internalize after just two or three instances?

Connected Concepts

Footnotes

domainCreative Practice
developing
sources1
complexity
createdMay 12, 2026
inbound links5