Actually, the idea was quite different to begin with, but it has evolved bit by bit. My aim was not just to feed an AI with good prompts, as with Vibe Computing, but to annotate the code as it is generated. These annotations can then be used by alternative LLMs to preserve the context. It has grown somewhat since then.
When starting a software project, a business application, a tool, a game, you so far opened your code editor. And then … the blank scree stares back. You start thinking about boilerplate, environment variables, dependency hell, and the specific syntax of a framework that updated three hours ago.
But what if the “how” of coding became invisible? What if your only job was the “what” and the “why”?
Welcome to the era of Prompt-Loop Development, powered by a new framework I’m working on: SDAIS (Specification-Driven AI Synthesis). It’s a fundamental shift from being a bricklayer to being an architect. In this workflow, you provide the vision and the constraints, and SDAIS orchestrates a tag-team of LLMs to handle the heavy lifting through a series of intelligent, self-correcting loops.
No Single Prompt anymore
When LLMs first hit the scene, we tried to do everything in one go. “Write me a full-stack e-commerce site,” we’d say. The result? A messy, hallucinated pile of code that broke the moment you tried to run it.
The breakthrough isn’t just in finding a “smarter” model; it’s in a smarter process. Instead of one giant leap, SDAIS takes hundreds of tiny, coordinated steps. It treats software development like a high-end manufacturing line rather than a magic trick.
How the SDAIS Loop Actually Works
Imagine a digital assembly line where you are the Foreman. You don’t touch the tools; you provide the blueprints. Here is how this “no-code-coding” process unfolds within the SDAIS framework:
- The Intent Phase (That’s You!): You define the requirements and, more importantly, the constraints. “I need a task manager. It must be written in Python, use a local SQLite database, and the UI should look like a 1990s terminal.” You set the guardrails—no external APIs, must run on Linux, keep it under 500 lines.
- A SemanticAuditor helps finding inconsistencies in your requirements.
- The Architect Loop: The first LLM takes your prompt and breaks it into a technical roadmap. It doesn’t write code yet; it defines the logic, the data structures, and the flow.
- The Builder Loop: A second LLM (or a specialized coding model) takes that roadmap and generates the first draft.
- The Critic Loop: This is where the magic happens. A third LLM reviews the code against your original constraints. It looks for bugs, missing features, or “hallucinations.” If it find an error, it sends it back to the Builder with specific notes.
- The Refinement Loop: The cycle repeats until the software meets every single one of your requirements. The human only steps in to approve the final product or pivot the direction.
Why This Changes Everything
This isn’t just about speed—though it is incredibly fast. It’s about democratizing creation.
- For the Seasoned Dev: It’s a superpower. You can prototype a complex backend in the time it takes to grab a coffee. You stop worrying about syntax and start focusing on system design and user experience.
- For the Visionary: The barrier to entry has vanished. If you can describe a problem clearly and understand the constraints of your environment, you can build professional-grade software. You don’t need to spend six months learning how to optimally use concurrency in RUST if SDAIS can handle the implementation while you focus on the business logic.
Living Within the Constraints
In the SDAIS world, constraints are your best friend. In traditional coding, constraints are annoying limits. In Prompt-Loop Development, constraints are the “guardrails” that keep the AI on track.
By telling the LLM what it can’t do, you’re actually helping it find the solution faster. “Don’t use external CSS libraries” or “Ensure all data is encrypted at rest” provides a narrow path for the AI to follow, resulting in much cleaner, more reliable output.
The SDAIS Philosophy: Focus on the boundaries, and the AI will fill the center.
What’s Next? The SDAIS Deep-Dive
This is just the beginning of the journey. I’m rolling out a comprehensive series to help you master this new way of building. Over the next few weeks, we’ll be dropping three essential guides:
- The SDAIS Introduction: A deep dive into the philosophy, the tech stack, and how to set up your first multi-LLM environment.
- The Greenfield Guide: How to use SDAIS to build a brand-new project from scratch, moving from a single idea to a working prototype in record time.
- The Re-Engineering Playbook: How to point SDAIS at “spaghetti code” or legacy systems to refactor, modernize, and fix bugs without breaking the core logic.
The first Greenfield project with earlier versions of SDAIS worked already fine. Now I’m working on a second one, got a third one in my mind, and also my first re-engineering project. I’ll write about too.
If all works fine source code may become only a context artifact in different projects architectures. The new syntax is the writing of requirements.
Take a look at https://codeberg.org/tideland/sdais and see how it grows.
The loops are waiting. Are you ready to lead them?
Stay tuned for Part 1: The SDAIS Foundations.
