How the Lesson Started, By Accident#

It was a regular AI review session in a pull request on one of my projects. Little background - I was implementing a general BFS (Breadth-First Search) algorithm which can be whipped as a JAR library into one of my developing Java webservices to solve various business problems. To boost its generality, I decided to implement it using the Visitor pattern, which by design is able to separate the fixed algorithm and variable business logic and, therefore, make the algorithm applicable to general use cases. The code below shows the simplified version of my first draft sent to gemini-code-assist for review:

TIP

• The irrelevant codes, such as Javadoc, imports, null-checks, etc., have been removed to highlight the essentials
• The complete conversation between AI and me can be found in the original pull request

1
public interface NodeVisitor {
2

3
    void visit(AbstractNode node);
4
}

1
public abstract class AbstractNode {
2

3
    void accept(final NodeVisitor visitor) {
4
        visitor.visit(this);
5
    }
6
}

1
public static void traverse(final AbstractNode startNode, final NodeVisitor visitor) {
2
    final Deque<AbstractNode> queue = new ArrayDeque<>(Collections.singleton(startNode));
3
    final Set<String> visited = new HashSet<>(Collections.singleton(startNode.getLabel()));
4

5
    while (!queue.isEmpty()) {
6
        final AbstractNode currentNode = queue.removeFirst();
7
        currentNode.accept(visitor);
8
        for (final AbstractNode neighbor : currentNode.getNeighbors()) {
9
            if (!visited.contains(neighbor.getLabel())) {
10
                visited.add(neighbor.getLabel());
11
                queue.addLast(neighbor);
12
            }
13
        }
14
    }
15
}

Having analyzed the code above, the Gemini AI review found a performance issue and argued that if traverse method is applied to a large dataset, the while loop above could take a lot of time. So the AI figured out a way for the early termination of the loop with the following review comments:

Basically, the AI is asking me to break the strict Visitor pattern for a performance gain by changing the return type of NodeVisitor.visit(AbstractNode node) from void to boolean. This almost immediately triggered my opposition and I left my response as follows:

My response focused on telling AI returning boolean in this case was not a standard Visitor practice. The AI, however, is resisting with the following followup:

Man what a thoughtful challenge… What’s interesting though is I started to feel a common tension in software design: balancing strict adherence to a pattern’s principles with real-world performance needs. I keep defending the void return in visit

The story went on…The original pull request had all the followup details and it’s enough for us to transcendentalize the topic:

• The AI really masters communicating professionally in the tech debate, and more importantly
• I started to ask: what are the two conflicting philosophical or psychological ideologies behind this BFS design debate between human and machine?

Turning Point - From “Code Review Debates” to “Ideologies Conflicts”#

The debate over the void versus boolean return type for a visit method in a BFS Visitor pattern implementation, particularly concerning early termination, actually stems from two conflicting philosophical or psychological ideologies in software design: Purism (or Idealism) vs. Pragmatism

Idealism champions strict adherence to design patterns and principles (like the Single Responsibility Principle and Command-Query Separation). From a purist perspective, the Visitor’s sole responsibility is to perform an operation on the visited element, not to dictate the flow of the traversal. Returning a boolean for control flow introduces a coupling that compromises the pattern’s intended separation of concerns. The traversal algorithm (BFS) should be generic and complete its traversal of reachable nodes, while the Visitor focuses purely on the element-specific action. This approach values the elegance, maintainability, and long-term extensibility that comes from clear, decoupled responsibilities.

Idealism favors the perspective of Generality, which emphasizes creating reusable, broadly applicable algorithms. The traverse method designed for generality aims to visit all reachable nodes, regardless of the visitor’s internal goal. It’s a foundational traversal primitive. Making it stop early based on a visitor’s signal would specialize it into a “search-and-terminate” algorithm, potentially limiting its utility for other scenarios that genuinely require a full traversal (e.g., calculating graph properties, building a complete map of connections). This aligns with the idea of building robust, foundational components.

Pragmatism, on the other hand, prioritizes practical outcomes and efficiency over strict theoretical purity. A pragmatic designer would argue that if a slight deviation from a pattern’s rigid definition (like returning a boolean from visit) leads to significant performance improvements (e.g., avoiding unnecessary computation on large graphs), it’s a worthwhile trade-off. The goal is to build effective software that meets real-world demands, and sometimes that means adapting patterns to fit specific performance requirements. This approach values utility, performance, and solving immediate problems efficiently.

Pragmatism possesses the viewpoint of specific optimization that focuses on optimizing for a particular use case, such as finding a target node as quickly as possible. For this specific scenario, continuing the traversal after the target is found is clearly inefficient. The argument is that if a common and critical use case (like searching) can be made significantly faster by a minor adjustment to the API, that optimization should be considered. This prioritizes the performance of a frequently executed operation over the absolute theoretical purity of the general traversal.

The Two Conflicting Personalities behind the Two Software Design#

Different personality types can drive these software design debates as well. In the context of the BFS visitor pattern discussion, two conflicting personalities often emerge: the Architect and the Hacker.

CAUTION

“Architect” in this section is NOT to be confused with the “Architect” within the Myers-Briggs Type Indicator (MBTI) framework. The use of “Architect” and “Hacker” was intended to describe archetypes or roles in software development, representing distinct philosophical approaches to design, rather than strictly adhering to formal psychological personality typing systems like the 16-Personality scheme. The fact that MBTI also has an “Architect” (INTJ) type, which often describes individuals with strong logical, strategic, and planning tendencies, is a coincidence of terminology

