According to TheRegister.com, MIT researchers Eagon Meng and Daniel Jackson have proposed a new software architecture model designed to fix what they call “illegible” modern software. Their paper details how current coding practices, especially when using LLMs, suffer from insufficient modularity and lack direct correspondence between code and behavior. The researchers argue this leads to failures in incrementality, integrity, and transparency – problems that become especially apparent when LLMs modify existing codebases. They’re proposing a system built around “concepts” and “synchronizations” that could make software more predictable and reliable. This approach specifically targets the phenomenon they call “vibe coding” where AI-generated results are unpredictable and each new coding step risks breaking previous functionality.
The vibe coding problem
Here’s the thing about current AI coding assistants – they’re kind of a mess when you try to build anything substantial. The researchers point out that when LLMs add code to existing repositories, it’s hard to control which modules get modified or ensure existing functionality doesn’t break. Programmers constantly complain that AI suggestions often break previously working code. And those “build a whole app” AI tools? They hit undefined complexity limits pretty quickly. Basically, we’ve got this situation where AI coding tools are everywhere – GitHub’s data shows they’ve even helped make TypeScript the platform’s top language – but the fundamental architecture of how we build software hasn’t evolved to handle AI’s particular strengths and weaknesses.
Concepts and synchronizations
So what’s the alternative? Meng and Jackson want us to break systems into “concepts” – user-facing units of functionality with well-defined purposes. Think of a social media app having concepts like “post,” “comment,” and “friend.” Each concept structures both the user experience AND the underlying implementation. They’re similar to microservices but without the tangled web of dependencies that can call or query each other’s state directly. Instead, concepts get orchestrated by an application layer using what they call “synchronizations” that act like contracts spelling out exactly how concepts interact. This means you could potentially run concept instances on different servers with synchronizations keeping everything in step.
Why this matters for AI
The real breakthrough here might be how this architecture plays with AI. Because synchronizations are explicit and declarative, LLMs can actually analyze, verify, and generate them reliably. We’re talking about moving from unpredictable “vibe coding” to something where AI tools can understand the structure and constraints of a system. The researchers imagine catalogs of well-tested, domain-specific concepts that both human and AI coders could incorporate. You’d still have to deal with feature interactions, but now that complexity would be out in the open rather than scattered and obscured. It’s essentially giving AI a framework it can actually work within instead of just guessing at structure.
The bigger picture
This isn’t just about making AI coding better – it’s about addressing fundamental flaws in software development that AI has simply exposed. The tech giants have poured billions into LLMs with promises of rationalizing development teams, but if AI can’t work incrementally while maintaining integrity, those promises might hit serious limits. The timing is interesting too – just as “vibe coding” makes it into the dictionary, researchers are proposing an architecture that would make it obsolete. Whether this particular approach gains traction remains to be seen, but it highlights that we probably need to rethink how we structure software if we want AI to be more than just a fancy autocomplete.
