Most software today is a mess. Not because developers aren’t smart or capable. It’s because the way we build systems makes it nearly impossible to see what’s actually happening.

MIT researchers have proposed a framework that could change that. They’re breaking software down into “concepts” and “synchronizations.” It’s a simpler way to think about how code works, and it could make software development safer and more transparent.

The Problem With How We Build Software Today

Here’s what happens in most modern applications. You want to add a feature like “share this post.” Simple enough, right?

Not really. That one feature gets split across multiple services. Part of it lives in the posting code. Part lives in notifications. Part lives in user authentication. And part lives somewhere else entirely.

MIT professor Daniel Jackson refers to this as “feature fragmentation.” You can’t look in one place to understand how sharing works. You have to hunt through three or four different parts of the codebase. The connections between these parts are buried in low-level code.

When you need to change something, you’re taking a risk. You might break something in a completely different part of the system. You won’t know until it happens.

This isn’t just annoying. It’s dangerous. It makes software harder to maintain, test, and trust.

Breaking Things Down Into Concepts

The MIT team, including Jackson and PhD student Eagon Meng, suggests a different approach. They break systems into two parts: concepts and synchronizations.

A concept is a piece of software that excels at one specific task. Think of it like a self-contained module. It could be “sharing,” “liking,” “following,” or “commenting.” Each concept has its own state and its own actions.

The key is that each concept is independent. It doesn’t depend on other parts of the system to work. You can understand it on its own.

Synchronizations are the rules that describe how concepts relate to each other. They spell out exactly how one concept interacts with another. Instead of writing messy integration code, you use a small domain-specific language to define these connections.

Meng puts it this way: “Why can’t we read code like a book? We believe that software should be legible and written in terms of our understanding.”

Why This Matters for LLMs and AI Coding Tools

This approach has benefits beyond making code easier to read. Because synchronizations are explicit and clear, they can be analyzed by tools. More importantly, they can be generated by large language models.

Currently, LLMs can generate code. But they can also introduce bugs and side effects. That’s partly because modern software is so fragmented. When an AI attempts to add a feature, it must identify all the hidden connections between different parts of the system.

With concepts and synchronizations, those connections aren’t hidden. They’re spelled out clearly. An LLM can see exactly how the pieces fit together. That makes it easier to generate correct code without breaking things.

The MIT researchers tested this in a real-world case study. They assigned features like liking, commenting, and sharing to individual concepts. Without this pattern, those features were scattered across many services. With it, each feature became centralized and testable.

They also demonstrated how synchronizations can address common concerns, such as error handling and data storage. Instead of writing that logic over and over, you write it once in the synchronization layer.

What This Could Mean for DevOps Teams

For DevOps teams, this matters because it addresses one of the most challenging aspects of continuous deployment: understanding what will break when a change is made.

If you can see how features connect at a high level, you can reason about the impact of a change before you deploy it. You’re not guessing. You’re working with a clear map of the system.

According to Mitch Ashley, VP and practice lead, software lifecycle engineering,The Futurum Group, “MIT’s concept and synchronization model gives large language models something they’ve never had in software development: Visibility into how systems actually work. Today’s AI coding tools struggle because feature logic is scattered across codebases. This framework makes relationships explicit, allowing LLMs to reason about behavior instead of guessing where connections live.”

Ashley continues, “For DevOps teams, this could bring a new level of predictability. When features and dependencies are clearly mapped, AI and automation can evaluate the impact of change before deployment. That means fewer blind spots, fewer regressions, and a more trustworthy path from code generation to production.”

Jackson sees potential for “concept catalogs” – shared libraries of well-tested concepts that teams can reuse. Application development could become less about writing code from scratch and more about selecting the right concepts and defining how they work together.

“It’s a way of making the connections in software visible,” Jackson says. “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.”

This won’t solve every problem in software development. You still have to deal with complexity. Features still interact in complicated ways. But at least that complexity is visible. It’s not buried in code you can’t see.

For teams using AI coding tools, this could make the difference between code that works and code that creates more problems. And in DevOps, where reliability matters more than speed alone, that’s worth paying attention to.