Scaffolded Stigmergy

Remember when we used to know what we were building before we built it? How quaint.

These days, I ship complex software faster by not knowing exactly what I'm building when I start. I'll have a rough idea—a use case, maybe a prompt, definitely some caffeine-fueled ambition. But the details? I figure that shit out as I go.

The secret isn't better planning. It's Scaffolded Stigmergy.

What The Hell Is Scaffolded Stigmergy

It's how ants build cities without architects.

Stigmergy is coordination through environmental modification. One ant drops a pheromone, another follows, pretty soon you've got superhighways to food sources. No central planning required.

Now imagine that—but with code. You and your AI co-pilot leave traces in a codebase that guide each successive iteration.

The "scaffolded" part? Structure you impose upfront to prevent the codebase from becoming a choke-base. Project boundaries, type systems, naming conventions—enough guardrails to prevent wandering into Crazytown.

Bottom-up evolution within top-down constraints. Darwin meets architecture.

How I Actually Build Things Now

Create the scaffolding: High-level PRD, thoughtful file organization, core types, clear naming conventions, system prompt that captures the project's vibe. Not waterfall planning—breadcrumbs for future decisions.

Build in traces: Each piece of code leaves evidence. Naming patterns, file structure, schemas, comments, refactors. These accumulate. The AI picks up on them. The codebase develops its own personality.

Refactor relentlessly: Clean traces create better feedback loops. Messy code generates messy AI outputs generates messier code. Clean code generates clean AI outputs generates cleaner code. The system either spirals up or spirals down.

But You're Just Winging It

Am I though?

Old approach: think really hard → plan everything → implement the plan. Worked when requirements were stable and humans were the bottleneck.

This approach: establish constraints → iterate rapidly → let patterns emerge. Works better when requirements shift constantly and AI amplifies your capabilities.

I'm not winging it—I'm optimizing for a different kind of predictability. Instead of predicting what I'll build, I'm predicting how I'll build it.

The AI Isn't Magic

People assume AI coding means you write one perfect prompt and get perfect code back. That's not how any of this works.

The AI is a pattern completion engine that happens to be really good at code patterns. It works best when reacting to existing structure—your types, your style, your mistakes, your corrections.

Think of it less like an assistant and more like a jazz musician. You lay down a chord progression (your scaffold), start improvising (your traces), and it improvises back. The magic happens in the feedback loop.

Why This Actually Works

Context accumulation: Each decision creates context for the next decision. The codebase becomes increasingly coherent without explicit design.

Rapid iteration: You're not trying to get everything right upfront. You're getting closer to right with each pass.

Emergent understanding: You don't need to fully understand the problem to start solving it. Understanding emerges through building.

AI amplification: Your AI co-pilot gets better at helping as it understands the patterns you're establishing.

The system becomes smarter over time instead of more complicated.

When This Fails Spectacularly

Scaffolded stigmergy isn't a silver bullet. It fails when:

• Your scaffold is too weak (not enough constraints)
• Your traces are inconsistent (confusing signals)
• You skip the refactoring step (entropy wins)
• The problem domain is too novel (no useful patterns to leverage)

It works best for building things where you can recognize good patterns when you see them, even if you couldn't design them from scratch.

The Real Shift

We're moving from "design then build" to "build toward design." The old way optimized for avoiding mistakes. The new way optimizes for learning from them.

With AI as an amplifier, the cost of iteration approaches zero. So why not iterate?

Instead of spending weeks architecting the perfect system, spend hours building the wrong system and letting it tell you what it should be.

Try This

Next time you're building something complex:

1. Create minimal scaffolding (don't overthink it)
2. Start coding with AI assistance
3. Pay attention to the patterns that emerge
4. Refactor aggressively to reinforce good patterns
5. Let the system tell you what it wants to become

Stop waiting to fully understand the problem. Start building to understand it.

The ants figured this out millions of years ago. Time to catch up.

---