What Octopuses Teach Us About Flexible Thinking

• The Alien Intelligence
• 500 Million Neurons, Two-Thirds in the Arms
• The Microservices Parallel
  • Conway's Law and the Octopus Body
  • When Distributed Wins, When Centralized Wins
• The Colorblind Artist: Processing Without Central Control
• Play as Intelligence
• Adaptive Camouflage and Technical Adaptability
  • T-Shaped Skills vs. Specialist vs. Generalist
  • Framework Fatigue and Strategic Learning
• Tool Use and the Developer's Toolbox
  • Sharpening the Axe
• The Escape Artist and Creative Problem Solving
  • Edward de Bono's Lateral Thinking
  • Creative Approaches to Debugging
• Short Lives and the Urgency of Knowledge Transfer
  • Documentation as Survival Strategy
• 5 Octopus Techniques for Creative Problem-Solving
  • Technique 1: Rubber Duck Debugging (Externalize the Problem)
  • Technique 2: Walk Away and Let the Arms Think
  • Technique 3: Translate the Problem to a Different Paradigm
  • Technique 4: Explain It to a Non-Expert
  • Technique 5: Run Parallel Hypotheses
• Closing: The Most Useful Kind of Stranger
• Quiz
• References

The Alien Intelligence

The Ancient Greeks called it πολύπους — polypous, "many feet." But the feet of an octopus are not merely feet. They are semi-independent computers, each capable of making decisions without consulting headquarters.

Octopuses appeared on Earth roughly 500 million years ago. They are mollusks, not vertebrates. Our last common ancestor with them lived approximately 750 million years ago — before the evolution of the first fish, the first frog, the first anything we would recognize as an animal with a brain.

And yet. They use tools. They solve puzzles. They play. They have personalities. They may dream.

The philosopher and marine biologist Peter Godfrey-Smith spent years diving alongside wild octopuses off the coast of Australia, and he wrote about what he found in Other Minds: The Octopus, the Sea, and the Deep Origins of Consciousness (2016):

"If we can make contact with cephalopods as sentient beings, it is not because of a shared history... It is because evolution built minds twice over."

Intelligence — perhaps consciousness itself — evolved not once but at least twice, completely independently, in lineages separated by hundreds of millions of years. This suggests something profound: that mind is not a peculiarity of a specific neural architecture. It is a solution that complex life converges upon when the problems are hard enough.

500 Million Neurons, Two-Thirds in the Arms

The neuroscience of the octopus is extraordinary.

An octopus has approximately 500 million neurons. For context, a mouse has around 70 million; a honeybee has about 1 million. The octopus is not operating at the level of a reflex machine.

What makes the distribution remarkable: only about 160 million of those neurons sit in the central brain. The remaining 340 million — roughly two-thirds of the octopus's total cognitive resources — are distributed across its eight arms.

Each arm contains a ganglion, a local nervous system capable of processing information and directing movement independently. When the central brain commands an arm to reach for food, it does not micromanage the path. It says, in effect, "get there." The arm figures out how — navigating around obstacles, feeling its way through crevices, adjusting for unexpected resistance — entirely on its own.

If this sounds familiar to anyone who has designed distributed systems, it should.

The Microservices Parallel

The architecture of an octopus maps almost perfectly onto the design philosophy of modern distributed software.

In a monolithic architecture, all logic routes through a single process. Every decision requires the central brain's involvement. This is simple to reason about but fragile — one failure can cascade everywhere, and scaling requires scaling everything.

In a microservices architecture, autonomous services handle their own domain logic. They receive high-level directives from orchestrators but implement those directives independently. Failures are contained. Services can be scaled individually. Different parts of the system can evolve at different rates.

The octopus solved this architectural problem before complex animals had spines. Its arms are services. Its central brain is the orchestrator. The communication protocol between them — refined over 500 million years — is not REST or gRPC, but it exhibits the same fundamental properties: loose coupling, local autonomy, and a shared contract about what each arm will and will not do.

What the octopus cannot do with this architecture is also instructive: it cannot develop a deeply integrated sense of its own arm positions the way mammals can. Octopuses are notoriously poor at proprioception. They trade holistic self-awareness for local adaptability. Every architectural choice is a trade-off.

Conway's Law and the Octopus Body

Melvin Conway proposed in 1967 that organizations design systems that mirror their own communication structures. Centralized organizations build monolithic systems; organizations composed of autonomous teams build distributed systems.