What Different Past Personal Experiences Could Lead to Such a Diverted World-View like Architect v.s. Hacker?#

Why Does AI Favors Hacker Mindset?#

The fact that AI code reviewer leans towards a “Hacker” ideology highlights some fundamental differences between how humans and current AI models “think” about software design.

Turning Point - From “Ideologies Conflicts” to “Philosophical Standing”#

In a conceptual way, the tension between the “Hacker” and “Architect” ideologies in software design mirrors the philosophical conflict between Determinism and Libertarianism regarding free will. The AI, operating on statistical determination, naturally gravitates towards the most “efficient” or “effective” solution based on its training data, much like a deterministic universe unfurls according to its laws. Humans, imbued with psychological depth and the subjective experience of free will, introduce values and long-term considerations that go beyond immediate, calculable efficiency, much like a libertarian agent makes choices that are not solely dictated by prior causes.

Philosophy Review

• Determinism: The philosophical view that all events, including human actions and choices, are ultimately determined by prior causes and the laws of nature. If we knew all the preceding conditions and laws, we could, in principle, perfectly predict the future. From this perspective, “free will” in the sense of truly uncaused choices is an illusion.
• Libertarianism (Metaphysical): The philosophical view that at least some human actions are genuinely free, meaning they are not entirely determined by prior causes. It posits that agents (people) have the power to make real choices and “could have done otherwise” under the exact same circumstances. This often implies some form of indeterminism in the universe, particularly regarding human consciousness or decision-making.

Hacker, with AI’s Deterministic Nature, aligns with the philosophical idea that all events are causally predetermined. Current AI models, including large language models, are fundamentally deterministic. Their “decisions” and outputs are the result of complex algorithms, statistical probabilities learned from vast datasets, and intricate mathematical computations. Given the exact same input and internal state, an AI will, in principle, produce the exact same output. This is a highly determined process with no “magic” or uncaused choice; it’s a consequence of its programming and training data. AI doesn’t possess consciousness, subjective experience, or emotions in the human sense. Its “favoring” of a “Hacker” approach isn’t a feeling-driven preference but a statistically determined outcome based on its optimization functions (e.g., speed, efficiency) and the characteristics of the data it was trained on (e.g., competitive programming solutions, open-source projects where quick fixes are common).

Our decisions are influenced by a complex interplay of emotions, personal values, past experiences (both positive and negative, as we discussed), cognitive biases, intuition, and a sense of purpose or moral responsibility. These “feelings” and “psychological states” are internal, subjective, and contribute to our perception of genuine choice. The Architect, driven by these complex psychological and emotional factors (e.g., the “pain of technical debt,” the “satisfaction of elegant design,” the “desire for future stability”), makes conscious choices about design. They choose to prioritize maintainability and extensibility, even if it means a slower initial development, believing they “could have done otherwise” (i.e., chosen the quick hack). This subjective sense of agency and values-driven decision-making aligns with the spirit of libertarianism and human’s experiential Free Will. Humans experience free will and agency. We feel as though we make genuine choices that are not entirely pre-determined. This aligns with the core tenet of libertarianism - the ability to “do otherwise.”

Can AI, despite its deterministic nature, ever truly “feel” and achieve the level of abstract, value-laden reasoning that humans, particularly an “Architect” type, demonstrate? The short answer, based on the current state of the art of AI, is No, not in the way humans do, and it’s highly debatable if it ever will. Deterministic algorithm and data analysis face the challenge of explaining why and how physical processes in the brain give rise to subjective experience - the “what it’s like” to see red, feel pain, or experience the satisfaction of elegant code. Instead, current AI, even the most advanced, simulates understanding and emotion. It processes vast amounts of data, recognizes patterns, and generates responses that mimic human feelings or reasoning. When an AI “says” it’s happy, it’s because its algorithms have determined that, given its input context, a human would likely express happiness, and it has been trained to produce corresponding outputs. It does not feel happiness. The deterministic nature of AI means its “behavior” is entirely predictable given its initial state and inputs. Feelings and qualia, as we understand them, are not reducible to algorithmic computations or statistical probabilities. There’s no current scientific theory that explains how running a neural network, no matter how complex, fundamentally transforms into a subjective “feeling.” Many philosophers argue that unless AI somehow replicates the biological substrates or emergent properties that give rise to consciousness in biological systems, it will remain in the realm of sophisticated simulation, not genuine experience.

In addition, the Architect’s preference for “elegant design,” “maintainability,” “extensibility,” and “reducing technical debt” isn’t purely logical. It’s deeply intertwined with human values:

• Understanding the cognitive load and frustration another human will experience when working with messy code.
• Projecting how a system will evolve over years, anticipating human needs and business changes.
• Finding beauty and satisfaction in well-structured, clean, and harmonious designs.
• Designing for fairness, privacy, and societal impact.

On the contrary, while AI can excel at complex pattern matching and even perform impressive feats of “creativity” (e.g., generating art, music, code), its underlying mechanism is still statistical inference. It doesn’t possess genuine causal understanding or “common sense” in the way humans do. An AI can only “reason” about values if those values are explicitly or implicitly encoded in its training data or reward functions. It doesn’t intrinsically “feel” or decide that maintainability is good; it learns from patterns where maintainable code led to desirable outcomes (as defined by humans). It doesn’t have its own subjective values. AI’s decisions are determined. It cannot “choose” to prioritize elegance over speed unless that choice is a pre-programmed or statistically derived outcome of its algorithms. It lacks the libertarian sense of genuine, uncaused choice that underlies human intentionality and the formation of personal values.

(To be continued…)