Software development isn't about writing code — it's about discovering constraints. But humans need surfaces to push against, like sculptors working with clay. Modern tools can create these surfaces, letting us naturally explore complex systems through interaction rather than formal specification.
Software development isn't what we think it is. For decades, we've trained developers to be both architects and artists, to write code that is simultaneously precise and elegant. But this approach misses a fundamental truth: what we're actually doing is discovering and navigating constraints, often in the dark, feeling our way through complex spaces we can barely comprehend.At CharmIQ we use Google's NoSQL database Firestore for all of our documents. (For example, this document has been written, edited and published using Firestore.) What seems like straightforward technical requirements — storing and querying documents — reveals itself as an intricate constraint problem. Firestore's security rules must exactly match query patterns. Document structure must anticipate access patterns. Query limitations affect how data can be filtered and sorted. These weren't separate concerns to be tackled individually. They formed an interconnected set of constraints that had to be solved holistically.every piece of software is just one solution to a constraint problem we're still learning how to articulateThink about what happens when a developer encounters a new codebase. They can't simply read the code to understand the system — because code is just one possible solution to an unspoken set of constraints. It's like being handed a photograph of a sculpture and being asked to understand the forces that shaped it. The real challenge isn't reading the code; it's reconstructing the invisible constraints that led to its creation.Here's the breakthrough: instead of forcing developers to juggle these constraints mentally, we can create surfaces that make them visible and interactive. The combination of large language models (LLM) and declarative systems like Answer Set Programming (ASP) offers a way forward. Using ASP, we can transform Firestore's complex query rules from documentation into executable logic. Rather than hoping developers remember all possible interactions between security rules, query patterns, and data structure, we can create systems that actively surface these constraints during development. We can explore possibilities conversationally while ensuring our solutions remain grounded in logical consistency.This shift in how we surface and interact with constraints reveals something profound about software development expertise. We've traditionally created specialists who essentially become living embodiments of constraint knowledge. Senior developers aren't just coding experts — they're constraint cartographers who've spent years building mental maps of complex systems. When we "bounce ideas off them," we're literally using them as surfaces to push against, testing whether our proposals satisfy constraints they've internalized through experience.Software development isn't what we think it isEven our tools and methodologies reflect this reality. Object-oriented programming, design patterns, abstraction layers. These aren't just organizational techniques. They're coping mechanisms we've developed to manage the cognitive load of constraint discovery. Each abstraction is really an attempt to box up understood constraints so we can focus our limited mental energy elsewhere.Previous attempts at modeling software requirements have fallen short. From business process modeling to UML, we've tried to create separate systems for capturing these constraints. But these efforts always feel divorced from reality because they try to separate constraint modeling from the working system. It's like trying to understand a river by studying its map — you need both the map and the water.We've been doing constraint discovery all along; we just haven't had the right vocabulary or tools to acknowledge it. Combining LLMs and ASP represent a fundamental shift in how we can approach software development. Instead of relying solely on human expertise to embody and navigate constraints, we can create interactive spaces where constraints become visible, testable, and explorable. This isn't just a new methodology — it's a recognition of what software development has always been about.The future of software development isn't about writing better code — it's about building better ways to discover, understand, and navigate constraints. Because at its heart, every piece of software is just one solution to a constraint problem we're still learning how to articulate.
Intelligence isn't about absorbing patterns. It emerges from testing boundaries and discovering constraints. Whether physical or abstract, all understanding comes from having something to push against.7 January 2025
Through the interplay of logical rules and relationships, systems aren't built but grown — emerging naturally from the boundaries we define, transforming traditional development into a dialogue of discovery where every constraint reveals new clarity.11 January 2025