The octopus nervous system is a biological prototype of Conway's Law. Its "organizational structure" of a central brain and eight semi-independent arm ganglia determines its "system" of behavior. The greater the autonomy of the arm nervous systems, the faster and more flexible the response. But tasks that require coordination among multiple arms, such as opening a jar lid, require increased involvement from the central brain.

When Distributed Wins, When Centralized Wins

Distribution is not always optimal. The octopus itself demonstrates this.

• Distributed advantage: when each arm explores a different crevice simultaneously, when rapidly changing direction to escape a predator, when the environment is unpredictable and fast local reactions are essential
• Centralized advantage: when multiple arms must cooperate to open a container, when fleeing in one coordinated direction, when maintaining a consistent camouflage pattern across the entire body

The same applies to software. Services with independent domains benefit from distribution, but transactions requiring strong data consistency are better served by centralized coordination. The key is the ability to switch between both modes depending on context.

The Colorblind Artist: Processing Without Central Control

Here is a puzzle that has fascinated scientists for decades.

Octopuses are colorblind. Their retinas contain only a single type of photoreceptor, which means they should have no ability to distinguish wavelengths of light — no ability to distinguish color.

And yet, octopuses perform astonishingly accurate color-based camouflage. In 200 milliseconds, a resting octopus can transform its skin into a near-perfect replica of its surrounding reef, rocky bottom, or sandy floor — matching color, texture, and pattern with extraordinary fidelity. It deploys up to 70 million chromatophores (pigment cells) in a precisely choreographed display.

How does a colorblind animal achieve color-matched camouflage?

One compelling hypothesis (Stubbs & Stubbs, 2016) involves the octopus's unusual, elongated pupil and the physics of chromatic aberration: different wavelengths of light focus at slightly different distances when passing through a lens. The octopus may exploit this blur to extract color information — not through color receptors, but through the geometry of its optics.

The lesson for developers: when a straightforward approach is unavailable, the solution is sometimes to use existing data differently, not to gather more data or build more powerful processors. Constraints can be generative. The octopus's colorblindness is not a bug it works around; it may be a feature of the solution.

Play as Intelligence

Jennifer Mather's research (Mather & Anderson, 1999) produced a finding that researchers were initially reluctant to publish because it seemed too anthropomorphizing: octopuses play.

Specifically, octopuses were observed repeatedly manipulating objects that had no food value and offered no survival advantage — picking up pill bottles, letting them float away on the tank's water current, catching them again. Repeating this sequence. The behavior was not foraging, not threat assessment, not sexual display. It appeared to be play.

Play is a marker of high-order cognition. It is associated with learning, creativity, and social development. Its presence in octopuses — mollusks, boneless, cold-blooded, solitary — suggests that play behavior emerges spontaneously in any system with sufficient cognitive complexity, regardless of neural architecture.

Mather also documented octopus personality: individual animals of the same species respond consistently differently to novel stimuli. Some are bold and curious. Some are cautious. Some are aggressive. Personality, like play, is a signature of genuine intelligence.

Adaptive Camouflage and Technical Adaptability

An octopus can change its skin color, texture, and even shape in roughly 0.3 seconds. This is not a simple color shift. It operates through three independent layers: chromatophores (pigment cells), iridophores (reflective cells), and leucophores (light-scattering cells) cooperating hierarchically to produce a near-infinite range of combinations.

Map this onto a developer's adaptability.

T-Shaped Skills vs. Specialist vs. Generalist

The software industry often holds up the T-shaped professional as the ideal: deep expertise in one area (the vertical stroke of the T) combined with broad understanding across adjacent areas (the horizontal stroke).

The octopus is nature's T-shaped professional. It is supremely skilled at camouflage, its core competency, while also deploying tool use, puzzle solving, escape tactics, and varied hunting strategies with remarkable flexibility.

Stack Overflow's 2023 developer survey found that developers proficient in three or more programming languages earn 15 to 20 percent more on average than single-language developers. But there is a caveat: breadth without depth produces the "shallow generalist" who cannot solve hard problems in any domain. Like the octopus, the strategy is to secure a core competency first, then layer flexibility on top.

Framework Fatigue and Strategic Learning

In an environment where new frameworks and languages appear monthly, learning everything is impossible. What the octopus's camouflage strategy teaches is context-dependent selective adaptation. The octopus does not memorize every possible ocean floor pattern in advance. It senses the current environment and generates the optimal pattern in real time.

