The AI Engineer Mindset - Part 3: Creative Tension

In this part, we examine the intensified creative-rigor tension and introduce the gardening metaphor. Building on Part 1’s orchestration and Part 2’s metacognition.

TL;DR

• AI intensifies the creativity-rigor tension by making generation nearly free
• The premium skill becomes discernment and refined taste
• Develop intuition for “alive” code vs sophisticated cargo culting
• Think of development as gardening living systems, not building monuments
• Reality testing and rigorous validation become non-negotiable

Creativity and rigor have always existed in tension for engineers. AI doesn’t resolve this tension—it intensifies it magnificently.

“In the beginner’s mind there are many possibilities, but in the expert’s there are few.” - Shunryu Suzuki

On the creative side, the liberation is profound. You can explore absurd ideas with almost zero cost. “What if we modeled our entire business domain as a living ecosystem with agents and resources instead of traditional CRUD operations?” The AI will enthusiastically build that world with you, showing consequences, edge cases, and emergent behaviors before you’ve written more than a few paragraphs of specification.

This is where expressing goals over actions becomes magical. By stating the desired properties and behaviors rather than the implementation, you allow the AI to explore solution spaces you might never have considered.

But this creative freedom demands correspondingly greater discipline on the rigor side. When generation is nearly free, the premium skill becomes discernment. Every suggestion, no matter how elegant, must be subjected to reality testing—performance benchmarks, security analysis, maintainability review, ethical consideration.

The most skilled practitioners develop what I can only describe as refined taste: an almost intuitive sense for what code feels alive and coherent versus what feels like sophisticated cargo culting. They can smell when an AI solution is papering over a fundamental misunderstanding of the domain.

Alive Code vs Cargo Cult Code

What is Cargo Culting?

The term comes from post-WWII Pacific islands where indigenous people built mock airstrips and control towers from bamboo and straw, imitating the structures they’d seen during the war. They hoped cargo planes would return with supplies. They replicated the form without understanding the function.

In software, cargo cult programming means copying patterns, syntax, and structures that look like good code—they have the right shape, the right keywords, the fashionable abstractions—but miss the underlying purpose. The code compiles. It might even pass basic tests. But it doesn’t actually solve the problem correctly because the developer (or AI) didn’t understand why the pattern exists.

AI is particularly prone to this because it pattern-matches across millions of examples without genuine comprehension. It can generate code that looks professional but lacks domain understanding.

Consider two implementations of a caching layer:

Sophisticated Cargo Culting:

class CacheManager:
    def __init__(self):
        self.cache = {}
        self.locks = {}

    async def get_or_compute(self, key, compute_fn):
        if key not in self.locks:
            self.locks[key] = asyncio.Lock()

        async with self.locks[key]:
            if key in self.cache:
                return self.cache[key]
            result = await compute_fn()
            self.cache[key] = result
            return result

Looks reasonable, right? It has locks, async/await, clean structure. But:

• Locks dictionary grows unbounded (memory leak)
• No TTL or eviction (stale data accumulates)
• No error handling if compute_fn fails
• Lock persists even for one-time keys

The AI generated “cache-like” code by pattern-matching solutions, but missed the domain reality.

Alive Code:

class CacheManager:
    def __init__(self, max_size=1000, ttl_seconds=300):
        self.cache = {}
        self.lock = asyncio.Lock()  # Single lock, simpler
        self.access_times = {}
        self.max_size = max_size
        self.ttl = ttl_seconds

    async def get_or_compute(self, key, compute_fn):
        async with self.lock:
            # Check if cached and fresh
            if key in self.cache:
                age = time.time() - self.access_times[key]
                if age < self.ttl:
                    return self.cache[key]
                else:
                    del self.cache[key]  # Expired

            # Evict oldest if at capacity
            if len(self.cache) >= self.max_size:
                oldest = min(self.access_times.items(), key=lambda x: x[1])
                del self.cache[oldest[0]]
                del self.access_times[oldest[0]]

            try:
                result = await compute_fn()
                self.cache[key] = result
                self.access_times[key] = time.time()
                return result
            except Exception as e:
                # Don't cache failures
                raise

This version understands the purpose of caching: bounded memory, freshness guarantees, failure handling.

Developing Refined Taste

How do you learn to spot the difference?

1. Question Everything

• What happens under load?
• What happens when this fails?
• What invariants must hold?
• What resources does this consume?

2. Reality Test Systematically

• Trace execution paths mentally
• Identify edge cases: empty inputs, concurrent access, failure mid-operation
• Ask: “What would break this?”

3. Study Production Failures

• Every bug in AI-generated code teaches pattern recognition
• Build a mental library of “smells” (unbounded growth, missing timeouts, uncaught exceptions)

4. Compare to Hand-Crafted Solutions

• Write critical components yourself first
• See what AI generates
• Notice what it missed

5. Use Metrics as Reality Checks

• Performance benchmarks
• Memory profiling
• Load testing
• Code coverage

If it passes metrics but feels wrong, dig deeper. If it feels right but fails metrics, trust the data.

The Gardening Metaphor

Returning to the core tension between creativity and rigor, the metaphor that works best is gardening rather than building. You are not constructing a static monument. You are creating the conditions in which complex, adaptive systems can grow. You plant seeds of ideas, provide the right nutrients (context, constraints, examples), nurture what takes root in reality, prune ruthlessly, and remain open to unexpected beauty emerging from the interactions.

Your AI agents are simultaneously the soil, the fertilizer, the weather, and the pruning shears. Powerful tools, but completely dependent on your vision and ongoing direction.

The Gardening Mindset in Practice

Concretely, this means:

• Plant seeds: Provide AI with clear outcome goals and rich context
• Provide nutrients: Add constraints, examples, edge cases as needed
• Observe growth: Watch what patterns emerge from the AI’s suggestions
• Prune ruthlessly: Cut anything that doesn’t serve the domain model
• Allow emergence: Sometimes the best solution isn’t what you initially envisioned

You are not constructing a cathedral from a blueprint. You are cultivating a living codebase that must adapt, evolve, and respond to real-world pressures.

Key Takeaways

• AI intensifies the creative-rigor tension, demanding refined discernment
• Treat development as gardening living systems rather than building monuments
• Explore ideas with zero cost using outcome-focused goals
• Develop refined taste through questioning, reality testing, and metrics
• Recognize cargo cult code by checking resource handling, error paths, and invariants

In Part 4, we explore what it means to become native to this new medium of conversational creation.