Skip to content
Design
Skill

/algorithmic-patterns

L-systems, cellular automata, agent-based modeling, swarm intelligence, reaction-diffusion, growth algorithms, packing algorithms, and nature-inspired computation for AEC design

BOOST
From plugin
computational-design-skills
22318 skills
Install
$ npx -y skills add Abhinavbwj/Claude-skills-for-Computational-Designers --skill algorithmic-patterns --agent claude-code

How it fires

How this skill gets triggered: by you, by Claude, or both.

  • Fires itselfAuto-invocation. Claude auto-loads it when your prompt matches the work.Auto-invocation is when the right skill fires by itself at the right moment, driven by a FLOW.md router and a hook, instead of you invoking it by name. It is the difference between a skill being installed and a skill actually getting used.Read the full definition →
  • You can call itInvoke it directly when you want it.
  • Slash command/algorithmic-patterns

Context preview

The summary Claude sees to decide when to auto-load this skill.

L-systems, cellular automata, agent-based modeling, swarm intelligence, reaction-diffusion, growth algorithms, packing algorithms, and nature-inspired computation for AEC design

SKILL.md

algorithmic-patterns.SKILL.md
title: Algorithmic Patterns
description: L-systems, cellular automata, agent-based modeling, swarm intelligence, reaction-diffusion, growth algorithms, packing algorithms, and nature-inspired computation for AEC design
version: 1.0.0
tags: [algorithmic, L-systems, cellular-automata, agent-based, swarm, reaction-diffusion, fractal, biomimetic]
auto_activate: true
user_invocable: true
invocation: /algorithmic-patterns

Algorithmic Patterns for AEC Design

1. Nature-Inspired Computation in AEC

Why Biological Algorithms Matter for Design

For three and a half billion years, evolution has solved the optimization problems architects and engineers face daily: distributing material efficiently, creating structures that resist loads with minimal mass, organizing circulation for millions of agents, regulating temperature without mechanical systems, and generating complex forms from simple rules. Nature-inspired computation translates these solutions into programmable algorithms that transform AEC practice.

The fundamental insight is that complexity does not require complex instructions. A fern frond with thousands of precisely placed leaflets emerges from a recursive rule fitting in a single line of code. A termite mound maintaining two-degree temperature stability is built by agents following three local rules. An oak tree optimally distributing material to resist wind has no central controller -- it grows according to Wolff's law, depositing material where stress is highest.

Emergence and Self-Organization

Emergence produces macro-scale patterns from micro-scale interactions without centralized control. In AEC, this challenges conventional top-down design, replacing it with local rules and boundary conditions that self-organize into coherent spatial configurations.

**Key properties of emergent systems:**

  • **Nonlinearity** -- small changes in rules produce disproportionate changes in output
  • **Feedback loops** -- positive feedback amplifies patterns, negative feedback stabilizes them
  • **Decentralization** -- no single agent has global knowledge of the system
  • **Adaptation** -- the system responds to environmental changes in real time
  • **Robustness** -- local failures do not cascade to system-level collapse

The computational thesis underlying all algorithmic patterns is that irreducible complexity can emerge from reducible rules. Stephen Wolfram demonstrated this with elementary cellular automata: Rule 110, defined by 8 binary transitions, is Turing-complete. A one-dimensional grid of cells with two states and nearest-neighbor rules can compute anything computable. For AEC: a branching structure with thousands of unique members can be specified by 3-4 L-system rules; a facade with apparent randomness generated by a 2-state CA; an optimal circulation network by 10,000 agents following 3 flocking rules.

| Aspect | Top-Down (Traditional) | Bottom-Up (Algorithmic) | |--------|----------------------|------------------------| | Control | Centralized | Distributed | | Specification | Global geometry | Local rules | | Adaptability | Low (manual redesign) | High (rules adapt) | | Scalability | Difficult | Inherent | | Novelty | Limited by imagination | Generates unexpected solutions |

Applications Across AEC

| Domain | Algorithm Class | Application | |--------|----------------|-------------| | Urban growth | Cellular automata, ABM | Land use simulation, sprawl prediction | | Structural branching | L-systems, space colonization | Tree columns, dendritic roofs | | Facade patterning | Reaction-diffusion, CA | Perforated screens, shading panels | | Space planning | Agent-based, packing | Room layout, furniture arrangement | | Material distribution | Topology optimization, DLA | Graded density structures | | Circulation design | Ant colony, shortest path | Corridor networks, staircase placement | | Acoustic design | Reaction-diffusion, fractal | Diffuser panel geometry | | Thermal design | Swarm optimization | Ventilation opening placement |

---

2. L-Systems (Lindenmayer Systems)

Formal Grammar

An L-system is a parallel rewriting system G = (V, w, P) where V is the alphabet, w is the axiom (initial string), and P is the production rules. Unlike Chomsky grammars, all rules apply simultaneously, modeling biological growth where cells divide concurrently.

DOL-Systems (Deterministic, Context-Free)

Each variable has exactly one production rule; rules are context-independent.

**Algae (Lindenmayer's original):** `Alphabet: {A,B} | Axiom: A | Rules: A->AB, B->A` String length follows the Fibonacci sequence: A, AB, ABA, ABAAB, ABAABABA.

**Koch Curve:** `Axiom: F | Rule: F->F+F-F-F+F | Angle: 90deg` Fractal dimension log(5)/log(3) = 1.465.

**Sierpinski Triangle:** `Axiom: F-G-G | Rules: F->F-G+F+G-F, G->GG | Angle: 120deg`

**Dragon Curve:** `Axiom: FX | Rules: X->X+YF+, Y->-FX-Y | Angle: 90deg`

**Hilbert Curve:** `Axiom: A | Rules: A->-BF+AFA+FB-, B->+AF-BFB-FA+ | Angle: 90deg`

Stochastic L-Systems

Multiple rules per predecessor with probabilities summing to 1:

F -> F[+F]F[-F]F    (p=0.33)
F -> F[+F]F          (p=0.33)
F -> FF-[-F+F+F]+[+F-F-F]  (p=0.34)

No two generated trees are identical, yet all share the same structural grammar. Critical for facades with varied but coherent panel geometries.

Context-Sensitive L-Systems

Rules depend on adjacent symbols: `A < B > C -> D` (B becomes D only between A and C). AEC application: signal propagation along structural members -- stress information triggers material deposition only where neighbors indicate high stress.

Parametric L-Systems

Symbols carry numerical parameters with guard conditions:

A(l,w) : l > 0.1 -> F(l) [+(30) A(l*0.7, w*0.8)] [-(30) A(l*0.7, w*0.8)]
A(l,w) : l <= 0.1 -> (terminal leaf)

Parameters 0.7 and 0.8 control child-to-parent ratios, mapping directly to Murray's law for biological branching.

Turtle Interpretation

| Symbol | Action | Symbol | Action | |---

Read more
Ships withcomputational-design-skills

Claude skills for Computational Designers

Get the whole plugin