Researchers propose a new model for readable, modular software

Coding with large language models (LLMs) is promising, but it also exposes some long-standing flaws in software: code that is messy, difficult to change securely, and often unclear about what’s really happening under the hood. Researchers at MIT’s Computer Science and Artificial Intelligence Laboratory (CSAIL) are charting a more “modular” path.

Their new approach breaks systems down into “concepts,” individual parts of a system, each designed to do one task well, and “syncs,” explicit rules that describe exactly how those pieces fit together. The result is software that is modular, more transparent and easier to understand.

A small domain-specific language (DSL) allows synchronizations to be expressed easily, in a form that LLMs can reliably generate. In a real-world case study, the team showed how this method can bring together functions that would otherwise be spread across multiple services. The article is published in the Proceedings of the 2025 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software.

The team, including Daniel Jackson, an MIT professor of electrical engineering and computer science (EECS) and CSAIL associate director, and Eagon Meng, an EECS Ph.D. student, CSAIL affiliate and designer of the new synchronization DSL, explore this approach in their paper “What You See Is What It Does: A Structural Pattern for Readible Software,” which they presented at the Splash conference in Singapore in October.

The challenge, they explain, is that in most modern systems a single function is never completely isolated. For example, adding a ‘share’ button to a social platform like Instagram doesn’t happen in just one service. The functionality is spread across code that handles posting, notifications, user authentication, and more. All these pieces, despite being scattered throughout the code, must be carefully coordinated, and any change risks unintended side effects elsewhere.

Jackson calls this “feature fragmentation,” a central obstacle to software reliability. “The way we build software today, the functionality is not localized. You want to understand how sharing works, but you have to look for it in three or four different places, and when you find it, the connections are hidden in low-level code,” says Jackson.

Drafts and syncs are intended to address this issue. A concept bundles one coherent piece of functionality, such as sharing, liking, or following, along with its state and the actions it can take. Synchronizations, on the other hand, describe at a higher level how these concepts interact.

Instead of writing messy low-level integration code, developers can use a small domain-specific language to spell out these connections directly. In this DSL, the rules are simple and clear: the action of one concept can trigger another action, so that a change in one part of the state can remain in sync with another.

“Think of concepts as modules that are completely clean and independent. Synchronizations then act like contracts: they tell you exactly how concepts should communicate with each other. That’s powerful because it makes the system both easier for people to understand and easier for tools like LLMs to generate correctly,” says Jackson.

“Why can’t we read code like a book? We believe that software should be readable and written in terms of our understanding: our hope is that concepts refer to known phenomena, and that synchronizations represent our intuition about what happens when they come together,” says Meng.

The benefits extend beyond clarity. Because synchronizations are explicit and declarative, they can be analyzed, verified and of course generated by an LLM. This opens the door to safer, more automated software development, where AI assistants can suggest new features without introducing hidden side effects.

In their case study, the researchers mapped functions like liking, commenting, and sharing to a single concept, like a microservices architecture, but more modular. Without this pattern, these features were spread across many services, making them difficult to locate and test. Using the concepts-and-synchronization approach, each function was centralized and readable, while the synchronizations described exactly how the concepts interact.

The study also showed how synchronizations can eliminate common concerns such as error handling, response formatting, or persistent storage. Rather than embedding these details in each service, Sync can handle them once, ensuring consistency across the system.

More advanced directions are also possible. Synchronizations can coordinate distributed systems, keep replicas on different servers in line, or ensure that shared databases can communicate gracefully with each other. Weakening the synchronization semantics could enable eventual consistency while still maintaining clarity at the architectural level.

Jackson sees potential for a broader cultural shift in software development. One idea is to create “concept catalogs,” shared libraries of well-tested, domain-specific concepts. Application development could then become less a matter of piecing together code and more about selecting the right concepts and writing the synchronizations between them.

“Concepts could become a new kind of high-level programming language, with synchronizations if the programs are written in that language. It’s a way to expose the connections in software,” says Jackson. “Today we hide those connections in code. But if you can see them explicitly, you can reason about the software at a much higher level. You still have to deal with the inherent complexity of the interaction between functions. But now it’s overt, undistributed and unclear.”

“Building software for human use based on abstractions of underlying computing machines has burdened the world with software that is too often expensive, frustrating, and even dangerous to understand and use,” said Associate Professor Kevin Sullivan of the University of Virginia, who was not involved in the study.

“The consequences (such as in healthcare) have been devastating. Meng and Jackson flip the script and insist on building interactive software based on abstractions of human understanding, which they call “concepts.” They combine expressive mathematical logic and natural language to specify such purposeful abstractions, providing a basis for verifying their meanings, compiling them into systems, and refining them into programs suitable for human use. It is a new and important direction in the theory and practice of software design that worth keeping an eye on.”

“It’s been clear for years that we need better ways to describe and specify what we want software to do,” said Thomas Ball, an honorary professor at Lancaster University and affiliated faculty at the University of Washington, who also was not involved in the study. “The ability of LLMs to generate code has only fueled the specification fire. Meng and Jackson’s work in concept design provides a promising way to describe what we expect from software in a modular way. Their concepts and specifications are well suited to be combined with LLMs to realize the designer’s intentions.”

Looking ahead, the researchers hope that their work can influence the way both industry and academia think about software architecture in the age of AI. “For software to become more reliable, we need ways to write it that make its intentions transparent,” Jackson says. “Concepts and Syncs are a step toward that goal.”