Developers operate the same way. Rather than pre-learning every technology, building strong foundations in core principles, including algorithms, data structures, and system design, and cultivating the ability to pick up new tools rapidly when needed, pays off more in the long run.

Tool Use and the Developer's Toolbox

In 2009, footage from Indonesian waters stunned the scientific community. A veined octopus (Amphioctopus marginatus) was filmed collecting two coconut shell halves, carrying them across the seafloor, and assembling them into a shelter when needed. This was the first confirmed case of tool use in an invertebrate (Finn et al., 2009).

The essence of tool use is anticipating a future need and adjusting present behavior accordingly. The octopus recognizes that the coconut shells are not useful right now, but will be later, and endures the awkwardness of carrying them.

Sharpening the Axe

There is a well-known saying attributed to Abraham Lincoln: given six hours to chop down a tree, he would spend the first four sharpening the axe. For developers, investing in tools follows the same principle.

• IDE plugins and configuration: mastering keyboard shortcuts, code snippets, and linter/formatter automation saves hundreds of hours of repetitive work over a career
• CLI tools and automation: shell scripts, Git aliases, build automation. Automating a repeated task once creates compounding returns
• AI coding tools: code completion, review assistance, and test generation are the modern developer's "coconut shells"

What matters is not the tools themselves but the ability to select and compose them. The octopus does not simply pick up a coconut shell. It figures out how to fit two halves together into a functional shelter. Developers similarly need to integrate tools organically into their workflows.

The Escape Artist and Creative Problem Solving

Octopus escape abilities are legendary. The most famous case is Inky, a common New Zealand octopus at the National Aquarium of New Zealand in 2016. Inky squeezed through a small gap at the top of his tank, crawled across the floor, found a drainpipe, and traveled 50 meters through it to reach the ocean. The story made international headlines.

What makes octopus escapes impressive is not mere physical flexibility. The octopus observes its environment, formulates a plan, and executes a multi-step sequence of actions. This is a biological case study in lateral thinking.

Edward de Bono's Lateral Thinking

Edward de Bono introduced the concept of lateral thinking in 1967. Unlike vertical thinking, which follows established patterns and logical steps, lateral thinking approaches a problem from an entirely different angle.

Inky's escape is a textbook example. Instead of accepting the premise "I cannot leave the tank," Inky reframed the question: "Which part of this tank is not completely sealed?"

Creative Approaches to Debugging

Developers face analogous moments where a shift in perspective is needed.

• Rubber duck debugging: explaining the problem aloud to gain a new perspective
• Git bisect: binary search for the commit that introduced a bug. This is a lateral approach that tracks when a bug started rather than guessing why it exists
• Printf debugging: tracing actual program flow with simple print statements instead of sophisticated debuggers. Sometimes the most primitive tool is the most effective
• Reverse debugging: working backward from effect to cause. Instead of asking "Why is this value wrong?" ask "Where was this value last correct?"

Like Inky, when the obvious path is blocked, the habit of exploring sideways is what distinguishes an exceptional debugger.

Short Lives and the Urgency of Knowledge Transfer

The most tragic fact about octopuses is their short lifespan. Most species live only one to two years. Even the giant Pacific octopus maxes out at about five years. Despite their intelligence, octopuses have virtually no mechanism for intergenerational knowledge transfer. The mother octopus stops eating after laying eggs, guards them until they hatch, and then dies. Her offspring enter the world knowing nothing she learned.

This connects directly to the bus factor in software teams: the number of people who could leave a team before the project stalls. A bus factor of one means a single departure can stop everything.

Documentation as Survival Strategy

The octopus fails at intergenerational knowledge transfer for a clear reason: it lacks a transmission mechanism. When software teams neglect documentation, they are repeating the same failure by choice.

Effective knowledge-sharing practices include the following.

• Architecture Decision Records (ADRs): document why decisions were made. Code shows what was done but not why
• Pair and mob programming: real-time knowledge transfer. Tacit knowledge, the kind that resists documentation, is shared through these practices
• Code review culture: code review is not only a quality gate but also a knowledge diffusion tool. Reviewers learn about other areas of the codebase, and authors are forced to articulate their reasoning
• Onboarding documentation: if every new team member requires a verbal walkthrough of everything from scratch, the bus factor is dangerously low

What if octopuses lived longer? What if they had a way to pass knowledge to the next generation? How far might their intelligence have developed? This counterfactual question carries a direct lesson for software teams: the ability to accumulate and transmit knowledge determines a team's long-term intelligence.

5 Octopus Techniques for Creative Problem-Solving

Technique 1: Rubber Duck Debugging (Externalize the Problem)

When an octopus arm encounters an unexpected obstacle, it doesn't wait for the central brain to devise a solution. It probes, adjusts, explores locally. You can activate the same distributed processing in your own mind by externalizing your problem — speaking it aloud, writing it out, drawing a diagram.

The act of articulation forces the prefrontal cortex to re-encode the problem in linguistic and spatial form, recruiting different cognitive resources than silent mental iteration. Your rubber duck, your blank whiteboard, your willing colleague — the audience matters less than the act of translation.

Technique 2: Walk Away and Let the Arms Think

Neuroscience has documented the "insight experience" — the sudden "aha!" that often comes after a period of not actively working on a problem (Kounios & Beeman, 2015). The brain's default mode network, active during rest and mind-wandering, is associated with the formation of unexpected connections between distant concepts.

When you are stuck, 20 minutes away from the problem is often not a delay — it is part of the solution process. Walk. Make tea. Fold laundry. The arms keep working.

Technique 3: Translate the Problem to a Different Paradigm

Just as the octopus extracts color information from a sensor not designed for color, you can extract new insights by translating your problem into a different representational system. Write your imperative code as functional code. Model your database schema as a graph. Describe your API as a state machine. Each translation reveals assumptions that were invisible in the original form.

Technique 4: Explain It to a Non-Expert

Godfrey-Smith describes the octopus as an intelligence that operates without the shared conceptual vocabulary that human communication depends on — forced to engage directly with physical reality, without the shortcut of language.

Explaining a technical problem to someone who does not know your framework or language requires you to identify what is essential and what is incidental — what the problem actually is, stripped of its implementation costume. In most cases, when developers say "I explained the problem to someone and realized the answer halfway through," this is the mechanism.

Technique 5: Run Parallel Hypotheses

An octopus uses eight arms simultaneously, exploring eight different directions at once. When investigating a complex bug or design problem, hold multiple hypotheses in parallel rather than pursuing them sequentially.

Sequential investigation is vulnerable to confirmation bias: once you believe hypothesis A is correct, you will interpret ambiguous evidence as supporting A. Parallel investigation keeps multiple explanations alive simultaneously, making it harder for any one story to colonize your attention before the evidence is in.

Closing: The Most Useful Kind of Stranger

It is easy to learn from things similar to yourself. A developer can always learn from other developers, from codebases in familiar languages, from patterns in familiar domains.

The deeper learning comes from genuine strangeness — the thing so different from you that it cannot be assimilated into your existing mental models without changing those models.

The octopus is 750 million years of evolutionary distance. It has blue blood, three hearts, and no parenting instinct. It will die without ever meeting its children. It experiences the world through arms that think for themselves, through eyes that somehow see without seeing color.

And it has something to teach us about building systems, solving problems, and staying flexible in the face of the unexpected.

The next time you are stuck on a hard problem, ask yourself: what would the octopus do? Probably it would stop trying to solve it from the center, and let each arm explore.

"Octopus arms are guided by a mind that is not entirely in the head." — Peter Godfrey-Smith

Quiz

References

• Godfrey-Smith, P. (2016). Other Minds: The Octopus, the Sea, and the Deep Origins of Consciousness. Farrar, Straus and Giroux.
• Mather, J. A., & Anderson, R. C. (1999). Exploration, play and habituation in octopuses. Journal of Comparative Psychology, 113(3), 333–338.
• Stubbs, A. L., & Stubbs, C. W. (2016). Spectral discrimination in color blind animals via chromatic aberration and pupil shape. PNAS, 113(29), 8206–8211.
• Kounios, J., & Beeman, M. (2015). The Eureka Factor: Aha Moments, Creative Insight, and the Brain. Random House.
• Finn, J. K., Tregenza, T., & Norman, M. D. (2009). Defensive tool use in a coconut-carrying octopus. Current Biology, 19(23), R1069–R1070.
• de Bono, E. (1967). The Use of Lateral Thinking. Jonathan Cape.
• Conway, M. E. (1968). How do committees invent? Datamation, 14(4), 28–31.